diff --git a/.clangd b/.clangd
index c864a33..adf7a53 100644
--- a/.clangd
+++ b/.clangd
@@ -1,2 +1,2 @@
 CompileFlags:
-  Add: [-std=c++2b, -Wunused-function]
+  Add: [-std=c++20, -Wunused-function]
diff --git a/flake.lock b/flake.lock
index bce19fc..9eb57a1 100644
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1717112898,
-        "narHash": "sha256-7R2ZvOnvd9h8fDd65p0JnB7wXfUvreox3xFdYWd1BnY=",
+        "lastModified": 1717430266,
+        "narHash": "sha256-EWy2Qbkl/HUwmO8KDBzgDQf+4rl+fLiPFvp3nUSWcxc=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "6132b0f6e344ce2fe34fc051b72fb46e34f668e0",
+        "rev": "d125f0e4d85f1517b639d4a8f848175da46fcd3e",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index c5e9e7a..40ddb97 100644
--- a/flake.nix
+++ b/flake.nix
@@ -46,7 +46,12 @@
           ];
         };
 
-        stdenv = pkgs.stdenvAdapters.useMoldLinker pkgs.llvmPackages_18.stdenv;
+        stdenv = pkgs.llvmPackages_18.stdenv;
+
+        darwinPkgs = nixpkgs.lib.optionals pkgs.stdenv.isDarwin (with pkgs.darwin; [
+          apple_sdk.frameworks.CoreFoundation
+          apple_sdk.frameworks.MediaPlayer
+        ]);
       in
         with pkgs; {
           packages = rec {
@@ -72,7 +77,7 @@
                 ]);
 
               buildInputs = [
-                boost185
+                coost
                 fmt
               ];
 
@@ -105,19 +110,22 @@
                 ninja
                 pkg-config
 
-                boost185
+                coost
                 fmt
                 glib
                 libcpr
                 tomlplusplus
               ]
-              ++ (lib.optionals pkgs.hostPlatform.isLinux [playerctl]);
+              ++ (lib.optionals pkgs.hostPlatform.isLinux [playerctl])
+              ++ darwinPkgs;
 
-            buildInputs = [
-              boost185
-              libcpr
-              tomlplusplus
-            ];
+            buildInputs =
+              [
+                coost
+                libcpr
+                tomlplusplus
+              ]
+              ++ darwinPkgs;
 
             name = "C++";
           };
diff --git a/include/rfl/bson.hpp b/include/rfl/bson.hpp
new file mode 100644
index 0000000..29ca2c5
--- /dev/null
+++ b/include/rfl/bson.hpp
@@ -0,0 +1,13 @@
+#ifndef RFL_BSON_HPP_
+#define RFL_BSON_HPP_
+
+#include "../rfl.hpp"
+#include "bson/Parser.hpp"
+#include "bson/Reader.hpp"
+#include "bson/Writer.hpp"
+#include "bson/load.hpp"
+#include "bson/read.hpp"
+#include "bson/save.hpp"
+#include "bson/write.hpp"
+
+#endif
diff --git a/include/rfl/bson/Parser.hpp b/include/rfl/bson/Parser.hpp
new file mode 100644
index 0000000..60352b2
--- /dev/null
+++ b/include/rfl/bson/Parser.hpp
@@ -0,0 +1,50 @@
+#ifndef RFL_BSON_PARSER_HPP_
+#define RFL_BSON_PARSER_HPP_
+
+#include <bson/bson.h>
+
+#include "../parsing/Parser.hpp"
+#include "Reader.hpp"
+#include "Writer.hpp"
+
+namespace rfl::parsing {
+
+/// bson_oid_t needs to be treated as a special case, otherwise it will be read
+/// as a struct.
+template <class R, class W, class ProcessorsType>
+requires AreReaderAndWriter<R, W, bson_oid_t>
+struct Parser<R, W, ProcessorsType, bson_oid_t> {
+  using InputVarType = typename R::InputVarType;
+  using OutputVarType = typename W::OutputVarType;
+
+  using ParentType = Parent<W>;
+
+  static Result<bson_oid_t> read(const R& _r,
+                                 const InputVarType& _var) noexcept {
+    return _r.template to_basic_type<bson_oid_t>(_var);
+  }
+
+  template <class P>
+  static void write(const W& _w, const bson_oid_t& _oid,
+                    const P& _parent) noexcept {
+    ParentType::add_value(_w, _oid, _parent);
+  }
+
+  static schema::Type to_schema(
+      std::map<std::string, schema::Type>* _definitions) {
+    static_assert(rfl::always_false_v<R>,
+                  "bson_oid_t cannot be expressed inside a JSON schema.");
+    return schema::Type{schema::Type::String{}};
+  }
+};
+
+}  // namespace rfl::parsing
+
+namespace rfl::bson {
+
+template <class T, class ProcessorsType>
+using Parser = parsing::Parser<Reader, Writer, T, ProcessorsType>;
+
+}  // namespace rfl::bson
+
+#endif
diff --git a/include/rfl/bson/Reader.hpp b/include/rfl/bson/Reader.hpp
new file mode 100644
index 0000000..dedcff4
--- /dev/null
+++ b/include/rfl/bson/Reader.hpp
@@ -0,0 +1,217 @@
+#ifndef RFL_BSON_READER_HPP_
+#define RFL_BSON_READER_HPP_
+
+#include <bson/bson.h>
+
+#include <array>
+#include <concepts>
+#include <exception>
+#include <map>
+#include <memory>
+#include <optional>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+#include "../Box.hpp"
+#include "../Result.hpp"
+#include "../always_false.hpp"
+
+namespace rfl {
+namespace bson {
+
+/// Please refer to https://mongoc.org/libbson/current/api.html
+struct Reader {
+  struct BSONValue {
+    bson_value_t val_;
+  };
+
+  struct BSONInputArray {
+    BSONValue* val_;
+  };
+
+  struct BSONInputObject {
+    BSONValue* val_;
+  };
+
+  struct BSONInputVar {
+    BSONValue* val_;
+  };
+
+  using InputArrayType = BSONInputArray;
+  using InputObjectType = BSONInputObject;
+  using InputVarType = BSONInputVar;
+
+  template <class T>
+  static constexpr bool has_custom_constructor = (requires(InputVarType var) {
+    T::from_bson_obj(var);
+  });
+
+  rfl::Result<InputVarType> get_field(
+      const std::string& _name, const InputObjectType& _obj) const noexcept {
+    bson_t b;
+    bson_iter_t iter;
+    const auto doc = _obj.val_->val_.value.v_doc;
+    if (bson_init_static(&b, doc.data, doc.data_len)) {
+      if (bson_iter_init(&iter, &b)) {
+        while (bson_iter_next(&iter)) {
+          auto key = std::string(bson_iter_key(&iter));
+          if (key == _name) {
+            return to_input_var(&iter);
+          }
+        }
+      }
+    }
+    return Error("No field named '" + _name + "' was found.");
+  }
+
+  bool is_empty(const InputVarType& _var) const noexcept {
+    return _var.val_->val_.value_type == BSON_TYPE_NULL;
+  }
+
+  template <class T>
+  rfl::Result<T> to_basic_type(const InputVarType& _var) const noexcept {
+    const auto btype = _var.val_->val_.value_type;
+    const auto value = _var.val_->val_.value;
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      switch (btype) {
+        case BSON_TYPE_UTF8:
+          return std::string(value.v_utf8.str, value.v_utf8.len);
+
+        case BSON_TYPE_SYMBOL:
+          return std::string(value.v_symbol.symbol, value.v_symbol.len);
+
+        default:
+          return rfl::Error(
+              "Could not cast to string. The type must be UTF8 or symbol.");
+      }
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      if (btype != BSON_TYPE_BOOL) {
+        return rfl::Error("Could not cast to boolean.");
+      }
+      return value.v_bool;
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>() ||
+                         std::is_integral<std::remove_cvref_t<T>>()) {
+      switch (btype) {
+        case BSON_TYPE_DOUBLE:
+          return static_cast<T>(value.v_double);
+
+        case BSON_TYPE_INT32:
+          return static_cast<T>(value.v_int32);
+
+        case BSON_TYPE_INT64:
+          return static_cast<T>(value.v_int64);
+
+        case BSON_TYPE_DATE_TIME:
+          return static_cast<T>(value.v_datetime);
+
+        default:
+          return rfl::Error(
+              "Could not cast to numeric value. The type must be double, "
+              "int32, int64 or date_time.");
+      }
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bson_oid_t>()) {
+      if (btype != BSON_TYPE_OID) {
+        return rfl::Error("Could not cast to OID.");
+      }
+      return value.v_oid;
+    } else {
+      static_assert(rfl::always_false_v<T>, "Unsupported type.");
+    }
+  }
+
+  rfl::Result<InputArrayType> to_array(
+      const InputVarType& _var) const noexcept {
+    const auto btype = _var.val_->val_.value_type;
+    if (btype != BSON_TYPE_ARRAY && btype != BSON_TYPE_DOCUMENT) {
+      return Error("Could not cast to an array.");
+    }
+    return InputArrayType{_var.val_};
+  }
+
+  template <class ArrayReader>
+  std::optional<Error> read_array(const ArrayReader& _array_reader,
+                                  const InputArrayType& _arr) const noexcept {
+    bson_t b;
+    bson_iter_t iter;
+    const auto doc = _arr.val_->val_.value.v_doc;
+    if (bson_init_static(&b, doc.data, doc.data_len)) {
+      if (bson_iter_init(&iter, &b)) {
+        while (bson_iter_next(&iter)) {
+          const auto err = _array_reader.read(to_input_var(&iter));
+          if (err) {
+            return err;
+          }
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  template <class ObjectReader>
+  std::optional<Error> read_object(const ObjectReader& _object_reader,
+                                   const InputObjectType& _obj) const noexcept {
+    bson_t b;
+    bson_iter_t iter;
+    const auto doc = _obj.val_->val_.value.v_doc;
+    if (bson_init_static(&b, doc.data, doc.data_len)) {
+      if (bson_iter_init(&iter, &b)) {
+        while (bson_iter_next(&iter)) {
+          const char* k = bson_iter_key(&iter);
+          _object_reader.read(std::string_view(k), to_input_var(&iter));
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  rfl::Result<InputObjectType> to_object(
+      const InputVarType& _var) const noexcept {
+    const auto btype = _var.val_->val_.value_type;
+    if (btype != BSON_TYPE_DOCUMENT) {
+      return Error("Could not cast to a document.");
+    }
+    return InputObjectType{_var.val_};
+  }
+
+  template <class T>
+  rfl::Result<T> use_custom_constructor(
+      const InputVarType& _var) const noexcept {
+    try {
+      return T::from_bson_obj(_var);
+    } catch (std::exception& e) {
+      return rfl::Error(e.what());
+    }
+  }
+
+ private:
+  struct BSONValues {
+    std::vector<rfl::Box<BSONValue>> vec_;
+    ~BSONValues() {
+      for (auto& v : vec_) {
+        bson_value_destroy(&(v->val_));
+      }
+    }
+  };
+
+ private:
+  InputVarType to_input_var(bson_iter_t* _iter) const noexcept {
+    values_->vec_.emplace_back(rfl::Box<BSONValue>::make());
+    auto* last_value = values_->vec_.back().get();
+    bson_value_copy(bson_iter_value(_iter), &last_value->val_);
+    return InputVarType{last_value};
+  }
+
+ private:
+  /// Contains the values inside the object.
+  rfl::Ref<BSONValues> values_;
+};
+
+}  // namespace bson
+}  // namespace rfl
+
+#endif  // JSON_PARSER_HPP_
diff --git a/include/rfl/bson/Writer.hpp b/include/rfl/bson/Writer.hpp
new file mode 100644
index 0000000..aac627a
--- /dev/null
+++ b/include/rfl/bson/Writer.hpp
@@ -0,0 +1,227 @@
+#ifndef RFL_BSON_WRITER_HPP_
+#define RFL_BSON_WRITER_HPP_
+
+#include <bson/bson.h>
+
+#include <exception>
+#include <map>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <variant>
+#include <vector>
+
+#include "../Box.hpp"
+#include "../Ref.hpp"
+#include "../Result.hpp"
+#include "../always_false.hpp"
+
+namespace rfl {
+namespace bson {
+
+/// Please refer to https://mongoc.org/libbson/current/api.html
+class Writer {
+  struct BSONType {
+    bson_t val_;
+  };
+
+  struct IsArray {
+    bson_array_builder_t* ptr_;
+  };
+
+  struct IsObject {
+    bson_t* ptr_;
+  };
+
+  struct IsRoot {};
+
+  using ParentType = std::variant<IsArray, IsObject, IsRoot>;
+
+ public:
+  struct BSONOutputArray {
+    BSONOutputArray(bson_array_builder_t* _val, ParentType _parent)
+        : parent_(_parent), val_(_val) {}
+    ParentType parent_;
+    bson_array_builder_t* val_;
+  };
+
+  struct BSONOutputObject {
+    BSONOutputObject(bson_t* _val, ParentType _parent)
+        : parent_(_parent), val_(_val) {}
+    ParentType parent_;
+    bson_t* val_;
+  };
+
+  struct BSONOutputVar {};
+
+  using OutputArrayType = BSONOutputArray;
+  using OutputObjectType = BSONOutputObject;
+  using OutputVarType = BSONOutputVar;
+
+  Writer(bson_t* _doc) : doc_(_doc) {}
+
+  ~Writer() = default;
+
+  OutputArrayType array_as_root(const size_t _size) const noexcept {
+    bson_array_builder_t* val = bson_array_builder_new();
+    return OutputArrayType(val, IsRoot{});
+  }
+
+  OutputObjectType object_as_root(const size_t _size) const noexcept {
+    return OutputObjectType(doc_, IsRoot{});
+  }
+
+  OutputVarType null_as_root() const noexcept {
+    // Appears to be unsupported by the BSON C API.
+    return OutputVarType{};
+  }
+
+  template <class T>
+  OutputVarType value_as_root(const T& _var) const noexcept {
+    static_assert(rfl::always_false_v<T>,
+                  "BSON only allows arrays or objects as its root.");
+    return OutputVarType{};
+  }
+
+  OutputArrayType add_array_to_array(const size_t _size,
+                                     OutputArrayType* _parent) const noexcept {
+    bson_array_builder_t* val;
+    bson_array_builder_append_array_builder_begin(_parent->val_, &val);
+    return OutputArrayType(val, IsArray{_parent->val_});
+  }
+
+  OutputArrayType add_array_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    bson_array_builder_t* val;
+    bson_append_array_builder_begin(_parent->val_, _name.data(),
+                                    static_cast<int>(_name.size()), &val);
+    return OutputArrayType(val, IsObject{_parent->val_});
+  }
+
+  OutputObjectType add_object_to_array(
+      const size_t _size, OutputArrayType* _parent) const noexcept {
+    subdocs_->emplace_back(rfl::Box<BSONType>());
+    bson_array_builder_append_document_begin(_parent->val_,
+                                             &(subdocs_->back()->val_));
+    return OutputObjectType(&subdocs_->back()->val_, IsArray{_parent->val_});
+  }
+
+  OutputObjectType add_object_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    subdocs_->emplace_back(rfl::Box<BSONType>());
+    bson_append_document_begin(_parent->val_, _name.data(),
+                               static_cast<int>(_name.size()),
+                               &(subdocs_->back()->val_));
+    return OutputObjectType(&subdocs_->back()->val_, IsObject{_parent->val_});
+  }
+
+  template <class T>
+  OutputVarType add_value_to_array(const T& _var,
+                                   OutputArrayType* _parent) const noexcept {
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      bson_array_builder_append_utf8(_parent->val_, _var.c_str(),
+                                     static_cast<int>(_var.size()));
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      bson_array_builder_append_bool(_parent->val_, _var);
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
+      bson_array_builder_append_double(_parent->val_,
+                                       static_cast<double>(_var));
+    } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
+      bson_array_builder_append_int64(_parent->val_,
+                                      static_cast<std::int64_t>(_var));
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bson_oid_t>()) {
+      bson_array_builder_append_oid(_parent->val_, &_var);
+    } else {
+      static_assert(rfl::always_false_v<T>, "Unsupported type.");
+    }
+    return OutputVarType{};
+  }
+
+  template <class T>
+  OutputVarType add_value_to_object(const std::string_view& _name,
+                                    const T& _var,
+                                    OutputObjectType* _parent) const noexcept {
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      bson_append_utf8(_parent->val_, _name.data(),
+                       static_cast<int>(_name.size()), _var.c_str(),
+                       static_cast<int>(_var.size()));
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      bson_append_bool(_parent->val_, _name.data(),
+                       static_cast<int>(_name.size()), _var);
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
+      bson_append_double(_parent->val_, _name.data(),
+                         static_cast<int>(_name.size()),
+                         static_cast<double>(_var));
+    } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
+      bson_append_int64(_parent->val_, _name.data(),
+                        static_cast<int>(_name.size()),
+                        static_cast<std::int64_t>(_var));
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bson_oid_t>()) {
+      bson_append_oid(_parent->val_, _name.data(),
+                      static_cast<int>(_name.size()), &_var);
+    } else {
+      static_assert(rfl::always_false_v<T>, "Unsupported type.");
+    }
+    return OutputVarType{};
+  }
+
+  OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept {
+    bson_array_builder_append_null(_parent->val_);
+    return OutputVarType{};
+  }
+
+  OutputVarType add_null_to_object(const std::string_view& _name,
+                                   OutputObjectType* _parent) const noexcept {
+    bson_append_null(_parent->val_, _name.data(),
+                     static_cast<int>(_name.size()));
+    return OutputVarType{};
+  }
+
+  void end_array(OutputArrayType* _arr) const noexcept {
+    const auto handle = [&](const auto _parent) {
+      using Type = std::remove_cvref_t<decltype(_parent)>;
+      if constexpr (std::is_same<Type, IsArray>()) {
+        bson_array_builder_append_array_builder_end(_parent.ptr_, _arr->val_);
+      } else if constexpr (std::is_same<Type, IsObject>()) {
+        bson_append_array_builder_end(_parent.ptr_, _arr->val_);
+      } else if constexpr (std::is_same<Type, IsRoot>()) {
+        bson_array_builder_build(_arr->val_, doc_);
+      } else {
+        static_assert(rfl::always_false_v<Type>, "Unsupported type.");
+      }
+    };
+    std::visit(handle, _arr->parent_);
+  }
+
+  void end_object(OutputObjectType* _obj) const noexcept {
+    const auto handle = [&](const auto _parent) {
+      using Type = std::remove_cvref_t<decltype(_parent)>;
+      if constexpr (std::is_same<Type, IsArray>()) {
+        bson_array_builder_append_document_end(_parent.ptr_, _obj->val_);
+      } else if constexpr (std::is_same<Type, IsObject>()) {
+        bson_append_document_end(_parent.ptr_, _obj->val_);
+      } else if constexpr (std::is_same<Type, IsRoot>()) {
+      } else {
+        static_assert(rfl::always_false_v<Type>, "Unsupported type.");
+      }
+    };
+    std::visit(handle, _obj->parent_);
+  }
+
+ private:
+  /// Pointer to the main document. In BSON, documents are what are usually
+  /// called objects.
+  bson_t* const doc_;
+
+  /// Contain all of the subdocuments.
+  const rfl::Ref<std::vector<rfl::Box<BSONType>>> subdocs_;
+};
+
+}  // namespace bson
+}  // namespace rfl
+
+#endif  // BSON_PARSER_HPP_
diff --git a/include/rfl/bson/load.hpp b/include/rfl/bson/load.hpp
new file mode 100644
index 0000000..05cd9b7
--- /dev/null
+++ b/include/rfl/bson/load.hpp
@@ -0,0 +1,22 @@
+#ifndef RFL_BSON_LOAD_HPP_
+#define RFL_BSON_LOAD_HPP_
+
+#include "../Result.hpp"
+#include "../io/load_bytes.hpp"
+#include "read.hpp"
+
+namespace rfl {
+namespace bson {
+
+template <class T, class... Ps>
+Result<T> load(const std::string& _fname) {
+  const auto read_bytes = [](const auto& _bytes) {
+    return read<T, Ps...>(_bytes);
+  };
+  return rfl::io::load_bytes(_fname).and_then(read_bytes);
+}
+
+}  // namespace bson
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/bson/read.hpp b/include/rfl/bson/read.hpp
new file mode 100644
index 0000000..2ee5bc3
--- /dev/null
+++ b/include/rfl/bson/read.hpp
@@ -0,0 +1,61 @@
+#ifndef RFL_BSON_READ_HPP_
+#define RFL_BSON_READ_HPP_
+
+#include <bson/bson.h>
+
+#include <istream>
+#include <string>
+
+#include "../Processors.hpp"
+#include "../internal/wrap_in_rfl_array_t.hpp"
+#include "Parser.hpp"
+#include "Reader.hpp"
+
+namespace rfl {
+namespace bson {
+
+using InputObjectType = typename Reader::InputObjectType;
+using InputVarType = typename Reader::InputVarType;
+
+/// Parses an object from a BSON var.
+template <class T, class... Ps>
+Result<internal::wrap_in_rfl_array_t<T>> read(const InputVarType& _obj) {
+  const auto r = Reader();
+  return Parser<T, Processors<Ps...>>::read(r, _obj);
+}
+
+/// Parses an BSON object using reflection.
+template <class T, class... Ps>
+auto read(const uint8_t* _bytes, const size_t _size) {
+  Reader::BSONValue value;
+  value.val_.value.v_doc.data_len = static_cast<uint32_t>(_size);
+  value.val_.value.v_doc.data = const_cast<uint8_t*>(_bytes);
+  value.val_.value_type = BSON_TYPE_DOCUMENT;
+  auto doc = InputVarType{&value};
+  return read<T, Ps...>(doc);
+}
+
+/// Parses an BSON object using reflection.
+template <class T, class... Ps>
+auto read(const char* _bytes, const size_t _size) {
+  return read<T, Ps...>(reinterpret_cast<const uint8_t*>(_bytes), _size);
+}
+
+/// Parses an object from BSON using reflection.
+template <class T, class... Ps>
+auto read(const std::vector<char>& _bytes) {
+  return read<T, Ps...>(_bytes.data(), _bytes.size());
+}
+
+/// Parses an object from a stream.
+template <class T, class... Ps>
+auto read(std::istream& _stream) {
+  std::istreambuf_iterator<char> begin(_stream), end;
+  auto bytes = std::vector<char>(begin, end);
+  return read<T, Ps...>(bytes.data(), bytes.size());
+}
+
+}  // namespace bson
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/bson/save.hpp b/include/rfl/bson/save.hpp
new file mode 100644
index 0000000..3ebbeda
--- /dev/null
+++ b/include/rfl/bson/save.hpp
@@ -0,0 +1,26 @@
+#ifndef RFL_BSON_SAVE_HPP_
+#define RFL_BSON_SAVE_HPP_
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#include "../Result.hpp"
+#include "../io/save_bytes.hpp"
+#include "write.hpp"
+
+namespace rfl {
+namespace bson {
+
+template <class... Ps>
+Result<Nothing> save(const std::string& _fname, const auto& _obj) {
+  const auto write_func = [](const auto& _obj, auto& _stream) -> auto& {
+    return write<Ps...>(_obj, _stream);
+  };
+  return rfl::io::save_bytes(_fname, _obj, write_func);
+}
+
+}  // namespace bson
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/bson/write.hpp b/include/rfl/bson/write.hpp
new file mode 100644
index 0000000..a22e750
--- /dev/null
+++ b/include/rfl/bson/write.hpp
@@ -0,0 +1,61 @@
+#ifndef RFL_BSON_WRITE_HPP_
+#define RFL_BSON_WRITE_HPP_
+
+#include <bson/bson.h>
+
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "../Processors.hpp"
+#include "../parsing/Parent.hpp"
+#include "Parser.hpp"
+
+namespace rfl {
+namespace bson {
+
+/// Returns BSON bytes. Careful: It is the responsibility of the caller to call
+/// bson_free on the returned pointer.
+template <class... Ps>
+std::pair<uint8_t*, size_t> to_buffer(const auto& _obj) noexcept {
+  using T = std::remove_cvref_t<decltype(_obj)>;
+  using ParentType = parsing::Parent<Writer>;
+  bson_t* doc = nullptr;
+  uint8_t* buf = nullptr;
+  size_t buflen = 0;
+  bson_writer_t* bson_writer =
+      bson_writer_new(&buf, &buflen, 0, bson_realloc_ctx, NULL);
+  bson_writer_begin(bson_writer, &doc);
+  const auto rfl_writer = Writer(doc);
+  Parser<T, Processors<Ps...>>::write(rfl_writer, _obj,
+                                      typename ParentType::Root{});
+  bson_writer_end(bson_writer);
+  const auto len = bson_writer_get_length(bson_writer);
+  bson_writer_destroy(bson_writer);
+  return std::make_pair(buf, len);
+}
+
+/// Returns BSON bytes.
+template <class... Ps>
+std::vector<char> write(const auto& _obj) noexcept {
+  auto [buf, len] = to_buffer<Ps...>(_obj);
+  const auto result = std::vector<char>(reinterpret_cast<char*>(buf),
+                                        reinterpret_cast<char*>(buf) + len);
+  bson_free(buf);
+  return result;
+}
+
+/// Writes a BSON into an ostream.
+template <class... Ps>
+std::ostream& write(const auto& _obj, std::ostream& _stream) noexcept {
+  auto [buf, len] = to_buffer<Ps...>(_obj);
+  _stream.write(reinterpret_cast<const char*>(buf), len);
+  bson_free(buf);
+  return _stream;
+}
+
+}  // namespace bson
+}  // namespace rfl
+
+#endif  // BSON_PARSER_HPP_
diff --git a/include/rfl/cbor.hpp b/include/rfl/cbor.hpp
new file mode 100644
index 0000000..e539617
--- /dev/null
+++ b/include/rfl/cbor.hpp
@@ -0,0 +1,13 @@
+#ifndef RFL_CBOR_HPP_
+#define RFL_CBOR_HPP_
+
+#include "../rfl.hpp"
+#include "cbor/Parser.hpp"
+#include "cbor/Reader.hpp"
+#include "cbor/Writer.hpp"
+#include "cbor/load.hpp"
+#include "cbor/read.hpp"
+#include "cbor/save.hpp"
+#include "cbor/write.hpp"
+
+#endif
diff --git a/include/rfl/cbor/Parser.hpp b/include/rfl/cbor/Parser.hpp
new file mode 100644
index 0000000..811978d
--- /dev/null
+++ b/include/rfl/cbor/Parser.hpp
@@ -0,0 +1,45 @@
+#ifndef RFL_CBOR_PARSER_HPP_
+#define RFL_CBOR_PARSER_HPP_
+
+#include "../parsing/Parser.hpp"
+#include "Reader.hpp"
+#include "Writer.hpp"
+
+namespace rfl {
+namespace parsing {
+
+/// CBOR requires us to explicitly set the number of fields in advance. Because
+/// of that, we require all of the fields and then set them to nullptr, if
+/// necessary.
+template <class ProcessorsType, class... FieldTypes>
+requires AreReaderAndWriter<cbor::Reader, cbor::Writer,
+                            NamedTuple<FieldTypes...>>
+struct Parser<cbor::Reader, cbor::Writer, NamedTuple<FieldTypes...>,
+              ProcessorsType>
+    : public NamedTupleParser<cbor::Reader, cbor::Writer,
+                              /*_ignore_empty_containers=*/false,
+                              /*_all_required=*/true, ProcessorsType,
+                              FieldTypes...> {
+};
+
+template <class ProcessorsType, class... Ts>
+requires AreReaderAndWriter<cbor::Reader, cbor::Writer, std::tuple<Ts...>>
+struct Parser<cbor::Reader, cbor::Writer, std::tuple<Ts...>, ProcessorsType>
+    : public TupleParser<cbor::Reader, cbor::Writer,
+                         /*_ignore_empty_containers=*/false,
+                         /*_all_required=*/true, ProcessorsType, Ts...> {
+};
+
+}  // namespace parsing
+}  // namespace rfl
+
+namespace rfl {
+namespace cbor {
+
+template <class T, class ProcessorsType>
+using Parser = parsing::Parser<Reader, Writer, T, ProcessorsType>;
+
+}
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/cbor/Reader.hpp b/include/rfl/cbor/Reader.hpp
new file mode 100644
index 0000000..42b1aee
--- /dev/null
+++ b/include/rfl/cbor/Reader.hpp
@@ -0,0 +1,259 @@
+#ifndef RFL_CBOR_READER_HPP_
+#define RFL_CBOR_READER_HPP_
+
+#include <cbor.h>
+
+#include <array>
+#include <concepts>
+#include <exception>
+#include <map>
+#include <memory>
+#include <source_location>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+#include "../Box.hpp"
+#include "../Result.hpp"
+#include "../always_false.hpp"
+
+namespace rfl {
+namespace cbor {
+
+/// Please refer to https://intel.github.io/tinycbor/current/index.html
+struct Reader {
+  struct CBORInputArray {
+    CborValue* val_;
+  };
+
+  struct CBORInputObject {
+    CborValue* val_;
+  };
+
+  struct CBORInputVar {
+    CborValue* val_;
+  };
+
+  using InputArrayType = CBORInputArray;
+  using InputObjectType = CBORInputObject;
+  using InputVarType = CBORInputVar;
+
+  template <class T>
+  static constexpr bool has_custom_constructor = (requires(InputVarType var) {
+    T::from_cbor_obj(var);
+  });
+
+  rfl::Result<InputVarType> get_field(
+      const std::string& _name, const InputObjectType& _obj) const noexcept {
+    CborValue val;
+    auto buffer = std::vector<char>();
+    auto err = cbor_value_enter_container(_obj.val_, &val);
+    if (err != CborNoError) {
+      return Error(cbor_error_string(err));
+    }
+    size_t length = 0;
+    err = cbor_value_get_map_length(_obj.val_, &length);
+    if (err != CborNoError) {
+      return Error(cbor_error_string(err));
+    }
+    for (size_t i = 0; i < length; ++i) {
+      if (!cbor_value_is_text_string(&val)) {
+        return Error("Expected the key to be a string value.");
+      }
+      err = get_string(&val, &buffer);
+      if (err != CborNoError) {
+        return Error(cbor_error_string(err));
+      }
+      err = cbor_value_advance(&val);
+      if (err != CborNoError) {
+        return Error(cbor_error_string(err));
+      }
+      if (_name == buffer.data()) {
+        return to_input_var(&val);
+      }
+      err = cbor_value_advance(&val);
+      if (err != CborNoError) {
+        return Error(cbor_error_string(err));
+      }
+    }
+    return Error("No field named '" + _name + "' was found.");
+  }
+
+  bool is_empty(const InputVarType& _var) const noexcept {
+    return cbor_value_is_null(_var.val_);
+  }
+
+  template <class T>
+  rfl::Result<T> to_basic_type(const InputVarType& _var) const noexcept {
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      if (!cbor_value_is_text_string(_var.val_)) {
+        return Error("Could not cast to string.");
+      }
+      std::vector<char> buffer;
+      const auto err = get_string(_var.val_, &buffer);
+      if (err != CborNoError) {
+        return Error(cbor_error_string(err));
+      }
+      return std::string(buffer.data());
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      if (!cbor_value_is_boolean(_var.val_)) {
+        return rfl::Error("Could not cast to boolean.");
+      }
+      bool result = false;
+      const auto err = cbor_value_get_boolean(_var.val_, &result);
+      if (err != CborNoError) {
+        return Error(cbor_error_string(err));
+      }
+      return result;
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>() ||
+                         std::is_integral<std::remove_cvref_t<T>>()) {
+      if (cbor_value_is_integer(_var.val_)) {
+        std::int64_t result = 0;
+        const auto err = cbor_value_get_int64(_var.val_, &result);
+        if (err != CborNoError) {
+          return Error(cbor_error_string(err));
+        }
+        return static_cast<T>(result);
+      } else if (cbor_value_is_float(_var.val_)) {
+        float result = 0.0;
+        const auto err = cbor_value_get_float(_var.val_, &result);
+        if (err != CborNoError) {
+          return Error(cbor_error_string(err));
+        }
+        return static_cast<T>(result);
+      } else if (cbor_value_is_double(_var.val_)) {
+        double result = 0.0;
+        const auto err = cbor_value_get_double(_var.val_, &result);
+        if (err != CborNoError) {
+          return Error(cbor_error_string(err));
+        }
+        return static_cast<T>(result);
+      }
+      return rfl::Error(
+          "Could not cast to numeric value. The type must be integral, float "
+          "or double.");
+
+    } else {
+      static_assert(rfl::always_false_v<T>, "Unsupported type.");
+    }
+  }
+
+  rfl::Result<InputArrayType> to_array(
+      const InputVarType& _var) const noexcept {
+    if (!cbor_value_is_array(_var.val_)) {
+      return Error("Could not cast to an array.");
+    }
+    return InputArrayType{_var.val_};
+  }
+
+  rfl::Result<InputObjectType> to_object(
+      const InputVarType& _var) const noexcept {
+    if (!cbor_value_is_map(_var.val_)) {
+      return Error("Could not cast to an object.");
+    }
+    return InputObjectType{_var.val_};
+  }
+
+  template <class ArrayReader>
+  std::optional<Error> read_array(const ArrayReader& _array_reader,
+                                  const InputArrayType& _arr) const noexcept {
+    CborValue val;
+    auto buffer = std::vector<char>();
+    auto err = cbor_value_enter_container(_arr.val_, &val);
+    if (err != CborNoError && err != CborErrorOutOfMemory) {
+      return Error(cbor_error_string(err));
+    }
+    size_t length = 0;
+    err = cbor_value_get_array_length(_arr.val_, &length);
+    if (err != CborNoError && err != CborErrorOutOfMemory) {
+      return Error(cbor_error_string(err));
+    }
+    for (size_t i = 0; i < length; ++i) {
+      const auto err2 = _array_reader.read(to_input_var(&val));
+      if (err2) {
+        return err2;
+      }
+      err = cbor_value_advance(&val);
+      if (err != CborNoError && err != CborErrorOutOfMemory) {
+        return Error(cbor_error_string(err));
+      }
+    }
+    return std::nullopt;
+  }
+
+  template <class ObjectReader>
+  std::optional<Error> read_object(const ObjectReader& _object_reader,
+                                   const InputObjectType& _obj) const noexcept {
+    size_t length = 0;
+    auto err = cbor_value_get_map_length(_obj.val_, &length);
+    if (err != CborNoError) {
+      return Error(cbor_error_string(err));
+    }
+
+    CborValue val;
+    err = cbor_value_enter_container(_obj.val_, &val);
+    if (err != CborNoError) {
+      return Error(cbor_error_string(err));
+    }
+
+    auto buffer = std::vector<char>();
+
+    for (size_t i = 0; i < length; ++i) {
+      err = get_string(&val, &buffer);
+      if (err != CborNoError) {
+        return Error(cbor_error_string(err));
+      }
+      err = cbor_value_advance(&val);
+      if (err != CborNoError) {
+        return Error(cbor_error_string(err));
+      }
+      const auto name = std::string_view(buffer.data(), buffer.size() - 1);
+      _object_reader.read(name, InputVarType{&val});
+      cbor_value_advance(&val);
+    }
+
+    return std::nullopt;
+  }
+
+  template <class T>
+  rfl::Result<T> use_custom_constructor(
+      const InputVarType& _var) const noexcept {
+    try {
+      return T::from_cbor_obj(_var);
+    } catch (std::exception& e) {
+      return rfl::Error(e.what());
+    }
+  }
+
+ private:
+  CborError get_string(const CborValue* _ptr,
+                       std::vector<char>* _buffer) const noexcept {
+    size_t length = 0;
+    auto err = cbor_value_get_string_length(_ptr, &length);
+    if (err != CborNoError && err != CborErrorOutOfMemory) {
+      return err;
+    }
+    _buffer->resize(length + 1);
+    (*_buffer)[length] = '\0';
+    return cbor_value_copy_text_string(_ptr, _buffer->data(), &length, NULL);
+  }
+
+  InputVarType to_input_var(CborValue* _ptr) const noexcept {
+    values_->emplace_back(rfl::Box<CborValue>::make(*_ptr));
+    auto* last_value = values_->back().get();
+    return InputVarType{last_value};
+  }
+
+ private:
+  /// Contains the values inside the object.
+  rfl::Box<std::vector<rfl::Box<CborValue>>> values_;
+};
+
+}  // namespace cbor
+}  // namespace rfl
+
+#endif  // JSON_PARSER_HPP_
diff --git a/include/rfl/cbor/Writer.hpp b/include/rfl/cbor/Writer.hpp
new file mode 100644
index 0000000..d2cb7d1
--- /dev/null
+++ b/include/rfl/cbor/Writer.hpp
@@ -0,0 +1,164 @@
+#ifndef RFL_CBOR_WRITER_HPP_
+#define RFL_CBOR_WRITER_HPP_
+
+#include <cbor.h>
+
+#include <exception>
+#include <map>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <variant>
+#include <vector>
+
+#include "../Box.hpp"
+#include "../Ref.hpp"
+#include "../Result.hpp"
+#include "../always_false.hpp"
+
+namespace rfl {
+namespace cbor {
+
+class Writer {
+ public:
+  struct CBOROutputArray {
+    CborEncoder* encoder_;
+    CborEncoder* parent_;
+  };
+
+  struct CBOROutputObject {
+    CborEncoder* encoder_;
+    CborEncoder* parent_;
+  };
+
+  struct CBOROutputVar {};
+
+  using OutputArrayType = CBOROutputArray;
+  using OutputObjectType = CBOROutputObject;
+  using OutputVarType = CBOROutputVar;
+
+  Writer(CborEncoder* _encoder) : encoder_(_encoder) {}
+
+  ~Writer() = default;
+
+  OutputArrayType array_as_root(const size_t _size) const noexcept {
+    return new_array(_size, encoder_);
+  }
+
+  OutputObjectType object_as_root(const size_t _size) const noexcept {
+    return new_object(_size, encoder_);
+  }
+
+  OutputVarType null_as_root() const noexcept {
+    cbor_encode_null(encoder_);
+    return OutputVarType{};
+  }
+
+  template <class T>
+  OutputVarType value_as_root(const T& _var) const noexcept {
+    return new_value(_var, encoder_);
+  }
+
+  OutputArrayType add_array_to_array(const size_t _size,
+                                     OutputArrayType* _parent) const noexcept {
+    return new_array(_size, _parent->encoder_);
+  }
+
+  OutputArrayType add_array_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    cbor_encode_text_string(_parent->encoder_, _name.data(), _name.size());
+    return new_array(_size, _parent->encoder_);
+  }
+
+  OutputObjectType add_object_to_array(
+      const size_t _size, OutputArrayType* _parent) const noexcept {
+    return new_object(_size, _parent->encoder_);
+  }
+
+  OutputObjectType add_object_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    cbor_encode_text_string(_parent->encoder_, _name.data(), _name.size());
+    return new_object(_size, _parent->encoder_);
+  }
+
+  template <class T>
+  OutputVarType add_value_to_array(const T& _var,
+                                   OutputArrayType* _parent) const noexcept {
+    return new_value(_var, _parent->encoder_);
+  }
+
+  template <class T>
+  OutputVarType add_value_to_object(const std::string_view& _name,
+                                    const T& _var,
+                                    OutputObjectType* _parent) const noexcept {
+    cbor_encode_text_string(_parent->encoder_, _name.data(), _name.size());
+    return new_value(_var, _parent->encoder_);
+  }
+
+  OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept {
+    cbor_encode_null(_parent->encoder_);
+    return OutputVarType{};
+  }
+
+  OutputVarType add_null_to_object(const std::string_view& _name,
+                                   OutputObjectType* _parent) const noexcept {
+    cbor_encode_text_string(_parent->encoder_, _name.data(), _name.size());
+    cbor_encode_null(_parent->encoder_);
+    return OutputVarType{};
+  }
+
+  void end_array(OutputArrayType* _arr) const noexcept {
+    cbor_encoder_close_container(_arr->parent_, _arr->encoder_);
+  }
+
+  void end_object(OutputObjectType* _obj) const noexcept {
+    cbor_encoder_close_container(_obj->parent_, _obj->encoder_);
+  }
+
+ private:
+  OutputArrayType new_array(const size_t _size,
+                            CborEncoder* _parent) const noexcept {
+    subencoders_->emplace_back(rfl::Box<CborEncoder>::make());
+    cbor_encoder_create_array(_parent, subencoders_->back().get(), _size);
+    return OutputArrayType{subencoders_->back().get(), _parent};
+  }
+
+  OutputObjectType new_object(const size_t _size,
+                              CborEncoder* _parent) const noexcept {
+    subencoders_->emplace_back(rfl::Box<CborEncoder>::make());
+    cbor_encoder_create_map(_parent, subencoders_->back().get(), _size);
+    return OutputObjectType{subencoders_->back().get(), _parent};
+  }
+
+  template <class T>
+  OutputVarType new_value(const T& _var, CborEncoder* _parent) const noexcept {
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      cbor_encode_text_string(_parent, _var.c_str(), _var.size());
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      cbor_encode_boolean(_parent, _var);
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
+      cbor_encode_double(_parent, static_cast<double>(_var));
+    } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
+      cbor_encode_int(_parent, static_cast<std::int64_t>(_var));
+    } else {
+      static_assert(rfl::always_false_v<T>, "Unsupported type.");
+    }
+    return OutputVarType{};
+  }
+
+ private:
+  /// The underlying TinyCBOR encoder.
+  CborEncoder* const encoder_;
+
+  /// Contain all of the subobjects and subarrays.
+  const rfl::Box<std::vector<rfl::Box<CborEncoder>>> subencoders_;
+};
+
+}  // namespace cbor
+}  // namespace rfl
+
+#endif  // CBOR_PARSER_HPP_
diff --git a/include/rfl/cbor/load.hpp b/include/rfl/cbor/load.hpp
new file mode 100644
index 0000000..574ea00
--- /dev/null
+++ b/include/rfl/cbor/load.hpp
@@ -0,0 +1,23 @@
+#ifndef RFL_CBOR_LOAD_HPP_
+#define RFL_CBOR_LOAD_HPP_
+
+#include "../Processors.hpp"
+#include "../Result.hpp"
+#include "../io/load_bytes.hpp"
+#include "read.hpp"
+
+namespace rfl {
+namespace cbor {
+
+template <class T, class... Ps>
+Result<T> load(const std::string& _fname) {
+  const auto read_bytes = [](const auto& _bytes) {
+    return read<T, Ps...>(_bytes);
+  };
+  return rfl::io::load_bytes(_fname).and_then(read_bytes);
+}
+
+}  // namespace cbor
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/cbor/read.hpp b/include/rfl/cbor/read.hpp
new file mode 100644
index 0000000..32abb59
--- /dev/null
+++ b/include/rfl/cbor/read.hpp
@@ -0,0 +1,57 @@
+#ifndef RFL_CBOR_READ_HPP_
+#define RFL_CBOR_READ_HPP_
+
+#include <cbor.h>
+
+#include <istream>
+#include <string>
+
+#include "../Processors.hpp"
+#include "../internal/wrap_in_rfl_array_t.hpp"
+#include "Parser.hpp"
+#include "Reader.hpp"
+
+namespace rfl {
+namespace cbor {
+
+using InputObjectType = typename Reader::InputObjectType;
+using InputVarType = typename Reader::InputVarType;
+
+/// Parses an object from a CBOR var.
+template <class T, class... Ps>
+auto read(const InputVarType& _obj) {
+  const auto r = Reader();
+  return Parser<T, Processors<Ps...>>::read(r, _obj);
+}
+
+/// Parses an object from CBOR using reflection.
+template <class T, class... Ps>
+Result<internal::wrap_in_rfl_array_t<T>> read(const char* _bytes,
+                                              const size_t _size) {
+  CborParser parser;
+  CborValue value;
+  cbor_parser_init(reinterpret_cast<const uint8_t*>(_bytes), _size, 0, &parser,
+                   &value);
+  auto doc = InputVarType{&value};
+  auto result = read<T, Ps...>(doc);
+  return result;
+}
+
+/// Parses an object from CBOR using reflection.
+template <class T, class... Ps>
+auto read(const std::vector<char>& _bytes) {
+  return read<T, Ps...>(_bytes.data(), _bytes.size());
+}
+
+/// Parses an object from a stream.
+template <class T, class... Ps>
+auto read(std::istream& _stream) {
+  std::istreambuf_iterator<char> begin(_stream), end;
+  auto bytes = std::vector<char>(begin, end);
+  return read<T, Ps...>(bytes.data(), bytes.size());
+}
+
+}  // namespace cbor
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/cbor/save.hpp b/include/rfl/cbor/save.hpp
new file mode 100644
index 0000000..59343e0
--- /dev/null
+++ b/include/rfl/cbor/save.hpp
@@ -0,0 +1,26 @@
+#ifndef RFL_CBOR_SAVE_HPP_
+#define RFL_CBOR_SAVE_HPP_
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#include "../Result.hpp"
+#include "../io/save_bytes.hpp"
+#include "write.hpp"
+
+namespace rfl {
+namespace cbor {
+
+template <class... Ps>
+Result<Nothing> save(const std::string& _fname, const auto& _obj) {
+  const auto write_func = [](const auto& _obj, auto& _stream) -> auto& {
+    return write<Ps...>(_obj, _stream);
+  };
+  return rfl::io::save_bytes(_fname, _obj, write_func);
+}
+
+}  // namespace cbor
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/cbor/write.hpp b/include/rfl/cbor/write.hpp
new file mode 100644
index 0000000..867f150
--- /dev/null
+++ b/include/rfl/cbor/write.hpp
@@ -0,0 +1,59 @@
+#ifndef RFL_CBOR_WRITE_HPP_
+#define RFL_CBOR_WRITE_HPP_
+
+#include <cbor.h>
+
+#include <cstdint>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "../parsing/Parent.hpp"
+#include "Parser.hpp"
+
+namespace rfl {
+namespace cbor {
+
+template <class... Ps>
+void write_into_buffer(const auto& _obj, CborEncoder* _encoder,
+                       std::vector<char>* _buffer) noexcept {
+  using T = std::remove_cvref_t<decltype(_obj)>;
+  using ParentType = parsing::Parent<Writer>;
+  cbor_encoder_init(_encoder, reinterpret_cast<uint8_t*>(_buffer->data()),
+                    _buffer->size(), 0);
+  const auto writer = Writer(_encoder);
+  Parser<T, Processors<Ps...>>::write(writer, _obj,
+                                      typename ParentType::Root{});
+}
+
+/// Returns CBOR bytes.
+template <class... Ps>
+std::vector<char> write(const auto& _obj) noexcept {
+  std::vector<char> buffer(4096);
+  CborEncoder encoder;
+  write_into_buffer<Ps...>(_obj, &encoder, &buffer);
+  const auto total_bytes_needed =
+      buffer.size() + cbor_encoder_get_extra_bytes_needed(&encoder);
+  if (total_bytes_needed != buffer.size()) {
+    buffer.resize(total_bytes_needed);
+    write_into_buffer<Ps...>(_obj, &encoder, &buffer);
+  }
+  const auto length = cbor_encoder_get_buffer_size(
+      &encoder, reinterpret_cast<uint8_t*>(buffer.data()));
+  buffer.resize(length);
+  return buffer;
+}
+
+/// Writes a CBOR into an ostream.
+template <class... Ps>
+std::ostream& write(const auto& _obj, std::ostream& _stream) noexcept {
+  auto buffer = write<Ps...>(_obj);
+  _stream.write(buffer.data(), buffer.size());
+  return _stream;
+}
+
+}  // namespace cbor
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/flexbuf.hpp b/include/rfl/flexbuf.hpp
new file mode 100644
index 0000000..b1e7325
--- /dev/null
+++ b/include/rfl/flexbuf.hpp
@@ -0,0 +1,13 @@
+#ifndef RFL_FLEXBUF_HPP_
+#define RFL_FLEXBUF_HPP_
+
+#include "../rfl.hpp"
+#include "flexbuf/Parser.hpp"
+#include "flexbuf/Reader.hpp"
+#include "flexbuf/Writer.hpp"
+#include "flexbuf/load.hpp"
+#include "flexbuf/read.hpp"
+#include "flexbuf/save.hpp"
+#include "flexbuf/write.hpp"
+
+#endif
diff --git a/include/rfl/flexbuf/Parser.hpp b/include/rfl/flexbuf/Parser.hpp
new file mode 100644
index 0000000..dd7020f
--- /dev/null
+++ b/include/rfl/flexbuf/Parser.hpp
@@ -0,0 +1,17 @@
+#ifndef FLEXBUF_PARSER_HPP_
+#define FLEXBUF_PARSER_HPP_
+
+#include "../parsing/Parser.hpp"
+#include "Reader.hpp"
+#include "Writer.hpp"
+
+namespace rfl {
+namespace flexbuf {
+
+template <class T, class ProcessorsType>
+using Parser = parsing::Parser<Reader, Writer, T, ProcessorsType>;
+
+}
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/flexbuf/Reader.hpp b/include/rfl/flexbuf/Reader.hpp
new file mode 100644
index 0000000..16a2de0
--- /dev/null
+++ b/include/rfl/flexbuf/Reader.hpp
@@ -0,0 +1,145 @@
+#ifndef FLEXBUF_READER_HPP_
+#define FLEXBUF_READER_HPP_
+
+#include <flatbuffers/flexbuffers.h>
+
+#include <exception>
+#include <map>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+#include "../Result.hpp"
+#include "../always_false.hpp"
+
+namespace rfl {
+namespace flexbuf {
+
+struct Reader {
+  using InputArrayType = flexbuffers::Vector;
+  using InputObjectType = flexbuffers::Map;
+  using InputVarType = flexbuffers::Reference;
+
+  template <class T, class = void>
+  struct has_from_flexbuf : std::false_type {};
+
+  template <class T>
+  struct has_from_flexbuf<
+      T, std::enable_if_t<std::is_invocable_r<T, decltype(T::from_flexbuf),
+                                              InputVarType>::value>>
+      : std::true_type {};
+
+  template <class T>
+  struct has_from_flexbuf<
+      T, std::enable_if_t<std::is_invocable_r<
+             rfl::Result<T>, decltype(T::from_flexbuf), InputVarType>::value>>
+      : std::true_type {};
+
+  template <class T>
+  static constexpr bool has_custom_constructor = has_from_flexbuf<T>::value;
+
+  rfl::Result<InputVarType> get_field(
+      const std::string& _name, const InputObjectType& _obj) const noexcept {
+    const auto keys = _obj.Keys();
+    for (size_t i = 0; i < keys.size(); ++i) {
+      if (_name == keys[i].AsString().c_str()) {
+        return _obj.Values()[i];
+      }
+    }
+    return rfl::Error("Map does not contain any element called '" + _name +
+                      "'.");
+  }
+
+  bool is_empty(const InputVarType& _var) const noexcept {
+    return _var.IsNull();
+  }
+
+  template <class T>
+  rfl::Result<T> to_basic_type(const InputVarType& _var) const noexcept {
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      if (!_var.IsString()) {
+        return rfl::Error("Could not cast to string.");
+      }
+      return std::string(_var.AsString().c_str());
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      if (!_var.IsBool()) {
+        return rfl::Error("Could not cast to boolean.");
+      }
+      return _var.AsBool();
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
+      if (!_var.IsNumeric()) {
+        return rfl::Error("Could not cast to double.");
+      }
+      return static_cast<T>(_var.AsDouble());
+    } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
+      if (!_var.IsNumeric()) {
+        return rfl::Error("Could not cast to int.");
+      }
+      return static_cast<T>(_var.AsInt64());
+    } else {
+      static_assert(rfl::always_false_v<T>, "Unsupported type.");
+    }
+  }
+
+  template <class ArrayReader>
+  std::optional<Error> read_array(const ArrayReader& _array_reader,
+                                  const InputArrayType& _arr) const noexcept {
+    const auto size = _arr.size();
+    for (size_t i = 0; i < size; ++i) {
+      const auto err = _array_reader.read(InputVarType(_arr[i]));
+      if (err) {
+        return err;
+      }
+    }
+    return std::nullopt;
+  }
+
+  template <class ObjectReader>
+  std::optional<Error> read_object(const ObjectReader& _object_reader,
+                                   const InputObjectType& _obj) const noexcept {
+    const auto keys = _obj.Keys();
+    const auto values = _obj.Values();
+    const auto num_values = std::min(keys.size(), values.size());
+
+    for (size_t i = 0; i < num_values; ++i) {
+      _object_reader.read(std::string_view(keys[i].AsString().c_str()),
+                          values[i]);
+    }
+
+    return std::nullopt;
+  }
+
+  rfl::Result<InputArrayType> to_array(
+      const InputVarType& _var) const noexcept {
+    if (!_var.IsVector()) {
+      return rfl::Error("Could not cast to Vector.");
+    }
+    return _var.AsVector();
+  }
+
+  rfl::Result<InputObjectType> to_object(
+      const InputVarType& _var) const noexcept {
+    if (!_var.IsMap()) {
+      return rfl::Error("Could not cast to Map!");
+    }
+    return _var.AsMap();
+  }
+
+  template <class T>
+  rfl::Result<T> use_custom_constructor(
+      const InputVarType& _var) const noexcept {
+    try {
+      return T::from_flexbuf(_var);
+    } catch (std::exception& e) {
+      return rfl::Error(e.what());
+    }
+  }
+};
+
+}  // namespace flexbuf
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/flexbuf/Writer.hpp b/include/rfl/flexbuf/Writer.hpp
new file mode 100644
index 0000000..3659a6e
--- /dev/null
+++ b/include/rfl/flexbuf/Writer.hpp
@@ -0,0 +1,176 @@
+#ifndef FLEXBUF_WRITER_HPP_
+#define FLEXBUF_WRITER_HPP_
+
+#include <flatbuffers/flexbuffers.h>
+
+#include <exception>
+#include <functional>
+#include <map>
+#include <optional>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+#include "../Ref.hpp"
+#include "../Result.hpp"
+#include "../always_false.hpp"
+
+namespace rfl {
+namespace flexbuf {
+
+struct Writer {
+  struct OutputArray {
+    size_t start_;
+  };
+
+  struct OutputObject {
+    size_t start_;
+  };
+
+  struct OutputVar {};
+
+  using OutputArrayType = OutputArray;
+  using OutputObjectType = OutputObject;
+  using OutputVarType = OutputVar;
+
+  Writer(const Ref<flexbuffers::Builder>& _fbb) : fbb_(_fbb) {}
+
+  ~Writer() = default;
+
+  OutputArrayType array_as_root(const size_t _size) const noexcept {
+    return new_array();
+  }
+
+  OutputObjectType object_as_root(const size_t _size) const noexcept {
+    return new_object();
+  }
+
+  OutputVarType null_as_root() const noexcept {
+    fbb_->Null();
+    return OutputVarType{};
+  }
+
+  template <class T>
+  OutputVarType value_as_root(const T& _var) const noexcept {
+    return insert_value(_var);
+  }
+
+  OutputArrayType add_array_to_array(const size_t _size,
+                                     OutputArrayType* _parent) const noexcept {
+    return new_array();
+  }
+
+  OutputArrayType add_array_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    return new_array(_name);
+  }
+
+  OutputObjectType add_object_to_array(
+      const size_t _size, OutputArrayType* _parent) const noexcept {
+    return new_object();
+  }
+
+  OutputObjectType add_object_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    return new_object(_name);
+  }
+
+  template <class T>
+  OutputVarType add_value_to_array(const T& _var,
+                                   OutputArrayType* _parent) const noexcept {
+    return insert_value(_var);
+  }
+
+  template <class T>
+  OutputVarType add_value_to_object(const std::string_view& _name,
+                                    const T& _var,
+                                    OutputObjectType* _parent) const noexcept {
+    return insert_value(_name, _var);
+  }
+
+  OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept {
+    fbb_->Null();
+    return OutputVarType{};
+  }
+
+  OutputVarType add_null_to_object(const std::string_view& _name,
+                                   OutputObjectType* _parent) const noexcept {
+    fbb_->Null(_name.data());
+    return OutputVarType{};
+  }
+
+  void end_array(OutputArrayType* _arr) const noexcept {
+    fbb_->EndVector(_arr->start_, false, false);
+  }
+
+  void end_object(OutputObjectType* _obj) const noexcept {
+    fbb_->EndMap(_obj->start_);
+  }
+
+ private:
+  template <class T>
+  OutputVarType insert_value(const std::string_view& _name,
+                             const T& _var) const noexcept {
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      fbb_->String(_name.data(), _var);
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      fbb_->Bool(_name.data(), _var);
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
+      fbb_->Double(_name.data(), _var);
+    } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
+      fbb_->Int(_name.data(), _var);
+    } else {
+      static_assert(always_false_v<T>, "Unsupported type");
+    }
+    return OutputVarType{};
+  }
+
+  template <class T>
+  OutputVarType insert_value(const T& _var) const noexcept {
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      fbb_->String(_var);
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      fbb_->Bool(_var);
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
+      fbb_->Double(_var);
+    } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
+      fbb_->Int(_var);
+    } else {
+      static_assert(always_false_v<T>, "Unsupported type");
+    }
+    return OutputVarType{};
+  }
+
+  OutputArrayType new_array(const std::string_view& _name) const noexcept {
+    const auto start = fbb_->StartVector(_name.data());
+    return OutputArrayType{start};
+  }
+
+  OutputArrayType new_array() const noexcept {
+    const auto start = fbb_->StartVector();
+    return OutputArrayType{start};
+  }
+
+  OutputObjectType new_object(const std::string_view& _name) const noexcept {
+    const auto start = fbb_->StartMap(_name.data());
+    return OutputObjectType{start};
+  }
+
+  OutputObjectType new_object() const noexcept {
+    const auto start = fbb_->StartMap();
+    return OutputObjectType{start};
+  }
+
+ private:
+  Ref<flexbuffers::Builder> fbb_;
+};
+
+}  // namespace flexbuf
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/flexbuf/load.hpp b/include/rfl/flexbuf/load.hpp
new file mode 100644
index 0000000..ec0a4e7
--- /dev/null
+++ b/include/rfl/flexbuf/load.hpp
@@ -0,0 +1,22 @@
+#ifndef RFL_FLEXBUF_LOAD_HPP_
+#define RFL_FLEXBUF_LOAD_HPP_
+
+#include "../Result.hpp"
+#include "../io/load_bytes.hpp"
+#include "read.hpp"
+
+namespace rfl {
+namespace flexbuf {
+
+template <class T, class... Ps>
+Result<T> load(const std::string& _fname) {
+  const auto read_bytes = [](const auto& _bytes) {
+    return read<T, Ps...>(_bytes);
+  };
+  return rfl::io::load_bytes(_fname).and_then(read_bytes);
+}
+
+}  // namespace flexbuf
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/flexbuf/read.hpp b/include/rfl/flexbuf/read.hpp
new file mode 100644
index 0000000..afdb805
--- /dev/null
+++ b/include/rfl/flexbuf/read.hpp
@@ -0,0 +1,50 @@
+#ifndef FLEXBUF_READ_HPP_
+#define FLEXBUF_READ_HPP_
+
+#include <flatbuffers/flexbuffers.h>
+
+#include <istream>
+#include <vector>
+
+#include "../Processors.hpp"
+#include "../Result.hpp"
+#include "Parser.hpp"
+
+namespace rfl {
+namespace flexbuf {
+
+using InputVarType = typename Reader::InputVarType;
+
+/// Parses an object from flexbuf var.
+template <class T, class... Ps>
+auto read(const InputVarType& _obj) {
+  const auto r = Reader();
+  return Parser<T, Processors<Ps...>>::read(r, _obj);
+}
+
+/// Parses an object from flexbuf using reflection.
+template <class T, class... Ps>
+auto read(const char* _bytes, const size_t _size) {
+  const InputVarType root =
+      flexbuffers::GetRoot(reinterpret_cast<const uint8_t*>(_bytes), _size);
+  return read<T, Ps...>(root);
+}
+
+/// Parses an object from flexbuf using reflection.
+template <class T, class... Ps>
+auto read(const std::vector<char>& _bytes) {
+  return read<T, Ps...>(_bytes.data(), _bytes.size());
+}
+
+/// Parses an object directly from a stream.
+template <class T, class... Ps>
+auto read(std::istream& _stream) {
+  std::istreambuf_iterator<char> begin(_stream), end;
+  const auto bytes = std::vector<char>(begin, end);
+  return read<T, Ps...>(bytes.data(), bytes.size());
+}
+
+}  // namespace flexbuf
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/flexbuf/save.hpp b/include/rfl/flexbuf/save.hpp
new file mode 100644
index 0000000..cc2a8d2
--- /dev/null
+++ b/include/rfl/flexbuf/save.hpp
@@ -0,0 +1,26 @@
+#ifndef RFL_FLEXBUF_SAVE_HPP_
+#define RFL_FLEXBUF_SAVE_HPP_
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#include "../Result.hpp"
+#include "../io/save_bytes.hpp"
+#include "write.hpp"
+
+namespace rfl {
+namespace flexbuf {
+
+template <class... Ps>
+Result<Nothing> save(const std::string& _fname, const auto& _obj) {
+  const auto write_func = [](const auto& _obj, auto& _stream) -> auto& {
+    return write<Ps...>(_obj, _stream);
+  };
+  return rfl::io::save_bytes(_fname, _obj, write_func);
+}
+
+}  // namespace flexbuf
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/flexbuf/write.hpp b/include/rfl/flexbuf/write.hpp
new file mode 100644
index 0000000..5409ead
--- /dev/null
+++ b/include/rfl/flexbuf/write.hpp
@@ -0,0 +1,50 @@
+#ifndef FLEXBUF_WRITE_HPP_
+#define FLEXBUF_WRITE_HPP_
+
+#include <flatbuffers/flexbuffers.h>
+
+#include <cstddef>
+#include <ostream>
+#include <sstream>
+#include <vector>
+
+#include "../Processors.hpp"
+#include "../Ref.hpp"
+#include "../parsing/Parent.hpp"
+#include "Parser.hpp"
+
+namespace rfl {
+namespace flexbuf {
+
+template <class... Ps>
+std::vector<uint8_t> to_buffer(const auto& _obj) {
+  using T = std::remove_cvref_t<decltype(_obj)>;
+  using ParentType = parsing::Parent<Writer>;
+  const auto fbb = Ref<flexbuffers::Builder>::make();
+  auto w = Writer(fbb);
+  Parser<T, Processors<Ps...>>::write(w, _obj, typename ParentType::Root{});
+  fbb->Finish();
+  return fbb->GetBuffer();
+}
+
+/// Writes an object to flexbuf.
+template <class... Ps>
+std::vector<char> write(const auto& _obj) {
+  const auto buffer = to_buffer<Ps...>(_obj);
+  const auto data = reinterpret_cast<const char*>(buffer.data());
+  return std::vector<char>(data, data + buffer.size());
+}
+
+/// Writes an object to an ostream.
+template <class... Ps>
+std::ostream& write(const auto& _obj, std::ostream& _stream) {
+  const auto buffer = to_buffer<Ps...>(_obj);
+  const auto data = reinterpret_cast<const char*>(buffer.data());
+  _stream.write(data, buffer.size());
+  return _stream;
+}
+
+}  // namespace flexbuf
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/json.hpp b/include/rfl/json.hpp
new file mode 100644
index 0000000..cac6b0e
--- /dev/null
+++ b/include/rfl/json.hpp
@@ -0,0 +1,14 @@
+#ifndef RFL_JSON_HPP_
+#define RFL_JSON_HPP_
+
+#include "../rfl.hpp"
+#include "json/Parser.hpp"
+#include "json/Reader.hpp"
+#include "json/Writer.hpp"
+#include "json/load.hpp"
+#include "json/read.hpp"
+#include "json/save.hpp"
+#include "json/to_schema.hpp"
+#include "json/write.hpp"
+
+#endif
diff --git a/include/rfl/json/Parser.hpp b/include/rfl/json/Parser.hpp
new file mode 100644
index 0000000..9de1755
--- /dev/null
+++ b/include/rfl/json/Parser.hpp
@@ -0,0 +1,15 @@
+#ifndef RFL_JSON_PARSER_HPP_
+#define RFL_JSON_PARSER_HPP_
+
+#include "../parsing/Parser.hpp"
+#include "Reader.hpp"
+#include "Writer.hpp"
+
+namespace rfl::json {
+
+template <class T, class ProcessorsType>
+using Parser = parsing::Parser<Reader, Writer, T, ProcessorsType>;
+
+}  // namespace rfl::json
+
+#endif
diff --git a/include/rfl/json/Reader.hpp b/include/rfl/json/Reader.hpp
new file mode 100644
index 0000000..958df68
--- /dev/null
+++ b/include/rfl/json/Reader.hpp
@@ -0,0 +1,154 @@
+#ifndef RFL_JSON_READER_HPP_
+#define RFL_JSON_READER_HPP_
+
+#include <yyjson.h>
+
+#include <array>
+#include <concepts>
+#include <exception>
+#include <map>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+#include "../Result.hpp"
+#include "../always_false.hpp"
+
+namespace rfl {
+namespace json {
+
+struct Reader {
+  struct YYJSONInputArray {
+    YYJSONInputArray(yyjson_val* _val) : val_(_val) {}
+    yyjson_val* val_;
+  };
+
+  struct YYJSONInputObject {
+    YYJSONInputObject(yyjson_val* _val) : val_(_val) {}
+    yyjson_val* val_;
+  };
+
+  struct YYJSONInputVar {
+    YYJSONInputVar() : val_(nullptr) {}
+    YYJSONInputVar(yyjson_val* _val) : val_(_val) {}
+    yyjson_val* val_;
+  };
+
+  using InputArrayType = YYJSONInputArray;
+  using InputObjectType = YYJSONInputObject;
+  using InputVarType = YYJSONInputVar;
+
+  template <class T>
+  static constexpr bool has_custom_constructor = (requires(InputVarType var) {
+    T::from_json_obj(var);
+  });
+
+  rfl::Result<InputVarType> get_field(
+      const std::string& _name, const InputObjectType _obj) const noexcept {
+    const auto var = InputVarType(yyjson_obj_get(_obj.val_, _name.c_str()));
+    if (!var.val_) {
+      return rfl::Error("Object contains no field named '" + _name + "'.");
+    }
+    return var;
+  }
+
+  bool is_empty(const InputVarType _var) const noexcept {
+    return !_var.val_ || yyjson_is_null(_var.val_);
+  }
+
+  template <class ArrayReader>
+  std::optional<Error> read_array(const ArrayReader& _array_reader,
+                                  const InputArrayType& _arr) const noexcept {
+    yyjson_val* val;
+    yyjson_arr_iter iter;
+    yyjson_arr_iter_init(_arr.val_, &iter);
+    while ((val = yyjson_arr_iter_next(&iter))) {
+      const auto err = _array_reader.read(InputVarType(val));
+      if (err) {
+        return err;
+      }
+    }
+    return std::nullopt;
+  }
+
+  template <class ObjectReader>
+  std::optional<Error> read_object(const ObjectReader& _object_reader,
+                                   const InputObjectType& _obj) const noexcept {
+    yyjson_obj_iter iter;
+    yyjson_obj_iter_init(_obj.val_, &iter);
+    yyjson_val* key;
+    while ((key = yyjson_obj_iter_next(&iter))) {
+      const auto name = std::string_view(yyjson_get_str(key));
+      _object_reader.read(name, InputVarType(yyjson_obj_iter_get_val(key)));
+    }
+    return std::nullopt;
+  }
+
+  template <class T>
+  rfl::Result<T> to_basic_type(const InputVarType _var) const noexcept {
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      const auto r = yyjson_get_str(_var.val_);
+      if (r == NULL) {
+        return rfl::Error("Could not cast to string.");
+      }
+      return std::string(r);
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      if (!yyjson_is_bool(_var.val_)) {
+        return rfl::Error("Could not cast to boolean.");
+      }
+      return yyjson_get_bool(_var.val_);
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
+      if (!yyjson_is_num(_var.val_)) {
+        return rfl::Error("Could not cast to double.");
+      }
+      return static_cast<T>(yyjson_get_num(_var.val_));
+    } else if constexpr (std::is_unsigned<std::remove_cvref_t<T>>()) {
+      if (!yyjson_is_int(_var.val_)) {
+        return rfl::Error("Could not cast to int.");
+      }
+      return static_cast<T>(yyjson_get_uint(_var.val_));
+    } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
+      if (!yyjson_is_int(_var.val_)) {
+        return rfl::Error("Could not cast to int.");
+      }
+      return static_cast<T>(yyjson_get_sint(_var.val_));
+    } else {
+      static_assert(rfl::always_false_v<T>, "Unsupported type.");
+    }
+  }
+
+  rfl::Result<InputArrayType> to_array(const InputVarType _var) const noexcept {
+    if (!yyjson_is_arr(_var.val_)) {
+      return rfl::Error("Could not cast to array!");
+    }
+    return InputArrayType(_var.val_);
+  }
+
+  rfl::Result<InputObjectType> to_object(
+      const InputVarType _var) const noexcept {
+    if (!yyjson_is_obj(_var.val_)) {
+      return rfl::Error("Could not cast to object!");
+    }
+    return InputObjectType(_var.val_);
+  }
+
+  template <class T>
+  rfl::Result<T> use_custom_constructor(
+      const InputVarType _var) const noexcept {
+    try {
+      return T::from_json_obj(_var);
+    } catch (std::exception& e) {
+      return rfl::Error(e.what());
+    }
+  }
+};
+
+}  // namespace json
+}  // namespace rfl
+
+#endif  // JSON_PARSER_HPP_
diff --git a/include/rfl/json/Writer.hpp b/include/rfl/json/Writer.hpp
new file mode 100644
index 0000000..81d794f
--- /dev/null
+++ b/include/rfl/json/Writer.hpp
@@ -0,0 +1,169 @@
+#ifndef RFL_JSON_WRITER_HPP_
+#define RFL_JSON_WRITER_HPP_
+
+#include <yyjson.h>
+
+#include <exception>
+#include <map>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+#include "../Result.hpp"
+#include "../always_false.hpp"
+
+namespace rfl {
+namespace json {
+
+class Writer {
+ public:
+  struct YYJSONOutputArray {
+    YYJSONOutputArray(yyjson_mut_val* _val) : val_(_val) {}
+    yyjson_mut_val* val_;
+  };
+
+  struct YYJSONOutputObject {
+    YYJSONOutputObject(yyjson_mut_val* _val) : val_(_val) {}
+    yyjson_mut_val* val_;
+  };
+
+  struct YYJSONOutputVar {
+    YYJSONOutputVar(yyjson_mut_val* _val) : val_(_val) {}
+
+    YYJSONOutputVar(YYJSONOutputArray _arr) : val_(_arr.val_) {}
+
+    YYJSONOutputVar(YYJSONOutputObject _obj) : val_(_obj.val_) {}
+
+    yyjson_mut_val* val_;
+  };
+
+  using OutputArrayType = YYJSONOutputArray;
+  using OutputObjectType = YYJSONOutputObject;
+  using OutputVarType = YYJSONOutputVar;
+
+  Writer(yyjson_mut_doc* _doc) : doc_(_doc) {}
+
+  ~Writer() = default;
+
+  OutputArrayType array_as_root(const size_t _size) const noexcept {
+    const auto arr = yyjson_mut_arr(doc_);
+    yyjson_mut_doc_set_root(doc_, arr);
+    return OutputArrayType(arr);
+  }
+
+  OutputObjectType object_as_root(const size_t _size) const noexcept {
+    const auto obj = yyjson_mut_obj(doc_);
+    yyjson_mut_doc_set_root(doc_, obj);
+    return OutputObjectType(obj);
+  }
+
+  OutputVarType null_as_root() const noexcept {
+    const auto null = yyjson_mut_null(doc_);
+    yyjson_mut_doc_set_root(doc_, null);
+    return OutputVarType(null);
+  }
+
+  template <class T>
+  OutputVarType value_as_root(const T& _var) const noexcept {
+    const auto val = from_basic_type(_var);
+    yyjson_mut_doc_set_root(doc_, val.val_);
+    return OutputVarType(val);
+  }
+
+  OutputArrayType add_array_to_array(const size_t _size,
+                                     OutputArrayType* _parent) const noexcept {
+    const auto arr = yyjson_mut_arr(doc_);
+    yyjson_mut_arr_add_val(_parent->val_, arr);
+    return OutputArrayType(arr);
+  }
+
+  OutputArrayType add_array_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    const auto arr = yyjson_mut_arr(doc_);
+    yyjson_mut_obj_add(_parent->val_, yyjson_mut_strcpy(doc_, _name.data()),
+                       arr);
+    return OutputArrayType(arr);
+  }
+
+  OutputObjectType add_object_to_array(
+      const size_t _size, OutputArrayType* _parent) const noexcept {
+    const auto obj = yyjson_mut_obj(doc_);
+    yyjson_mut_arr_add_val(_parent->val_, obj);
+    return OutputObjectType(obj);
+  }
+
+  OutputObjectType add_object_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    const auto obj = yyjson_mut_obj(doc_);
+    yyjson_mut_obj_add(_parent->val_, yyjson_mut_strcpy(doc_, _name.data()),
+                       obj);
+    return OutputObjectType(obj);
+  }
+
+  template <class T>
+  OutputVarType add_value_to_array(const T& _var,
+                                   OutputArrayType* _parent) const noexcept {
+    const auto val = from_basic_type(_var);
+    yyjson_mut_arr_add_val(_parent->val_, val.val_);
+    return OutputVarType(val);
+  }
+
+  template <class T>
+  OutputVarType add_value_to_object(const std::string_view& _name,
+                                    const T& _var,
+                                    OutputObjectType* _parent) const noexcept {
+    const auto val = from_basic_type(_var);
+    yyjson_mut_obj_add(_parent->val_, yyjson_mut_strcpy(doc_, _name.data()),
+                       val.val_);
+    return OutputVarType(val);
+  }
+
+  OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept {
+    const auto null = yyjson_mut_null(doc_);
+    yyjson_mut_arr_add_val(_parent->val_, null);
+    return OutputVarType(null);
+  }
+
+  OutputVarType add_null_to_object(const std::string_view& _name,
+                                   OutputObjectType* _parent) const noexcept {
+    const auto null = yyjson_mut_null(doc_);
+    yyjson_mut_obj_add(_parent->val_, yyjson_mut_strcpy(doc_, _name.data()),
+                       null);
+    return OutputVarType(null);
+  }
+
+  void end_array(OutputArrayType* _arr) const noexcept {}
+
+  void end_object(OutputObjectType* _obj) const noexcept {}
+
+ private:
+  template <class T>
+  OutputVarType from_basic_type(const T& _var) const noexcept {
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      return OutputVarType(yyjson_mut_strcpy(doc_, _var.c_str()));
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      return OutputVarType(yyjson_mut_bool(doc_, _var));
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
+      return OutputVarType(yyjson_mut_real(doc_, static_cast<double>(_var)));
+    } else if constexpr (std::is_unsigned<std::remove_cvref_t<T>>()) {
+      return OutputVarType(yyjson_mut_uint(doc_, static_cast<uint64_t>(_var)));
+    } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
+      return OutputVarType(yyjson_mut_int(doc_, static_cast<int64_t>(_var)));
+    } else {
+      static_assert(rfl::always_false_v<T>, "Unsupported type.");
+    }
+  }
+
+ public:
+  yyjson_mut_doc* doc_;
+};
+
+}  // namespace json
+}  // namespace rfl
+
+#endif  // JSON_PARSER_HPP_
diff --git a/include/rfl/json/load.hpp b/include/rfl/json/load.hpp
new file mode 100644
index 0000000..5f7e8f4
--- /dev/null
+++ b/include/rfl/json/load.hpp
@@ -0,0 +1,22 @@
+#ifndef RFL_JSON_LOAD_HPP_
+#define RFL_JSON_LOAD_HPP_
+
+#include "../Result.hpp"
+#include "../io/load_string.hpp"
+#include "read.hpp"
+
+namespace rfl {
+namespace json {
+
+template <class T, class... Ps>
+Result<T> load(const std::string& _fname) {
+  const auto read_string = [](const auto& _str) {
+    return read<T, Ps...>(_str);
+  };
+  return rfl::io::load_string(_fname).and_then(read_string);
+}
+
+}  // namespace json
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/json/read.hpp b/include/rfl/json/read.hpp
new file mode 100644
index 0000000..30bef1b
--- /dev/null
+++ b/include/rfl/json/read.hpp
@@ -0,0 +1,52 @@
+#ifndef RFL_JSON_READ_HPP_
+#define RFL_JSON_READ_HPP_
+
+#include <yyjson.h>
+
+#include <istream>
+#include <string>
+
+#include "../Processors.hpp"
+#include "../internal/wrap_in_rfl_array_t.hpp"
+#include "Parser.hpp"
+#include "Reader.hpp"
+
+namespace rfl {
+namespace json {
+
+using InputObjectType = typename Reader::InputObjectType;
+using InputVarType = typename Reader::InputVarType;
+
+/// Parses an object from a JSON var.
+template <class T, class... Ps>
+auto read(const InputVarType& _obj) {
+  const auto r = Reader();
+  return Parser<T, Processors<Ps...>>::read(r, _obj);
+}
+
+/// Parses an object from JSON using reflection.
+template <class T, class... Ps>
+Result<internal::wrap_in_rfl_array_t<T>> read(const std::string& _json_str) {
+  yyjson_doc* doc = yyjson_read(_json_str.c_str(), _json_str.size(), 0);
+  if (!doc) {
+    return Error("Could not parse document");
+  }
+  yyjson_val* root = yyjson_doc_get_root(doc);
+  const auto r = Reader();
+  auto res = Parser<T, Processors<Ps...>>::read(r, InputVarType(root));
+  yyjson_doc_free(doc);
+  return res;
+}
+
+/// Parses an object from a stringstream.
+template <class T, class... Ps>
+auto read(std::istream& _stream) {
+  const auto json_str = std::string(std::istreambuf_iterator<char>(_stream),
+                                    std::istreambuf_iterator<char>());
+  return read<T, Ps...>(json_str);
+}
+
+}  // namespace json
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/json/save.hpp b/include/rfl/json/save.hpp
new file mode 100644
index 0000000..9875df8
--- /dev/null
+++ b/include/rfl/json/save.hpp
@@ -0,0 +1,29 @@
+#ifndef RFL_JSON_SAVE_HPP_
+#define RFL_JSON_SAVE_HPP_
+
+#include <yyjson.h>
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#include "../Result.hpp"
+#include "../io/save_string.hpp"
+#include "write.hpp"
+
+namespace rfl {
+namespace json {
+
+template <class... Ps>
+Result<Nothing> save(const std::string& _fname, const auto& _obj,
+                     const yyjson_write_flag _flag = 0) {
+  const auto write_func = [_flag](const auto& _obj, auto& _stream) -> auto& {
+    return write<Ps...>(_obj, _stream, _flag);
+  };
+  return rfl::io::save_string(_fname, _obj, write_func);
+}
+
+}  // namespace json
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/json/schema/JSONSchema.hpp b/include/rfl/json/schema/JSONSchema.hpp
new file mode 100644
index 0000000..7aedfb7
--- /dev/null
+++ b/include/rfl/json/schema/JSONSchema.hpp
@@ -0,0 +1,25 @@
+#ifndef RFL_JSON_SCHEMA_JSONSCHEMA_HPP_
+#define RFL_JSON_SCHEMA_JSONSCHEMA_HPP_
+
+#include <map>
+#include <string>
+#include <variant>
+
+#include "../../Flatten.hpp"
+#include "../../Literal.hpp"
+#include "../../Rename.hpp"
+#include "Type.hpp"
+
+namespace rfl::json::schema {
+
+template <class T>
+struct JSONSchema {
+  Rename<"$schema", Literal<"https://json-schema.org/draft/2020-12/schema">>
+      schema;
+  Flatten<T> root;
+  std::map<std::string, Type> definitions;
+};
+
+}  // namespace rfl::json::schema
+
+#endif
diff --git a/include/rfl/json/schema/Type.hpp b/include/rfl/json/schema/Type.hpp
new file mode 100644
index 0000000..7352cad
--- /dev/null
+++ b/include/rfl/json/schema/Type.hpp
@@ -0,0 +1,147 @@
+#ifndef RFL_JSON_SCHEMA_TYPE_HPP_
+#define RFL_JSON_SCHEMA_TYPE_HPP_
+
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+
+#include "../../Literal.hpp"
+#include "../../Rename.hpp"
+
+namespace rfl::json::schema {
+
+/// The JSON representation of internal::schema::Type.
+struct Type {
+  struct Boolean {
+    std::optional<std::string> description;
+    Literal<"boolean"> type;
+  };
+
+  struct Integer {
+    Literal<"integer"> type;
+    std::optional<std::string> description;
+  };
+
+  struct Number {
+    Literal<"number"> type;
+    std::optional<std::string> description;
+  };
+
+  struct String {
+    Literal<"string"> type;
+    std::optional<std::string> description;
+  };
+
+  using NumericType = std::variant<Integer, Number>;
+
+  struct AllOf {
+    std::optional<std::string> description;
+    std::vector<Type> allOf;
+  };
+
+  struct AnyOf {
+    std::optional<std::string> description;
+    std::vector<Type> anyOf;
+  };
+
+  struct ExclusiveMaximum {
+    std::optional<std::string> description;
+    std::variant<double, int> exclusiveMaximum;
+    std::string type;
+  };
+
+  struct ExclusiveMinimum {
+    std::optional<std::string> description;
+    std::variant<double, int> exclusiveMinimum;
+    std::string type;
+  };
+
+  struct FixedSizeTypedArray {
+    Literal<"array"> type;
+    std::optional<std::string> description;
+    rfl::Ref<Type> items;
+    size_t minContains;
+    size_t maxContains;
+  };
+
+  struct Maximum {
+    std::optional<std::string> description;
+    std::variant<double, int> maximum;
+    std::string type;
+  };
+
+  struct Minimum {
+    std::optional<std::string> description;
+    std::variant<double, int> minimum;
+    std::string type;
+  };
+
+  struct Null {
+    Literal<"null"> type;
+    std::optional<std::string> description;
+  };
+
+  struct Object {
+    Literal<"object"> type;
+    std::optional<std::string> description;
+    std::map<std::string, Type> properties;
+    std::vector<std::string> required;
+  };
+
+  struct OneOf {
+    std::optional<std::string> description;
+    std::vector<Type> oneOf;
+  };
+
+  struct Reference {
+    Rename<"$ref", std::optional<std::string>> ref;
+    std::optional<std::string> description;
+  };
+
+  struct Regex {
+    Literal<"string"> type;
+    std::optional<std::string> description;
+    std::string pattern;
+  };
+
+  struct StringEnum {
+    Literal<"string"> type;
+    std::optional<std::string> description;
+    rfl::Rename<"enum", std::vector<std::string>> values;
+  };
+
+  struct StringMap {
+    Literal<"object"> type;
+    std::optional<std::string> description;
+    rfl::Ref<Type> additionalProperties;
+  };
+
+  struct Tuple {
+    Literal<"array"> type;
+    std::optional<std::string> description;
+    std::vector<Type> prefixItems;
+    bool items = false;
+  };
+
+  struct TypedArray {
+    Literal<"array"> type;
+    std::optional<std::string> description;
+    rfl::Ref<Type> items;
+  };
+
+  using ReflectionType =
+      std::variant<AllOf, AnyOf, Boolean, ExclusiveMaximum, ExclusiveMinimum,
+                   FixedSizeTypedArray, Integer, Maximum, Minimum, Number, Null,
+                   Object, OneOf, Reference, Regex, String, StringEnum,
+                   StringMap, Tuple, TypedArray>;
+
+  const auto& reflection() const { return value; }
+
+  ReflectionType value;
+};
+
+}  // namespace rfl::json::schema
+
+#endif
diff --git a/include/rfl/json/to_schema.hpp b/include/rfl/json/to_schema.hpp
new file mode 100644
index 0000000..37ff2d5
--- /dev/null
+++ b/include/rfl/json/to_schema.hpp
@@ -0,0 +1,262 @@
+#ifndef RFL_JSON_TOSCHEMA_HPP_
+#define RFL_JSON_TOSCHEMA_HPP_
+
+#include <yyjson.h>
+
+#include <map>
+#include <string>
+#include <type_traits>
+#include <variant>
+
+#include "../Literal.hpp"
+#include "../Processors.hpp"
+#include "../parsing/schema/Type.hpp"
+#include "../parsing/schema/ValidationType.hpp"
+#include "../parsing/schema/make.hpp"
+#include "Reader.hpp"
+#include "Writer.hpp"
+#include "schema/JSONSchema.hpp"
+#include "schema/Type.hpp"
+#include "write.hpp"
+
+namespace rfl::json {
+
+inline schema::Type type_to_json_schema_type(
+    const parsing::schema::Type& _type);
+
+inline bool is_optional(const parsing::schema::Type& _t) {
+  const auto handle = [](const auto& _v) -> bool {
+    using T = std::remove_cvref_t<decltype(_v)>;
+    return std::is_same<T, parsing::schema::Type::Optional>();
+  };
+  return std::visit(handle, _t.variant_);
+}
+
+inline std::string numeric_type_to_string(const parsing::schema::Type& _type) {
+  const auto handle_variant = [](const auto& _t) -> std::string {
+    using T = std::remove_cvref_t<decltype(_t)>;
+    using Type = parsing::schema::Type;
+    if constexpr (std::is_same<T, Type::Int32>() ||
+                  std::is_same<T, Type::Int64>() ||
+                  std::is_same<T, Type::UInt32>() ||
+                  std::is_same<T, Type::UInt64>() ||
+                  std::is_same<T, Type::Integer>()) {
+      return schema::Type::Integer{}.type.str();
+    } else {
+      return schema::Type::Number{}.type.str();
+    }
+  };
+  return std::visit(handle_variant, _type.variant_);
+}
+
+inline schema::Type handle_validation_type(
+    const parsing::schema::Type& _type,
+    const parsing::schema::ValidationType& _validation_type) {
+  const auto handle_variant = [&](const auto& _v) -> schema::Type {
+    using T = std::remove_cvref_t<decltype(_v)>;
+    using ValidationType = parsing::schema::ValidationType;
+    if constexpr (std::is_same<T, ValidationType::AllOf>()) {
+      auto all_of = std::vector<schema::Type>();
+      for (const auto& t : _v.types_) {
+        all_of.emplace_back(handle_validation_type(_type, t));
+      }
+      return schema::Type{.value = schema::Type::AllOf{.allOf = all_of}};
+
+    } else if constexpr (std::is_same<T, ValidationType::AnyOf>()) {
+      auto any_of = std::vector<schema::Type>();
+      for (const auto& t : _v.types_) {
+        any_of.emplace_back(handle_validation_type(_type, t));
+      }
+      return schema::Type{.value = schema::Type::AnyOf{.anyOf = any_of}};
+
+    } else if constexpr (std::is_same<T, ValidationType::OneOf>()) {
+      auto one_of = std::vector<schema::Type>();
+      for (const auto& t : _v.types_) {
+        one_of.emplace_back(handle_validation_type(_type, t));
+      }
+      return schema::Type{.value = schema::Type::OneOf{.oneOf = one_of}};
+
+    } else if constexpr (std::is_same<T, ValidationType::Regex>()) {
+      return schema::Type{.value = schema::Type::Regex{.pattern = _v.pattern_}};
+
+    } else if constexpr (std::is_same<T, ValidationType::Size>()) {
+      return type_to_json_schema_type(_type);
+
+    } else if constexpr (std::is_same<T, ValidationType::ExclusiveMaximum>()) {
+      return schema::Type{.value = schema::Type::ExclusiveMaximum{
+                              .exclusiveMaximum = _v.value_,
+                              .type = numeric_type_to_string(_type)}};
+
+    } else if constexpr (std::is_same<T, ValidationType::ExclusiveMinimum>()) {
+      return schema::Type{.value = schema::Type::ExclusiveMinimum{
+                              .exclusiveMinimum = _v.value_,
+                              .type = numeric_type_to_string(_type)}};
+
+    } else if constexpr (std::is_same<T, ValidationType::Maximum>()) {
+      return schema::Type{
+          .value = schema::Type::Maximum{
+              .maximum = _v.value_, .type = numeric_type_to_string(_type)}};
+
+    } else if constexpr (std::is_same<T, ValidationType::Minimum>()) {
+      return schema::Type{
+          .value = schema::Type::Minimum{
+              .minimum = _v.value_, .type = numeric_type_to_string(_type)}};
+
+    } else if constexpr (std::is_same<T, ValidationType::EqualTo>()) {
+      const auto maximum = schema::Type{
+          .value = schema::Type::Maximum{
+              .maximum = _v.value_, .type = numeric_type_to_string(_type)}};
+      const auto minimum = schema::Type{
+          .value = schema::Type::Minimum{
+              .minimum = _v.value_, .type = numeric_type_to_string(_type)}};
+      return schema::Type{.value =
+                              schema::Type::AllOf{.allOf = {maximum, minimum}}};
+
+    } else if constexpr (std::is_same<T, ValidationType::NotEqualTo>()) {
+      const auto excl_maximum =
+          schema::Type{.value = schema::Type::ExclusiveMaximum{
+                           .exclusiveMaximum = _v.value_,
+                           .type = numeric_type_to_string(_type)}};
+      const auto excl_minimum =
+          schema::Type{.value = schema::Type::ExclusiveMinimum{
+                           .exclusiveMinimum = _v.value_,
+                           .type = numeric_type_to_string(_type)}};
+      return schema::Type{
+          .value = schema::Type::AnyOf{.anyOf = {excl_maximum, excl_minimum}}};
+
+    } else {
+      static_assert(rfl::always_false_v<T>, "Not all cases were covered.");
+    }
+  };
+
+  return std::visit(handle_variant, _validation_type.variant_);
+}
+
+inline schema::Type type_to_json_schema_type(
+    const parsing::schema::Type& _type) {
+  const auto handle_variant = [](const auto& _t) -> schema::Type {
+    using T = std::remove_cvref_t<decltype(_t)>;
+    using Type = parsing::schema::Type;
+    if constexpr (std::is_same<T, Type::Boolean>()) {
+      return schema::Type{.value = schema::Type::Boolean{}};
+
+    } else if constexpr (std::is_same<T, Type::Int32>() ||
+                         std::is_same<T, Type::Int64>() ||
+                         std::is_same<T, Type::UInt32>() ||
+                         std::is_same<T, Type::UInt64>() ||
+                         std::is_same<T, Type::Integer>()) {
+      return schema::Type{.value = schema::Type::Integer{}};
+
+    } else if constexpr (std::is_same<T, Type::Float>() ||
+                         std::is_same<T, Type::Double>()) {
+      return schema::Type{.value = schema::Type::Number{}};
+
+    } else if constexpr (std::is_same<T, Type::String>()) {
+      return schema::Type{.value = schema::Type::String{}};
+
+    } else if constexpr (std::is_same<T, Type::AnyOf>()) {
+      auto any_of = std::vector<schema::Type>();
+      for (const auto& t : _t.types_) {
+        any_of.emplace_back(type_to_json_schema_type(t));
+      }
+      return schema::Type{.value = schema::Type::AnyOf{.anyOf = any_of}};
+
+    } else if constexpr (std::is_same<T, Type::Description>()) {
+      auto res = type_to_json_schema_type(*_t.type_);
+      const auto update_prediction = [&](auto _v) -> schema::Type {
+        _v.description = _t.description_;
+        return schema::Type{_v};
+      };
+      return std::visit(update_prediction, res.value);
+
+    } else if constexpr (std::is_same<T, Type::FixedSizeTypedArray>()) {
+      return schema::Type{.value = schema::Type::FixedSizeTypedArray{
+                              .items = Ref<schema::Type>::make(
+                                  type_to_json_schema_type(*_t.type_)),
+                              .minContains = _t.size_,
+                              .maxContains = _t.size_}};
+
+    } else if constexpr (std::is_same<T, Type::Literal>()) {
+      return schema::Type{.value =
+                              schema::Type::StringEnum{.values = _t.values_}};
+
+    } else if constexpr (std::is_same<T, Type::Object>()) {
+      auto properties = std::map<std::string, schema::Type>();
+      auto required = std::vector<std::string>();
+      for (const auto& [k, v] : _t.types_) {
+        properties[k] = type_to_json_schema_type(v);
+        if (!is_optional(v)) {
+          required.push_back(k);
+        }
+      }
+      return schema::Type{.value = schema::Type::Object{
+                              .properties = properties, .required = required}};
+
+    } else if constexpr (std::is_same<T, Type::Optional>()) {
+      return schema::Type{.value = schema::Type::AnyOf{
+                              .anyOf = {type_to_json_schema_type(*_t.type_),
+                                        schema::Type{schema::Type::Null{}}}}};
+
+    } else if constexpr (std::is_same<T, Type::Reference>()) {
+      return schema::Type{
+          .value = schema::Type::Reference{.ref = "#/definitions/" + _t.name_}};
+
+    } else if constexpr (std::is_same<T, Type::StringMap>()) {
+      return schema::Type{.value = schema::Type::StringMap{
+                              .additionalProperties = Ref<schema::Type>::make(
+                                  type_to_json_schema_type(*_t.value_type_))}};
+
+    } else if constexpr (std::is_same<T, Type::Tuple>()) {
+      auto items = std::vector<schema::Type>();
+      for (const auto& t : _t.types_) {
+        items.emplace_back(type_to_json_schema_type(t));
+      }
+      return schema::Type{.value = schema::Type::Tuple{.prefixItems = items}};
+
+    } else if constexpr (std::is_same<T, Type::TypedArray>()) {
+      return schema::Type{.value = schema::Type::TypedArray{
+                              .items = Ref<schema::Type>::make(
+                                  type_to_json_schema_type(*_t.type_))}};
+
+    } else if constexpr (std::is_same<T, Type::Validated>()) {
+      return handle_validation_type(*_t.type_, _t.validation_);
+
+    } else {
+      static_assert(rfl::always_false_v<T>, "Not all cases were covered.");
+    }
+  };
+
+  return std::visit(handle_variant, _type.variant_);
+}
+
+template <class T>
+struct TypeHelper {};
+
+template <class... Ts>
+struct TypeHelper<std::variant<Ts...>> {
+  using JSONSchemaType = std::variant<schema::JSONSchema<Ts>...>;
+};
+
+/// Returns the JSON schema for a class.
+template <class T, class... Ps>
+std::string to_schema(const yyjson_write_flag _flag = 0) {
+  const auto internal_schema =
+      parsing::schema::make<Reader, Writer, T, Processors<Ps...>>();
+  auto definitions = std::map<std::string, schema::Type>();
+  for (const auto& [k, v] : internal_schema.definitions_) {
+    definitions[k] = type_to_json_schema_type(v);
+  }
+  using JSONSchemaType =
+      typename TypeHelper<schema::Type::ReflectionType>::JSONSchemaType;
+  const auto to_schema = [&](auto&& _root) -> JSONSchemaType {
+    using U = std::decay_t<decltype(_root)>;
+    return schema::JSONSchema<U>{.root = std::move(_root),
+                                 .definitions = definitions};
+  };
+  auto root = type_to_json_schema_type(internal_schema.root_);
+  const auto json_schema = std::visit(to_schema, std::move(root.value));
+  return write(json_schema, _flag);
+}
+}  // namespace rfl::json
+
+#endif
diff --git a/include/rfl/json/write.hpp b/include/rfl/json/write.hpp
new file mode 100644
index 0000000..8f5bc50
--- /dev/null
+++ b/include/rfl/json/write.hpp
@@ -0,0 +1,52 @@
+#ifndef RFL_JSON_WRITE_HPP_
+#define RFL_JSON_WRITE_HPP_
+
+#include <yyjson.h>
+
+#include <ostream>
+#include <sstream>
+#include <string>
+
+#include "../Processors.hpp"
+#include "../parsing/Parent.hpp"
+#include "Parser.hpp"
+
+namespace rfl {
+namespace json {
+
+/// Convenient alias for the YYJSON pretty flag
+inline constexpr yyjson_write_flag pretty = YYJSON_WRITE_PRETTY;
+
+/// Returns a JSON string.
+template <class... Ps>
+std::string write(const auto& _obj, const yyjson_write_flag _flag = 0) {
+  using T = std::remove_cvref_t<decltype(_obj)>;
+  using ParentType = parsing::Parent<Writer>;
+  auto w = Writer(yyjson_mut_doc_new(NULL));
+  Parser<T, Processors<Ps...>>::write(w, _obj, typename ParentType::Root{});
+  const char* json_c_str = yyjson_mut_write(w.doc_, _flag, NULL);
+  const auto json_str = std::string(json_c_str);
+  free((void*)json_c_str);
+  yyjson_mut_doc_free(w.doc_);
+  return json_str;
+}
+
+/// Writes a JSON into an ostream.
+template <class... Ps>
+std::ostream& write(const auto& _obj, std::ostream& _stream,
+                    const yyjson_write_flag _flag = 0) {
+  using T = std::remove_cvref_t<decltype(_obj)>;
+  using ParentType = parsing::Parent<Writer>;
+  auto w = Writer(yyjson_mut_doc_new(NULL));
+  Parser<T, Processors<Ps...>>::write(w, _obj, typename ParentType::Root{});
+  const char* json_c_str = yyjson_mut_write(w.doc_, _flag, NULL);
+  _stream << json_c_str;
+  free((void*)json_c_str);
+  yyjson_mut_doc_free(w.doc_);
+  return _stream;
+}
+
+}  // namespace json
+}  // namespace rfl
+
+#endif  // JSON_PARSER_HPP_
diff --git a/include/rfl/msgpack.hpp b/include/rfl/msgpack.hpp
new file mode 100644
index 0000000..45e8c66
--- /dev/null
+++ b/include/rfl/msgpack.hpp
@@ -0,0 +1,13 @@
+#ifndef RFL_MSGPACK_HPP_
+#define RFL_MSGPACK_HPP_
+
+#include "../rfl.hpp"
+#include "msgpack/Parser.hpp"
+#include "msgpack/Reader.hpp"
+#include "msgpack/Writer.hpp"
+#include "msgpack/load.hpp"
+#include "msgpack/read.hpp"
+#include "msgpack/save.hpp"
+#include "msgpack/write.hpp"
+
+#endif
diff --git a/include/rfl/msgpack/Parser.hpp b/include/rfl/msgpack/Parser.hpp
new file mode 100644
index 0000000..79da146
--- /dev/null
+++ b/include/rfl/msgpack/Parser.hpp
@@ -0,0 +1,46 @@
+#ifndef RFL_MSGPACK_PARSER_HPP_
+#define RFL_MSGPACK_PARSER_HPP_
+
+#include "../parsing/Parser.hpp"
+#include "Reader.hpp"
+#include "Writer.hpp"
+
+namespace rfl {
+namespace parsing {
+
+/// msgpack-c requires us to explicitly set the number of fields in advance.
+/// Because of that, we require all of the fields and then set them to nullptr,
+/// if necessary.
+template <class ProcessorsType, class... FieldTypes>
+requires AreReaderAndWriter<msgpack::Reader, msgpack::Writer,
+                            NamedTuple<FieldTypes...>>
+struct Parser<msgpack::Reader, msgpack::Writer, NamedTuple<FieldTypes...>,
+              ProcessorsType>
+    : public NamedTupleParser<msgpack::Reader, msgpack::Writer,
+                              /*_ignore_empty_containers=*/false,
+                              /*_all_required=*/true, ProcessorsType,
+                              FieldTypes...> {
+};
+
+template <class ProcessorsType, class... Ts>
+requires AreReaderAndWriter<msgpack::Reader, msgpack::Writer, std::tuple<Ts...>>
+struct Parser<msgpack::Reader, msgpack::Writer, std::tuple<Ts...>,
+              ProcessorsType>
+    : public TupleParser<msgpack::Reader, msgpack::Writer,
+                         /*_ignore_empty_containers=*/false,
+                         /*_all_required=*/true, ProcessorsType, Ts...> {
+};
+
+}  // namespace parsing
+}  // namespace rfl
+
+namespace rfl {
+namespace msgpack {
+
+template <class T, class ProcessorsType>
+using Parser = parsing::Parser<Reader, Writer, T, ProcessorsType>;
+
+}
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/msgpack/Reader.hpp b/include/rfl/msgpack/Reader.hpp
new file mode 100644
index 0000000..004251d
--- /dev/null
+++ b/include/rfl/msgpack/Reader.hpp
@@ -0,0 +1,148 @@
+#ifndef RFL_MSGPACK_READER_HPP_
+#define RFL_MSGPACK_READER_HPP_
+
+#include <msgpack.h>
+
+#include <array>
+#include <concepts>
+#include <exception>
+#include <map>
+#include <memory>
+#include <source_location>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+#include "../Box.hpp"
+#include "../Result.hpp"
+#include "../always_false.hpp"
+
+namespace rfl {
+namespace msgpack {
+
+struct Reader {
+  using InputArrayType = msgpack_object_array;
+  using InputObjectType = msgpack_object_map;
+  using InputVarType = msgpack_object;
+
+  template <class T>
+  static constexpr bool has_custom_constructor = (requires(InputVarType var) {
+    T::from_msgpack_obj(var);
+  });
+
+  rfl::Result<InputVarType> get_field(
+      const std::string& _name, const InputObjectType& _obj) const noexcept {
+    for (uint32_t i = 0; i < _obj.size; ++i) {
+      const auto& key = _obj.ptr[i].key;
+      if (key.type != MSGPACK_OBJECT_STR) {
+        return Error("Key in element " + std::to_string(i) +
+                     " was not a string.");
+      }
+      const auto current_name =
+          std::string_view(key.via.str.ptr, key.via.str.size);
+      if (_name == current_name) {
+        return _obj.ptr[i].val;
+      }
+    }
+    return Error("No field named '" + _name + "' was found.");
+  }
+
+  bool is_empty(const InputVarType& _var) const noexcept {
+    return _var.type == MSGPACK_OBJECT_NIL;
+  }
+
+  template <class T>
+  rfl::Result<T> to_basic_type(const InputVarType& _var) const noexcept {
+    const auto type = _var.type;
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      if (type != MSGPACK_OBJECT_STR) {
+        return Error("Could not cast to string.");
+      }
+      const auto str = _var.via.str;
+      return std::string(str.ptr, str.size);
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      if (type != MSGPACK_OBJECT_BOOLEAN) {
+        return Error("Could not cast to boolean.");
+      }
+      return _var.via.boolean;
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>() ||
+                         std::is_integral<std::remove_cvref_t<T>>()) {
+      if (type == MSGPACK_OBJECT_FLOAT32 || type == MSGPACK_OBJECT_FLOAT64 ||
+          type == MSGPACK_OBJECT_FLOAT) {
+        return static_cast<T>(_var.via.f64);
+      } else if (type == MSGPACK_OBJECT_POSITIVE_INTEGER) {
+        return static_cast<T>(_var.via.u64);
+      } else if (type == MSGPACK_OBJECT_NEGATIVE_INTEGER) {
+        return static_cast<T>(_var.via.i64);
+      }
+      return rfl::Error(
+          "Could not cast to numeric value. The type must be integral, float "
+          "or double.");
+    } else {
+      static_assert(rfl::always_false_v<T>, "Unsupported type.");
+    }
+  }
+
+  rfl::Result<InputArrayType> to_array(
+      const InputVarType& _var) const noexcept {
+    if (_var.type != MSGPACK_OBJECT_ARRAY) {
+      return Error("Could not cast to an array.");
+    }
+    return _var.via.array;
+  }
+
+  rfl::Result<InputObjectType> to_object(
+      const InputVarType& _var) const noexcept {
+    if (_var.type != MSGPACK_OBJECT_MAP) {
+      return Error("Could not cast to a map.");
+    }
+    return _var.via.map;
+  }
+
+  template <class ArrayReader>
+  std::optional<Error> read_array(const ArrayReader& _array_reader,
+                                  const InputArrayType& _arr) const noexcept {
+    for (uint32_t i = 0; i < _arr.size; ++i) {
+      const auto err = _array_reader.read(_arr.ptr[i]);
+      if (err) {
+        return err;
+      }
+    }
+    return std::nullopt;
+  }
+
+  template <class ObjectReader>
+  std::optional<Error> read_object(const ObjectReader& _object_reader,
+                                   const InputObjectType& _obj) const noexcept {
+    for (uint32_t i = 0; i < _obj.size; ++i) {
+      const auto& key = _obj.ptr[i].key;
+      const auto& val = _obj.ptr[i].val;
+      if (key.type != MSGPACK_OBJECT_STR) {
+        return Error("Key in element " + std::to_string(i) +
+                     " was not a string.");
+      }
+      const auto name = std::string_view(key.via.str.ptr, key.via.str.size);
+      _object_reader.read(name, val);
+    }
+    return std::nullopt;
+  }
+
+  template <class T>
+  rfl::Result<T> use_custom_constructor(
+      const InputVarType& _var) const noexcept {
+    try {
+      return T::from_msgpack_obj(_var);
+    } catch (std::exception& e) {
+      return rfl::Error(e.what());
+    }
+  }
+};
+
+}  // namespace msgpack
+}  // namespace rfl
+
+#endif  // JSON_PARSER_HPP_
diff --git a/include/rfl/msgpack/Writer.hpp b/include/rfl/msgpack/Writer.hpp
new file mode 100644
index 0000000..0ee2796
--- /dev/null
+++ b/include/rfl/msgpack/Writer.hpp
@@ -0,0 +1,154 @@
+#ifndef RFL_MSGPACK_WRITER_HPP_
+#define RFL_MSGPACK_WRITER_HPP_
+
+#include <msgpack.h>
+
+#include <exception>
+#include <map>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <variant>
+#include <vector>
+
+#include "../Box.hpp"
+#include "../Ref.hpp"
+#include "../Result.hpp"
+#include "../always_false.hpp"
+
+namespace rfl::msgpack {
+
+class Writer {
+ public:
+  struct MsgpackOutputArray {};
+
+  struct MsgpackOutputObject {};
+
+  struct MsgpackOutputVar {};
+
+  using OutputArrayType = MsgpackOutputArray;
+  using OutputObjectType = MsgpackOutputObject;
+  using OutputVarType = MsgpackOutputVar;
+
+  Writer(msgpack_packer* _pk) : pk_(_pk) {}
+
+  ~Writer() = default;
+
+  OutputArrayType array_as_root(const size_t _size) const noexcept {
+    return new_array(_size);
+  }
+
+  OutputObjectType object_as_root(const size_t _size) const noexcept {
+    return new_object(_size);
+  }
+
+  OutputVarType null_as_root() const noexcept {
+    msgpack_pack_nil(pk_);
+    return OutputVarType{};
+  }
+
+  template <class T>
+  OutputVarType value_as_root(const T& _var) const noexcept {
+    return new_value(_var);
+  }
+
+  OutputArrayType add_array_to_array(const size_t _size,
+                                     OutputArrayType* _parent) const noexcept {
+    return new_array(_size);
+  }
+
+  OutputArrayType add_array_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    msgpack_pack_str(pk_, _name.size());
+    msgpack_pack_str_body(pk_, _name.data(), _name.size());
+    return new_array(_size);
+  }
+
+  OutputObjectType add_object_to_array(
+      const size_t _size, OutputArrayType* _parent) const noexcept {
+    return new_object(_size);
+  }
+
+  OutputObjectType add_object_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    msgpack_pack_str(pk_, _name.size());
+    msgpack_pack_str_body(pk_, _name.data(), _name.size());
+    return new_object(_size);
+  }
+
+  template <class T>
+  OutputVarType add_value_to_array(const T& _var,
+                                   OutputArrayType* _parent) const noexcept {
+    return new_value(_var);
+  }
+
+  template <class T>
+  OutputVarType add_value_to_object(const std::string_view& _name,
+                                    const T& _var,
+                                    OutputObjectType* _parent) const noexcept {
+    msgpack_pack_str(pk_, _name.size());
+    msgpack_pack_str_body(pk_, _name.data(), _name.size());
+    return new_value(_var);
+  }
+
+  OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept {
+    msgpack_pack_nil(pk_);
+    return OutputVarType{};
+  }
+
+  OutputVarType add_null_to_object(const std::string_view& _name,
+                                   OutputObjectType* _parent) const noexcept {
+    msgpack_pack_str(pk_, _name.size());
+    msgpack_pack_str_body(pk_, _name.data(), _name.size());
+    msgpack_pack_nil(pk_);
+    return OutputVarType{};
+  }
+
+  void end_array(OutputArrayType* _arr) const noexcept {}
+
+  void end_object(OutputObjectType* _obj) const noexcept {}
+
+ private:
+  OutputArrayType new_array(const size_t _size) const noexcept {
+    msgpack_pack_array(pk_, _size);
+    return OutputArrayType{};
+  }
+
+  OutputObjectType new_object(const size_t _size) const noexcept {
+    msgpack_pack_map(pk_, _size);
+    return OutputObjectType{};
+  }
+
+  template <class T>
+  OutputVarType new_value(const T& _var) const noexcept {
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      msgpack_pack_str(pk_, _var.size());
+      msgpack_pack_str_body(pk_, _var.c_str(), _var.size());
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      if (_var) {
+        msgpack_pack_true(pk_);
+      } else {
+        msgpack_pack_false(pk_);
+      }
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
+      msgpack_pack_double(pk_, static_cast<double>(_var));
+    } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
+      msgpack_pack_int64(pk_, static_cast<std::int64_t>(_var));
+    } else {
+      static_assert(rfl::always_false_v<T>, "Unsupported type.");
+    }
+    return OutputVarType{};
+  }
+
+ private:
+  /// The underlying packer.
+  msgpack_packer* pk_;
+};
+
+}  // namespace rfl::msgpack
+
+#endif  // MSGPACK_PARSER_HPP_
diff --git a/include/rfl/msgpack/load.hpp b/include/rfl/msgpack/load.hpp
new file mode 100644
index 0000000..5780257
--- /dev/null
+++ b/include/rfl/msgpack/load.hpp
@@ -0,0 +1,22 @@
+#ifndef RFL_MSGPACK_LOAD_HPP_
+#define RFL_MSGPACK_LOAD_HPP_
+
+#include "../Result.hpp"
+#include "../io/load_bytes.hpp"
+#include "read.hpp"
+
+namespace rfl {
+namespace msgpack {
+
+template <class T, class... Ps>
+Result<T> load(const std::string& _fname) {
+  const auto read_bytes = [](const auto& _bytes) {
+    return read<T, Ps...>(_bytes);
+  };
+  return rfl::io::load_bytes(_fname).and_then(read_bytes);
+}
+
+}  // namespace msgpack
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/msgpack/read.hpp b/include/rfl/msgpack/read.hpp
new file mode 100644
index 0000000..0e0b676
--- /dev/null
+++ b/include/rfl/msgpack/read.hpp
@@ -0,0 +1,57 @@
+#ifndef RFL_MSGPACK_READ_HPP_
+#define RFL_MSGPACK_READ_HPP_
+
+#include <msgpack.h>
+
+#include <istream>
+#include <string>
+
+#include "../Processors.hpp"
+#include "../internal/wrap_in_rfl_array_t.hpp"
+#include "Parser.hpp"
+#include "Reader.hpp"
+
+namespace rfl {
+namespace msgpack {
+
+using InputObjectType = typename Reader::InputObjectType;
+using InputVarType = typename Reader::InputVarType;
+
+/// Parses an object from a MSGPACK var.
+template <class T, class... Ps>
+auto read(const InputVarType& _obj) {
+  const auto r = Reader();
+  return Parser<T, Processors<Ps...>>::read(r, _obj);
+}
+
+/// Parses an object from MSGPACK using reflection.
+template <class T, class... Ps>
+Result<internal::wrap_in_rfl_array_t<T>> read(const char* _bytes,
+                                              const size_t _size) {
+  msgpack_zone mempool;
+  msgpack_zone_init(&mempool, 2048);
+  msgpack_object deserialized;
+  msgpack_unpack(_bytes, _size, NULL, &mempool, &deserialized);
+  auto r = read<T, Ps...>(deserialized);
+  msgpack_zone_destroy(&mempool);
+  return r;
+}
+
+/// Parses an object from MSGPACK using reflection.
+template <class T, class... Ps>
+auto read(const std::vector<char>& _bytes) {
+  return read<T, Ps...>(_bytes.data(), _bytes.size());
+}
+
+/// Parses an object from a stream.
+template <class T, class... Ps>
+auto read(std::istream& _stream) {
+  std::istreambuf_iterator<char> begin(_stream), end;
+  auto bytes = std::vector<char>(begin, end);
+  return read<T, Ps...>(bytes.data(), bytes.size());
+}
+
+}  // namespace msgpack
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/msgpack/save.hpp b/include/rfl/msgpack/save.hpp
new file mode 100644
index 0000000..1d2cfe5
--- /dev/null
+++ b/include/rfl/msgpack/save.hpp
@@ -0,0 +1,26 @@
+#ifndef RFL_MSGPACK_SAVE_HPP_
+#define RFL_MSGPACK_SAVE_HPP_
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#include "../Result.hpp"
+#include "../io/save_bytes.hpp"
+#include "write.hpp"
+
+namespace rfl {
+namespace msgpack {
+
+template <class... Ps>
+Result<Nothing> save(const std::string& _fname, const auto& _obj) {
+  const auto write_func = [](const auto& _obj, auto& _stream) -> auto& {
+    return write<Ps...>(_obj, _stream);
+  };
+  return rfl::io::save_bytes(_fname, _obj, write_func);
+}
+
+}  // namespace msgpack
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/msgpack/write.hpp b/include/rfl/msgpack/write.hpp
new file mode 100644
index 0000000..620ebb9
--- /dev/null
+++ b/include/rfl/msgpack/write.hpp
@@ -0,0 +1,44 @@
+#ifndef RFL_MSGPACK_WRITE_HPP_
+#define RFL_MSGPACK_WRITE_HPP_
+
+#include <msgpack.h>
+
+#include <cstdint>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "../Processors.hpp"
+#include "../parsing/Parent.hpp"
+#include "Parser.hpp"
+
+namespace rfl::msgpack {
+
+/// Returns msgpack bytes.
+template <class... Ps>
+std::vector<char> write(const auto& _obj) noexcept {
+  using T = std::remove_cvref_t<decltype(_obj)>;
+  using ParentType = parsing::Parent<Writer>;
+  msgpack_sbuffer sbuf;
+  msgpack_sbuffer_init(&sbuf);
+  msgpack_packer pk;
+  msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
+  auto w = Writer(&pk);
+  Parser<T, Processors<Ps...>>::write(w, _obj, typename ParentType::Root{});
+  auto bytes = std::vector<char>(sbuf.data, sbuf.data + sbuf.size);
+  msgpack_sbuffer_destroy(&sbuf);
+  return bytes;
+}
+
+/// Writes a MSGPACK into an ostream.
+template <class... Ps>
+std::ostream& write(const auto& _obj, std::ostream& _stream) noexcept {
+  auto buffer = write<Ps...>(_obj);
+  _stream.write(buffer.data(), buffer.size());
+  return _stream;
+}
+
+}  // namespace rfl::msgpack
+
+#endif
diff --git a/include/rfl/parsing/NamedTupleParser.hpp b/include/rfl/parsing/NamedTupleParser.hpp
index 9882868..59fc718 100644
--- a/include/rfl/parsing/NamedTupleParser.hpp
+++ b/include/rfl/parsing/NamedTupleParser.hpp
@@ -6,6 +6,7 @@
 #include <tuple>
 #include <type_traits>
 #include <unordered_map>
+#include <utility>
 
 #include "../NamedTuple.hpp"
 #include "../Result.hpp"
@@ -59,7 +60,7 @@ struct NamedTupleParser {
     using ViewType = std::remove_cvref_t<decltype(view)>;
     const auto err =
         Parser<R, W, ViewType, ProcessorsType>::read_view(_r, _var, &view);
-    if (err) {
+    if (err) [[unlikely]] {
       return *err;
     }
     return *ptr;
@@ -69,11 +70,11 @@ struct NamedTupleParser {
   static std::optional<Error> read_view(
       const R& _r, const InputVarType& _var,
       NamedTuple<FieldTypes...>* _view) noexcept {
-    const auto obj = _r.to_object(_var);
-    if (obj) {
-      return read_object(_r, *obj, _view);
+    auto obj = _r.to_object(_var);
+    if (!obj) [[unlikely]] {
+      return obj.error();
     }
-    return obj.error();
+    return read_object(_r, *obj, _view);
   }
 
   /// For writing, we do not need to make the distinction between
@@ -147,38 +148,43 @@ struct NamedTupleParser {
   }
 
   /// Generates error messages for when fields are missing.
-  template <size_t _i = 0>
-  static void handle_missing_fields(const std::array<bool, size_>& _found,
-                                    const NamedTupleType& _view,
-                                    std::array<bool, size_>* _set,
-                                    std::vector<Error>* _errors) noexcept {
-    if constexpr (_i < sizeof...(FieldTypes)) {
-      using FieldType =
-          std::tuple_element_t<_i, typename NamedTupleType::Fields>;
-      using ValueType = std::remove_reference_t<
-          std::remove_pointer_t<typename FieldType::Type>>;
+  template <int _i>
+  static void handle_one_missing_field(const std::array<bool, size_>& _found,
+                                       const NamedTupleType& _view,
+                                       std::array<bool, size_>* _set,
+                                       std::vector<Error>* _errors) noexcept {
+    using FieldType = std::tuple_element_t<_i, typename NamedTupleType::Fields>;
+    using ValueType = std::remove_reference_t<
+        std::remove_pointer_t<typename FieldType::Type>>;
 
-      if (!std::get<_i>(_found)) {
-        if constexpr (_all_required ||
-                      is_required<ValueType, _ignore_empty_containers>()) {
-          constexpr auto current_name =
-              std::tuple_element_t<_i, typename NamedTupleType::Fields>::name();
-          _errors->push_back("Field named '" + std::string(current_name) +
-                             "' not found.");
+    if (!std::get<_i>(_found)) {
+      if constexpr (_all_required ||
+                    is_required<ValueType, _ignore_empty_containers>()) {
+        constexpr auto current_name =
+            std::tuple_element_t<_i, typename NamedTupleType::Fields>::name();
+        _errors->emplace_back(Error(
+            "Field named '" + std::string(current_name) + "' not found."));
+      } else {
+        if constexpr (!std::is_const_v<ValueType>) {
+          ::new (rfl::get<_i>(_view)) ValueType();
         } else {
-          if constexpr (!std::is_const_v<ValueType>) {
-            ::new (rfl::get<_i>(_view)) ValueType();
-          } else {
-            using NonConstT = std::remove_const_t<ValueType>;
-            ::new (const_cast<NonConstT*>(rfl::get<_i>(_view))) NonConstT();
-          }
-          std::get<_i>(*_set) = true;
+          using NonConstT = std::remove_const_t<ValueType>;
+          ::new (const_cast<NonConstT*>(rfl::get<_i>(_view))) NonConstT();
         }
+        std::get<_i>(*_set) = true;
       }
-      handle_missing_fields<_i + 1>(_found, _view, _set, _errors);
     }
   }
 
+  /// Generates error messages for when fields are missing.
+  template <int... _is>
+  static void handle_missing_fields(
+      const std::array<bool, size_>& _found, const NamedTupleType& _view,
+      std::array<bool, size_>* _set, std::vector<Error>* _errors,
+      std::integer_sequence<int, _is...>) noexcept {
+    (handle_one_missing_field<_is>(_found, _view, _set, _errors), ...);
+  }
+
   static std::optional<Error> read_object(const R& _r,
                                           const InputObjectType& _obj,
                                           NamedTupleType* _view) noexcept {
@@ -193,7 +199,8 @@ struct NamedTupleParser {
     if (err) {
       return *err;
     }
-    handle_missing_fields(found, *_view, &set, &errors);
+    handle_missing_fields(found, *_view, &set, &errors,
+                          std::make_integer_sequence<int, size_>());
     if (errors.size() != 0) {
       object_reader.call_destructors_where_necessary();
       return to_single_error_message(errors);
diff --git a/include/rfl/parsing/Parser_default.hpp b/include/rfl/parsing/Parser_default.hpp
index a3b5b0a..88e5606 100644
--- a/include/rfl/parsing/Parser_default.hpp
+++ b/include/rfl/parsing/Parser_default.hpp
@@ -17,11 +17,11 @@
 #include "../internal/is_validator.hpp"
 #include "../internal/processed_t.hpp"
 #include "../internal/to_ptr_named_tuple.hpp"
+#include "../to_view.hpp"
 #include "../type_name_t.hpp"
 #include "AreReaderAndWriter.hpp"
 #include "Parent.hpp"
 #include "Parser_base.hpp"
-#include "StructReader.hpp"
 #include "is_tagged_union_wrapper.hpp"
 #include "schema/Type.hpp"
 
@@ -55,19 +55,13 @@ struct Parser {
         return Parser<R, W, ReflectionType, ProcessorsType>::read(_r, _var)
             .and_then(wrap_in_t);
       } else if constexpr (std::is_class_v<T> && std::is_aggregate_v<T>) {
-        return StructReader<R, W, T, ProcessorsType>::read(_r, _var);
+        return read_struct(_r, _var);
       } else if constexpr (std::is_enum_v<T>) {
         using StringConverter = internal::enums::StringConverter<T>;
         return _r.template to_basic_type<std::string>(_var).and_then(
             StringConverter::string_to_enum);
-      } else if constexpr (internal::is_basic_type_v<T>) {
-        return _r.template to_basic_type<std::remove_cvref_t<T>>(_var);
       } else {
-        static_assert(
-            always_false_v<T>,
-            "Unsupported type. Please refer to the sections on custom "
-            "classes and custom parsers for information on how add "
-            "support for your own classes.");
+        return _r.template to_basic_type<std::remove_cvref_t<T>>(_var);
       }
     }
   }
@@ -93,13 +87,8 @@ struct Parser {
       using StringConverter = internal::enums::StringConverter<T>;
       const auto str = StringConverter::enum_to_string(_var);
       ParentType::add_value(_w, str, _parent);
-    } else if constexpr (internal::is_basic_type_v<T>) {
-      ParentType::add_value(_w, _var, _parent);
     } else {
-      static_assert(always_false_v<T>,
-                    "Unsupported type. Please refer to the sections on custom "
-                    "classes and custom parsers for information on how add "
-                    "support for your own classes.");
+      ParentType::add_value(_w, _var, _parent);
     }
   }
 
@@ -222,6 +211,23 @@ struct Parser {
     }
   }
 
+  /// The way this works is that we allocate space on the stack in this size of
+  /// the struct in which we then write the individual fields using
+  /// views and placement new. This is how we deal with the fact that some
+  /// fields might not be default-constructible.
+  static Result<T> read_struct(const R& _r, const InputVarType& _var) {
+    alignas(T) unsigned char buf[sizeof(T)];
+    auto ptr = reinterpret_cast<T*>(buf);
+    auto view = ProcessorsType::template process<T>(to_view(*ptr));
+    using ViewType = std::remove_cvref_t<decltype(view)>;
+    const auto err =
+        Parser<R, W, ViewType, ProcessorsType>::read_view(_r, _var, &view);
+    if (err) [[unlikely]] {
+      return *err;
+    }
+    return std::move(*ptr);
+  }
+
   static std::string replace_non_alphanumeric(std::string _str) {
     for (auto& ch : _str) {
       ch = std::isalnum(ch) ? ch : '_';
diff --git a/include/rfl/parsing/StructReader.hpp b/include/rfl/parsing/StructReader.hpp
deleted file mode 100644
index e32f2c6..0000000
--- a/include/rfl/parsing/StructReader.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef RFL_PARSING_STRUCTREADER_HPP_
-#define RFL_PARSING_STRUCTREADER_HPP_
-
-#include <array>
-#include <string_view>
-#include <type_traits>
-#include <vector>
-
-#include "../Result.hpp"
-#include "../to_view.hpp"
-#include "AreReaderAndWriter.hpp"
-
-namespace rfl::parsing {
-
-template <class R, class W, class StructType, class ProcessorsType>
-requires AreReaderAndWriter<R, W, StructType>
-struct StructReader {
- public:
-  using InputVarType = typename R::InputVarType;
-
-  /// The way this works is that we allocate space on the stack in this size of
-  /// the struct in which we then write the individual fields using
-  /// views and placement new. This is how we deal with the fact that some
-  /// fields might not be default-constructible.
-  static Result<StructType> read(const R& _r, const InputVarType& _var) {
-    alignas(StructType) unsigned char buf[sizeof(StructType)];
-    auto ptr = reinterpret_cast<StructType*>(buf);
-    auto view = ProcessorsType::template process<StructType>(to_view(*ptr));
-    using ViewType = std::remove_cvref_t<decltype(view)>;
-    const auto err =
-        Parser<R, W, ViewType, ProcessorsType>::read_view(_r, _var, &view);
-    if (err) {
-      return *err;
-    }
-    return std::move(*ptr);
-  }
-};
-
-}  // namespace rfl::parsing
-
-#endif
diff --git a/include/rfl/parsing/ViewReader.hpp b/include/rfl/parsing/ViewReader.hpp
index 3f3eb5c..d1ba971 100644
--- a/include/rfl/parsing/ViewReader.hpp
+++ b/include/rfl/parsing/ViewReader.hpp
@@ -4,6 +4,7 @@
 #include <array>
 #include <string_view>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 #include "../Result.hpp"
@@ -24,63 +25,68 @@ class ViewReader {
 
   ~ViewReader() = default;
 
-  template <size_t _i = 0>
+  /// Assigns the parsed version of _var to the field signified by _name, if
+  /// such a field exists in the underlying view.
   void read(const std::string_view& _name, const InputVarType& _var) const {
-    if constexpr (_i < size_) {
-      using FieldType = std::tuple_element_t<_i, typename ViewType::Fields>;
-      using OriginalType = std::remove_cvref_t<typename FieldType::Type>;
-      using CurrentType =
-          std::remove_cvref_t<std::remove_pointer_t<OriginalType>>;
-      constexpr auto current_name = FieldType::name();
-      if (!std::get<_i>(*found_) && _name == current_name) {
-        auto res = Parser<R, W, CurrentType, ProcessorsType>::read(*r_, _var);
-        if (res) {
-          if constexpr (std::is_pointer_v<OriginalType>) {
-            move_to(rfl::get<_i>(*view_), &(*res));
-          } else {
-            rfl::get<_i>(*view_) = *res;
-          }
-          std::get<_i>(*set_) = true;
-        } else {
-          errors_->push_back(Error("Failed to parse field '" +
-                                   std::string(current_name) +
-                                   "': " + res.error()->what()));
-        }
-        std::get<_i>(*found_) = true;
-        return;
-      }
-      read<_i + 1>(_name, _var);
-    }
+    assign_to_matching_field(*r_, _name, _var, view_, errors_, found_, set_,
+                             std::make_integer_sequence<int, size_>());
   }
 
   /// Because of the way we have allocated the fields, we need to manually
   /// trigger the destructors.
-  template <size_t _i = 0>
   void call_destructors_where_necessary() const {
-    if constexpr (_i < size_) {
-      using FieldType = std::tuple_element_t<_i, typename ViewType::Fields>;
-      using OriginalType = std::remove_cvref_t<typename FieldType::Type>;
-      using ValueType =
-          std::remove_cvref_t<std::remove_pointer_t<typename FieldType::Type>>;
-      if constexpr (!std::is_array_v<ValueType> &&
-                    std::is_pointer_v<OriginalType> &&
-                    std::is_destructible_v<ValueType>) {
-        if (std::get<_i>(*set_)) {
-          rfl::get<_i>(*view_)->~ValueType();
-        }
-      } else if constexpr (std::is_array_v<ValueType>) {
-        if (std::get<_i>(*set_)) {
-          auto ptr = rfl::get<_i>(*view_);
-          call_destructor_on_array(sizeof(*ptr) / sizeof(**ptr), *ptr);
-        }
-      }
-      call_destructors_where_necessary<_i + 1>();
+    [&]<int... is>(std::integer_sequence<int, is...>) {
+      (call_destructor_on_one_if_necessary<is>(), ...);
     }
+    (std::make_integer_sequence<int, size_>());
   }
 
  private:
+  template <int i>
+  static void assign_if_field_matches(const R& _r,
+                                      const std::string_view& _current_name,
+                                      const auto& _var, auto* _view,
+                                      auto* _errors, auto* _found, auto* _set,
+                                      bool* _already_assigned) {
+    using FieldType = std::tuple_element_t<i, typename ViewType::Fields>;
+    using OriginalType = typename FieldType::Type;
+    using T =
+        std::remove_cvref_t<std::remove_pointer_t<typename FieldType::Type>>;
+    constexpr auto name = FieldType::name();
+    if (!(*_already_assigned) && !std::get<i>(*_found) &&
+        _current_name == name) {
+      std::get<i>(*_found) = true;
+      *_already_assigned = true;
+      auto res = Parser<R, W, T, ProcessorsType>::read(_r, _var);
+      if (!res) {
+        _errors->emplace_back(Error("Failed to parse field '" +
+                                    std::string(name) +
+                                    "': " + std::move(res.error()->what())));
+        return;
+      }
+      if constexpr (std::is_pointer_v<OriginalType>) {
+        move_to(rfl::get<i>(*_view), &(*res));
+      } else {
+        rfl::get<i>(*_view) = std::move(*res);
+      }
+      std::get<i>(*_set) = true;
+    }
+  }
+
+  template <int... is>
+  static void assign_to_matching_field(const R& _r,
+                                       const std::string_view& _current_name,
+                                       const auto& _var, auto* _view,
+                                       auto* _errors, auto* _found, auto* _set,
+                                       std::integer_sequence<int, is...>) {
+    bool already_assigned = false;
+    (assign_if_field_matches<is>(_r, _current_name, _var, _view, _errors,
+                                 _found, _set, &already_assigned),
+     ...);
+  }
+
   template <class T>
-  void call_destructor_on_array(const size_t _size, T* _ptr) const {
+  static void call_destructor_on_array(const size_t _size, T* _ptr) {
     for (size_t i = 0; i < _size; ++i) {
       if constexpr (std::is_array_v<T>) {
         call_destructor_on_array(sizeof(*_ptr) / sizeof(**_ptr), *(_ptr + i));
@@ -90,14 +96,34 @@ class ViewReader {
     }
   }
 
+  template <int _i>
+  void call_destructor_on_one_if_necessary() const {
+    using FieldType = std::tuple_element_t<_i, typename ViewType::Fields>;
+    using OriginalType = std::remove_cvref_t<typename FieldType::Type>;
+    using ValueType =
+        std::remove_cvref_t<std::remove_pointer_t<typename FieldType::Type>>;
+    if constexpr (!std::is_array_v<ValueType> &&
+                  std::is_pointer_v<OriginalType> &&
+                  std::is_destructible_v<ValueType>) {
+      if (std::get<_i>(*set_)) {
+        rfl::get<_i>(*view_)->~ValueType();
+      }
+    } else if constexpr (std::is_array_v<ValueType>) {
+      if (std::get<_i>(*set_)) {
+        auto ptr = rfl::get<_i>(*view_);
+        call_destructor_on_array(sizeof(*ptr) / sizeof(**ptr), *ptr);
+      }
+    }
+  }
+
   template <class Target, class Source>
-  void move_to(Target* _t, Source* _s) const {
+  static void move_to(Target* _t, Source* _s) {
     if constexpr (std::is_const_v<Target>) {
       return move_to(const_cast<std::remove_const_t<Target>*>(_t), _s);
-    } else if constexpr (!internal::is_array_v<Source> &&
+    } else if constexpr (!rfl::internal::is_array_v<Source> &&
                          !std::is_array_v<Target>) {
       ::new (_t) Target(std::move(*_s));
-    } else if constexpr (internal::is_array_v<Source>) {
+    } else if constexpr (rfl::internal::is_array_v<Source>) {
       static_assert(std::is_array_v<Target>,
                     "Expected target to be a c-array.");
       for (size_t i = 0; i < _s->arr_.size(); ++i) {
diff --git a/include/rfl/xml.hpp b/include/rfl/xml.hpp
new file mode 100644
index 0000000..ecb20c8
--- /dev/null
+++ b/include/rfl/xml.hpp
@@ -0,0 +1,13 @@
+#ifndef RFL_XML_HPP_
+#define RFL_XML_HPP_
+
+#include "../rfl.hpp"
+#include "xml/Parser.hpp"
+#include "xml/Reader.hpp"
+#include "xml/Writer.hpp"
+#include "xml/load.hpp"
+#include "xml/read.hpp"
+#include "xml/save.hpp"
+#include "xml/write.hpp"
+
+#endif
diff --git a/include/rfl/xml/Parser.hpp b/include/rfl/xml/Parser.hpp
new file mode 100644
index 0000000..687f751
--- /dev/null
+++ b/include/rfl/xml/Parser.hpp
@@ -0,0 +1,40 @@
+#ifndef RFL_XML_PARSER_HPP_
+#define RFL_XML_PARSER_HPP_
+
+#include <type_traits>
+
+#include "../internal/is_attribute.hpp"
+#include "../parsing/NamedTupleParser.hpp"
+#include "../parsing/Parser.hpp"
+#include "Reader.hpp"
+#include "Writer.hpp"
+
+namespace rfl {
+namespace parsing {
+
+/// XML is very special. It doesn't have proper support for arrays, which means
+/// that we just need to ignore empty containers. Therefore, we need to a
+/// template specialization for the NamedTuple parser to accommodate for it.
+template <class ProcessorsType, class... FieldTypes>
+requires AreReaderAndWriter<xml::Reader, xml::Writer, NamedTuple<FieldTypes...>>
+struct Parser<xml::Reader, xml::Writer, NamedTuple<FieldTypes...>,
+              ProcessorsType>
+    : public NamedTupleParser<xml::Reader, xml::Writer,
+                              /*_ignore_empty_containers=*/true,
+                              /*_all_required=*/ProcessorsType::all_required_,
+                              ProcessorsType, FieldTypes...> {
+};
+
+}  // namespace parsing
+}  // namespace rfl
+
+namespace rfl {
+namespace xml {
+
+template <class T, class ProcessorsType>
+using Parser = parsing::Parser<Reader, Writer, T, ProcessorsType>;
+
+}
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/xml/Reader.hpp b/include/rfl/xml/Reader.hpp
new file mode 100644
index 0000000..6500b0d
--- /dev/null
+++ b/include/rfl/xml/Reader.hpp
@@ -0,0 +1,174 @@
+#ifndef RFL_XML_READER_HPP_
+#define RFL_XML_READER_HPP_
+
+#include <array>
+#include <exception>
+#include <map>
+#include <memory>
+#include <optional>
+#include <pugixml.hpp>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+#include "../Result.hpp"
+#include "../always_false.hpp"
+#include "../parsing/is_view_reader.hpp"
+
+namespace rfl {
+namespace xml {
+
+struct Reader {
+  struct XMLInputArray {
+    XMLInputArray(pugi::xml_node _node) : node_(_node) {}
+    pugi::xml_node node_;
+  };
+
+  struct XMLInputObject {
+    XMLInputObject(pugi::xml_node _node) : node_(_node) {}
+    pugi::xml_node node_;
+  };
+
+  struct XMLInputVar {
+    XMLInputVar() : node_or_attribute_(pugi::xml_node()) {}
+    XMLInputVar(pugi::xml_attribute _attr) : node_or_attribute_(_attr) {}
+    XMLInputVar(pugi::xml_node _node) : node_or_attribute_(_node) {}
+    std::variant<pugi::xml_node, pugi::xml_attribute> node_or_attribute_;
+  };
+
+  using InputArrayType = XMLInputArray;
+  using InputObjectType = XMLInputObject;
+  using InputVarType = XMLInputVar;
+
+  // TODO
+  template <class T>
+  static constexpr bool has_custom_constructor = false;
+
+  /// XML-only helper function. This is needed because XML distinguishes between
+  /// nodes and attributes.
+  static rfl::Result<pugi::xml_node> cast_as_node(
+      const std::variant<pugi::xml_node, pugi::xml_attribute>&
+          _node_or_attribute) {
+    const auto cast = [](const auto& _n) -> Result<pugi::xml_node> {
+      using Type = std::remove_cvref_t<decltype(_n)>;
+      if constexpr (std::is_same<Type, pugi::xml_node>()) {
+        return _n;
+      } else {
+        return Error("Field '" + std::string(_n.name()) + "' is an attribute.");
+      }
+    };
+    return std::visit(cast, _node_or_attribute);
+  }
+
+  rfl::Result<InputVarType> get_field(
+      const std::string& _name, const InputObjectType _obj) const noexcept {
+    const auto node = _obj.node_.child(_name.c_str());
+    if (!node) {
+      return rfl::Error("Object contains no field named '" + _name + "'.");
+    }
+    return InputVarType(node);
+  }
+
+  bool is_empty(const InputVarType _var) const noexcept {
+    const auto wrap = [](const auto& _node) { return !_node; };
+    return std::visit(cast_as_node, _var.node_or_attribute_)
+        .transform(wrap)
+        .value_or(false);
+  }
+
+  template <class T>
+  rfl::Result<T> to_basic_type(const InputVarType _var) const noexcept {
+    const auto get_value = [](const auto& _n) -> std::string {
+      using Type = std::remove_cvref_t<decltype(_n)>;
+      if constexpr (std::is_same<Type, pugi::xml_node>()) {
+        return std::string(_n.child_value());
+      } else {
+        return std::string(_n.value());
+      }
+    };
+
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      return std::visit(get_value, _var.node_or_attribute_);
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      return std::visit(get_value, _var.node_or_attribute_) == "true";
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
+      const auto str = std::visit(get_value, _var.node_or_attribute_);
+      try {
+        return static_cast<T>(std::stod(str));
+      } catch (std::exception& e) {
+        return Error("Could not cast '" + std::string(str) +
+                     "' to floating point value.");
+      }
+    } else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
+      const auto str = std::visit(get_value, _var.node_or_attribute_);
+      try {
+        return static_cast<T>(std::stoi(str));
+      } catch (std::exception& e) {
+        return Error("Could not cast '" + std::string(str) + "' to integer.");
+      }
+    } else {
+      static_assert(rfl::always_false_v<T>, "Unsupported type.");
+    }
+  }
+
+  rfl::Result<InputArrayType> to_array(const InputVarType _var) const noexcept {
+    const auto wrap = [](const auto& _node) { return InputArrayType(_node); };
+    return std::visit(cast_as_node, _var.node_or_attribute_).transform(wrap);
+  }
+
+  template <class ArrayReader>
+  std::optional<Error> read_array(const ArrayReader& _array_reader,
+                                  const InputArrayType& _arr) const noexcept {
+    const auto name = _arr.node_.name();
+    for (auto node = _arr.node_; node; node = node.next_sibling(name)) {
+      const auto err = _array_reader.read(InputVarType(node));
+      if (err) {
+        return err;
+      }
+    }
+    return std::nullopt;
+  }
+
+  template <class ObjectReader>
+  std::optional<Error> read_object(const ObjectReader& _object_reader,
+                                   const InputObjectType& _obj) const noexcept {
+    for (auto child = _obj.node_.first_child(); child;
+         child = child.next_sibling()) {
+      _object_reader.read(std::string_view(child.name()), InputVarType(child));
+    }
+
+    for (auto attr = _obj.node_.first_attribute(); attr;
+         attr = attr.next_attribute()) {
+      _object_reader.read(std::string_view(attr.name()), InputVarType(attr));
+    }
+
+    if constexpr (parsing::is_view_reader_v<ObjectReader>) {
+      _object_reader.read(std::string_view("xml_content"),
+                          InputVarType(_obj.node_));
+    }
+
+    return std::nullopt;
+  }
+
+  rfl::Result<InputObjectType> to_object(
+      const InputVarType _var) const noexcept {
+    const auto wrap = [](const auto& _node) { return InputObjectType(_node); };
+    return std::visit(cast_as_node, _var.node_or_attribute_).transform(wrap);
+  }
+
+  template <class T>
+  rfl::Result<T> use_custom_constructor(
+      const InputVarType _var) const noexcept {
+    return rfl::Error("TODO");
+  }
+};
+
+}  // namespace xml
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/xml/Writer.hpp b/include/rfl/xml/Writer.hpp
new file mode 100644
index 0000000..be9131a
--- /dev/null
+++ b/include/rfl/xml/Writer.hpp
@@ -0,0 +1,181 @@
+#ifndef RFL_XML_WRITER_HPP_
+#define RFL_XML_WRITER_HPP_
+
+#include <exception>
+#include <map>
+#include <pugixml.hpp>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+#include "../Ref.hpp"
+#include "../Result.hpp"
+#include "../always_false.hpp"
+
+namespace rfl {
+namespace xml {
+
+struct Writer {
+  static constexpr const char* XML_CONTENT = "xml_content";
+
+  struct XMLOutputArray {
+    XMLOutputArray(const std::string_view& _name,
+                   const Ref<pugi::xml_node>& _node)
+        : name_(_name), node_(_node) {}
+    std::string_view name_;
+    Ref<pugi::xml_node> node_;
+  };
+
+  struct XMLOutputObject {
+    XMLOutputObject(const Ref<pugi::xml_node>& _node) : node_(_node) {}
+    Ref<pugi::xml_node> node_;
+  };
+
+  struct XMLOutputVar {
+    XMLOutputVar(const Ref<pugi::xml_node>& _node) : node_(_node) {}
+    Ref<pugi::xml_node> node_;
+  };
+
+  using OutputArrayType = XMLOutputArray;
+  using OutputObjectType = XMLOutputObject;
+  using OutputVarType = XMLOutputVar;
+
+  Writer(const Ref<pugi::xml_node>& _root, const std::string& _root_name)
+      : root_(_root), root_name_(_root_name) {}
+
+  ~Writer() = default;
+
+  OutputArrayType array_as_root(const size_t _size) const noexcept {
+    auto node_child =
+        Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
+    return OutputArrayType(root_name_, node_child);
+  }
+
+  OutputObjectType object_as_root(const size_t _size) const noexcept {
+    auto node_child =
+        Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
+    return OutputObjectType(node_child);
+  }
+
+  OutputVarType null_as_root() const noexcept {
+    auto node_child =
+        Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
+    return OutputVarType(node_child);
+  }
+
+  template <class T>
+  OutputVarType value_as_root(const T& _var) const noexcept {
+    const auto str = to_string(_var);
+    auto node_child =
+        Ref<pugi::xml_node>::make(root_->append_child(root_name_.c_str()));
+    node_child->append_child(pugi::node_pcdata).set_value(str.c_str());
+    return OutputVarType(node_child);
+  }
+
+  OutputArrayType add_array_to_array(const size_t _size,
+                                     OutputArrayType* _parent) const noexcept {
+    return *_parent;
+  }
+
+  OutputArrayType add_array_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    return OutputArrayType(_name, _parent->node_);
+  }
+
+  OutputObjectType add_object_to_array(
+      const size_t _size, OutputArrayType* _parent) const noexcept {
+    auto node_child = Ref<pugi::xml_node>::make(
+        _parent->node_->append_child(_parent->name_.data()));
+    return OutputObjectType(node_child);
+  }
+
+  OutputObjectType add_object_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    auto node_child =
+        Ref<pugi::xml_node>::make(_parent->node_->append_child(_name.data()));
+    return OutputObjectType(node_child);
+  }
+
+  template <class T>
+  OutputVarType add_value_to_array(const T& _var,
+                                   OutputArrayType* _parent) const noexcept {
+    const auto str = to_string(_var);
+    auto node_child = Ref<pugi::xml_node>::make(
+        _parent->node_->append_child(_parent->name_.data()));
+    node_child->append_child(pugi::node_pcdata).set_value(str.c_str());
+    return OutputVarType(node_child);
+  }
+
+  template <class T>
+  OutputVarType add_value_to_object(
+      const std::string_view& _name, const T& _var, OutputObjectType* _parent,
+      const bool _is_attribute = false) const noexcept {
+    const auto str = to_string(_var);
+    if (_is_attribute) {
+      _parent->node_->append_attribute(_name.data()) = str.c_str();
+      return OutputVarType(_parent->node_);
+    } else if (_name == XML_CONTENT) {
+      _parent->node_->append_child(pugi::node_pcdata).set_value(str.c_str());
+      return OutputVarType(_parent->node_);
+    } else {
+      auto node_child =
+          Ref<pugi::xml_node>::make(_parent->node_->append_child(_name.data()));
+      node_child->append_child(pugi::node_pcdata).set_value(str.c_str());
+      return OutputVarType(node_child);
+    }
+  }
+
+  OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept {
+    auto node_child = Ref<pugi::xml_node>::make(
+        _parent->node_->append_child(_parent->name_.data()));
+    return OutputVarType(node_child);
+  }
+
+  OutputVarType add_null_to_object(
+      const std::string_view& _name, OutputObjectType* _parent,
+      const bool _is_attribute = false) const noexcept {
+    if (_is_attribute) {
+      return OutputVarType(_parent->node_);
+    } else if (_name == XML_CONTENT) {
+      return OutputVarType(_parent->node_);
+    } else {
+      auto node_child =
+          Ref<pugi::xml_node>::make(_parent->node_->append_child(_name.data()));
+      return OutputVarType(node_child);
+    }
+  }
+
+  void end_array(OutputArrayType* _arr) const noexcept {}
+
+  void end_object(OutputObjectType* _obj) const noexcept {}
+
+ private:
+  template <class T>
+  std::string to_string(const T& _val) const noexcept {
+    if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
+      return _val;
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
+      return _val ? "true" : "false";
+    } else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>() ||
+                         std::is_integral<std::remove_cvref_t<T>>()) {
+      return std::to_string(_val);
+    } else {
+      static_assert(always_false_v<T>, "Unsupported type");
+    }
+  }
+
+ public:
+  Ref<pugi::xml_node> root_;
+
+  std::string root_name_;
+};
+
+}  // namespace xml
+}  // namespace rfl
+
+#endif  // XML_PARSER_HPP_
diff --git a/include/rfl/xml/load.hpp b/include/rfl/xml/load.hpp
new file mode 100644
index 0000000..861f8c4
--- /dev/null
+++ b/include/rfl/xml/load.hpp
@@ -0,0 +1,22 @@
+#ifndef RFL_XML_LOAD_HPP_
+#define RFL_XML_LOAD_HPP_
+
+#include "../Result.hpp"
+#include "../io/load_string.hpp"
+#include "read.hpp"
+
+namespace rfl {
+namespace xml {
+
+template <class T, class... Ps>
+Result<T> load(const std::string& _fname) {
+  const auto read_string = [](const auto& _str) {
+    return read<T, Ps...>(_str);
+  };
+  return rfl::io::load_string(_fname).and_then(read_string);
+}
+
+}  // namespace xml
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/xml/read.hpp b/include/rfl/xml/read.hpp
new file mode 100644
index 0000000..e20d4c5
--- /dev/null
+++ b/include/rfl/xml/read.hpp
@@ -0,0 +1,50 @@
+#ifndef RFL_XML_READ_HPP_
+#define RFL_XML_READ_HPP_
+
+#include <istream>
+#include <pugixml.hpp>
+#include <string>
+
+#include "../Processors.hpp"
+#include "../internal/get_type_name.hpp"
+#include "../internal/remove_namespaces.hpp"
+#include "Parser.hpp"
+#include "Reader.hpp"
+
+namespace rfl {
+namespace xml {
+
+using InputVarType = typename Reader::InputVarType;
+
+/// Parses an object from a XML var.
+template <class T, class... Ps>
+auto read(const InputVarType& _var) {
+  const auto r = Reader();
+  return Parser<T, Processors<Ps...>>::read(r, _var);
+}
+
+/// Parses an object from XML using reflection.
+template <class T, class... Ps>
+Result<T> read(const std::string& _xml_str) {
+  pugi::xml_document doc;
+  const auto result = doc.load_string(_xml_str.c_str());
+  if (!result) {
+    return Error("XML string could not be parsed: " +
+                 std::string(result.description()));
+  }
+  const auto var = InputVarType(doc.first_child());
+  return read<T, Ps...>(var);
+}
+
+/// Parses an object from a stringstream.
+template <class T, class... Ps>
+auto read(std::istream& _stream) {
+  const auto xml_str = std::string(std::istreambuf_iterator<char>(_stream),
+                                   std::istreambuf_iterator<char>());
+  return read<T, Ps...>(xml_str);
+}
+
+}  // namespace xml
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/xml/save.hpp b/include/rfl/xml/save.hpp
new file mode 100644
index 0000000..48c3e5c
--- /dev/null
+++ b/include/rfl/xml/save.hpp
@@ -0,0 +1,28 @@
+#ifndef RFL_XML_SAVE_HPP_
+#define RFL_XML_SAVE_HPP_
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#include "../Result.hpp"
+#include "../internal/StringLiteral.hpp"
+#include "../io/save_string.hpp"
+#include "write.hpp"
+
+namespace rfl {
+namespace xml {
+
+template <internal::StringLiteral _root = internal::StringLiteral(""),
+          class... Ps>
+Result<Nothing> save(const std::string& _fname, const auto& _obj) {
+  const auto write_func = [](const auto& _obj, auto& _stream) -> auto& {
+    return write<_root, Ps...>(_obj, _stream);
+  };
+  return rfl::io::save_string(_fname, _obj, write_func);
+}
+
+}  // namespace xml
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/xml/write.hpp b/include/rfl/xml/write.hpp
new file mode 100644
index 0000000..023c757
--- /dev/null
+++ b/include/rfl/xml/write.hpp
@@ -0,0 +1,74 @@
+#ifndef RFL_XML_WRITE_HPP_
+#define RFL_XML_WRITE_HPP_
+
+#include <ostream>
+#include <pugixml.hpp>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+#include "../Processors.hpp"
+#include "../internal/StringLiteral.hpp"
+#include "../internal/get_type_name.hpp"
+#include "../internal/remove_namespaces.hpp"
+#include "../parsing/Parent.hpp"
+#include "Parser.hpp"
+
+namespace rfl {
+namespace xml {
+
+template <internal::StringLiteral _root, class T>
+consteval auto get_root_name() {
+  if constexpr (_root != internal::StringLiteral("")) {
+    return _root;
+  } else {
+    return internal::remove_namespaces<
+        internal::get_type_name<std::remove_cvref_t<T>>()>();
+  }
+}
+
+/// Writes a XML into an ostream.
+template <internal::StringLiteral _root = internal::StringLiteral(""),
+          class... Ps>
+std::ostream& write(const auto& _obj, std::ostream& _stream,
+                    const std::string& _indent = "    ") {
+  using T = std::remove_cvref_t<decltype(_obj)>;
+  using ParentType = parsing::Parent<Writer>;
+
+  constexpr auto root_name = get_root_name<_root, T>();
+
+  static_assert(root_name.string_view().find("<") == std::string_view::npos &&
+                    root_name.string_view().find(">") == std::string_view::npos,
+                "The name of an XML root node cannot contain '<' or '>'. "
+                "Please assign an "
+                "explicit root name to rfl::xml::write(...) like this: "
+                "rfl::xml::write<\"root_name\">(...).");
+
+  const auto doc = rfl::Ref<pugi::xml_document>::make();
+
+  auto declaration_node = doc->append_child(pugi::node_declaration);
+  declaration_node.append_attribute("version") = "1.0";
+  declaration_node.append_attribute("encoding") = "UTF-8";
+
+  auto w = Writer(doc, root_name.str());
+
+  Parser<T, Processors<Ps...>>::write(w, _obj, typename ParentType::Root{});
+
+  doc->save(_stream, _indent.c_str());
+
+  return _stream;
+}
+
+/// Returns a XML string.
+template <internal::StringLiteral _root = internal::StringLiteral(""),
+          class... Ps>
+std::string write(const auto& _obj, const std::string& _indent = "    ") {
+  std::stringstream stream;
+  write<_root, Ps...>(_obj, stream);
+  return stream.str();
+}
+
+}  // namespace xml
+}  // namespace rfl
+
+#endif  // XML_PARSER_HPP_
diff --git a/include/rfl/yaml.hpp b/include/rfl/yaml.hpp
new file mode 100644
index 0000000..11cb13e
--- /dev/null
+++ b/include/rfl/yaml.hpp
@@ -0,0 +1,13 @@
+#ifndef RFL_YAML_HPP_
+#define RFL_YAML_HPP_
+
+#include "../rfl.hpp"
+#include "yaml/Parser.hpp"
+#include "yaml/Reader.hpp"
+#include "yaml/Writer.hpp"
+#include "yaml/load.hpp"
+#include "yaml/read.hpp"
+#include "yaml/save.hpp"
+#include "yaml/write.hpp"
+
+#endif
diff --git a/include/rfl/yaml/Parser.hpp b/include/rfl/yaml/Parser.hpp
new file mode 100644
index 0000000..78ef335
--- /dev/null
+++ b/include/rfl/yaml/Parser.hpp
@@ -0,0 +1,17 @@
+#ifndef RFL_YAML_PARSER_HPP_
+#define RFL_YAML_PARSER_HPP_
+
+#include "../parsing/Parser.hpp"
+#include "Reader.hpp"
+#include "Writer.hpp"
+
+namespace rfl {
+namespace yaml {
+
+template <class T, class ProcessorsType>
+using Parser = parsing::Parser<Reader, Writer, T, ProcessorsType>;
+
+}
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/yaml/Reader.hpp b/include/rfl/yaml/Reader.hpp
new file mode 100644
index 0000000..ab950ce
--- /dev/null
+++ b/include/rfl/yaml/Reader.hpp
@@ -0,0 +1,137 @@
+#ifndef RFL_YAML_READER_HPP_
+#define RFL_YAML_READER_HPP_
+
+#include <yaml-cpp/yaml.h>
+
+#include <array>
+#include <exception>
+#include <map>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+#include "../Result.hpp"
+#include "../always_false.hpp"
+
+namespace rfl {
+namespace yaml {
+
+struct Reader {
+  struct YAMLInputArray {
+    YAMLInputArray(const YAML::Node& _node) : node_(_node) {}
+    YAML::Node node_;
+  };
+
+  struct YAMLInputObject {
+    YAMLInputObject(const YAML::Node& _node) : node_(_node) {}
+    YAML::Node node_;
+  };
+
+  struct YAMLInputVar {
+    YAMLInputVar(const YAML::Node& _node) : node_(_node) {}
+    YAML::Node node_;
+  };
+
+  using InputArrayType = YAMLInputArray;
+  using InputObjectType = YAMLInputObject;
+  using InputVarType = YAMLInputVar;
+
+  template <class T, class = void>
+  struct has_from_json_obj : std::false_type {};
+
+  template <class T>
+  static constexpr bool has_custom_constructor = (requires(InputVarType var) {
+    T::from_yaml_obj(var);
+  });
+
+  rfl::Result<InputVarType> get_field(
+      const std::string& _name, const InputObjectType& _obj) const noexcept {
+    auto var = InputVarType(_obj.node_[_name]);
+    if (!var.node_) {
+      return rfl::Error("Object contains no field named '" + _name + "'.");
+    }
+    return var;
+  }
+
+  bool is_empty(const InputVarType& _var) const noexcept {
+    return !_var.node_ && true;
+  }
+
+  template <class T>
+  rfl::Result<T> to_basic_type(const InputVarType& _var) const noexcept {
+    try {
+      if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>() ||
+                    std::is_same<std::remove_cvref_t<T>, bool>() ||
+                    std::is_floating_point<std::remove_cvref_t<T>>() ||
+                    std::is_integral<std::remove_cvref_t<T>>()) {
+        return _var.node_.as<std::remove_cvref_t<T>>();
+      } else {
+        static_assert(rfl::always_false_v<T>, "Unsupported type.");
+      }
+    } catch (std::exception& e) {
+      return rfl::Error(e.what());
+    }
+  }
+
+  rfl::Result<InputArrayType> to_array(
+      const InputVarType& _var) const noexcept {
+    if (!_var.node_.IsSequence()) {
+      return rfl::Error("Could not cast to sequence!");
+    }
+    return InputArrayType(_var.node_);
+  }
+
+  template <class ArrayReader>
+  std::optional<Error> read_array(const ArrayReader& _array_reader,
+                                  const InputArrayType& _arr) const noexcept {
+    for (size_t i = 0; i < _arr.node_.size(); ++i) {
+      const auto err = _array_reader.read(_arr.node_[i]);
+      if (err) {
+        return err;
+      }
+    }
+    return std::nullopt;
+  }
+
+  template <class ObjectReader>
+  std::optional<Error> read_object(const ObjectReader& _object_reader,
+                                   const InputObjectType& _obj) const noexcept {
+    for (const auto& p : _obj.node_) {
+      try {
+        const auto k = p.first.as<std::string>();
+        _object_reader.read(std::string_view(k), InputVarType(p.second));
+      } catch (std::exception& e) {
+        continue;
+      }
+    }
+    return std::nullopt;
+  }
+
+  rfl::Result<InputObjectType> to_object(
+      const InputVarType& _var) const noexcept {
+    if (!_var.node_.IsMap()) {
+      return rfl::Error("Could not cast to map!");
+    }
+    return InputObjectType(_var.node_);
+  }
+
+  template <class T>
+  rfl::Result<T> use_custom_constructor(
+      const InputVarType _var) const noexcept {
+    try {
+      return T::from_yaml_obj(_var);
+    } catch (std::exception& e) {
+      return rfl::Error(e.what());
+    }
+  }
+};
+
+}  // namespace yaml
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/yaml/Writer.hpp b/include/rfl/yaml/Writer.hpp
new file mode 100644
index 0000000..c55d88e
--- /dev/null
+++ b/include/rfl/yaml/Writer.hpp
@@ -0,0 +1,148 @@
+#ifndef RFL_YAML_WRITER_HPP_
+#define RFL_YAML_WRITER_HPP_
+
+#include <yaml-cpp/yaml.h>
+
+#include <exception>
+#include <map>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+#include "../Ref.hpp"
+#include "../Result.hpp"
+#include "../always_false.hpp"
+
+namespace rfl {
+namespace yaml {
+
+class Writer {
+ public:
+  struct YAMLArray {};
+
+  struct YAMLObject {};
+
+  struct YAMLVar {};
+
+  using OutputArrayType = YAMLArray;
+  using OutputObjectType = YAMLObject;
+  using OutputVarType = YAMLVar;
+
+  Writer(const Ref<YAML::Emitter>& _out) : out_(_out) {}
+
+  ~Writer() = default;
+
+  OutputArrayType array_as_root(const size_t _size) const noexcept {
+    return new_array();
+  }
+
+  OutputObjectType object_as_root(const size_t _size) const noexcept {
+    return new_object();
+  }
+
+  OutputVarType null_as_root() const noexcept {
+    return insert_value(YAML::Null);
+  }
+
+  template <class T>
+  OutputVarType value_as_root(const T& _var) const noexcept {
+    return insert_value(_var);
+  }
+
+  OutputArrayType add_array_to_array(const size_t _size,
+                                     OutputArrayType* _parent) const noexcept {
+    return new_array();
+  }
+
+  OutputArrayType add_array_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    return new_array(_name);
+  }
+
+  OutputObjectType add_object_to_array(
+      const size_t _size, OutputArrayType* _parent) const noexcept {
+    return new_object();
+  }
+
+  OutputObjectType add_object_to_object(
+      const std::string_view& _name, const size_t _size,
+      OutputObjectType* _parent) const noexcept {
+    return new_object(_name);
+  }
+
+  template <class T>
+  OutputVarType add_value_to_array(const T& _var,
+                                   OutputArrayType* _parent) const noexcept {
+    return insert_value(_var);
+  }
+
+  template <class T>
+  OutputVarType add_value_to_object(const std::string_view& _name,
+                                    const T& _var,
+                                    OutputObjectType* _parent) const noexcept {
+    return insert_value(_name, _var);
+  }
+
+  OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept {
+    return insert_value(YAML::Null);
+  }
+
+  OutputVarType add_null_to_object(const std::string_view& _name,
+                                   OutputObjectType* _parent) const noexcept {
+    return insert_value(_name, YAML::Null);
+  }
+
+  void end_array(OutputArrayType* _arr) const noexcept {
+    (*out_) << YAML::EndSeq;
+  }
+
+  void end_object(OutputObjectType* _obj) const noexcept {
+    (*out_) << YAML::EndMap;
+  }
+
+ private:
+  template <class T>
+  OutputVarType insert_value(const std::string_view& _name,
+                             const T& _var) const noexcept {
+    (*out_) << YAML::Key << _name.data() << YAML::Value << _var;
+    return OutputVarType{};
+  }
+
+  template <class T>
+  OutputVarType insert_value(const T& _var) const noexcept {
+    (*out_) << _var;
+    return OutputVarType{};
+  }
+
+  OutputArrayType new_array(const std::string_view& _name) const noexcept {
+    (*out_) << YAML::Key << _name.data() << YAML::Value << YAML::BeginSeq;
+    return OutputArrayType{};
+  }
+
+  OutputArrayType new_array() const noexcept {
+    (*out_) << YAML::BeginSeq;
+    return OutputArrayType{};
+  }
+
+  OutputObjectType new_object(const std::string_view& _name) const noexcept {
+    (*out_) << YAML::Key << _name.data() << YAML::Value << YAML::BeginMap;
+    return OutputObjectType{};
+  }
+
+  OutputObjectType new_object() const noexcept {
+    (*out_) << YAML::BeginMap;
+    return OutputObjectType{};
+  }
+
+ public:
+  const Ref<YAML::Emitter> out_;
+};
+
+}  // namespace yaml
+}  // namespace rfl
+
+#endif  // JSON_PARSER_HPP_
diff --git a/include/rfl/yaml/load.hpp b/include/rfl/yaml/load.hpp
new file mode 100644
index 0000000..7f3fa92
--- /dev/null
+++ b/include/rfl/yaml/load.hpp
@@ -0,0 +1,22 @@
+#ifndef RFL_YAML_LOAD_HPP_
+#define RFL_YAML_LOAD_HPP_
+
+#include "../Result.hpp"
+#include "../io/load_string.hpp"
+#include "read.hpp"
+
+namespace rfl {
+namespace yaml {
+
+template <class T, class... Ps>
+Result<T> load(const std::string& _fname) {
+  const auto read_string = [](const auto& _str) {
+    return read<T, Ps...>(_str);
+  };
+  return rfl::io::load_string(_fname).and_then(read_string);
+}
+
+}  // namespace yaml
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/yaml/read.hpp b/include/rfl/yaml/read.hpp
new file mode 100644
index 0000000..0d00eb6
--- /dev/null
+++ b/include/rfl/yaml/read.hpp
@@ -0,0 +1,47 @@
+#ifndef RFL_YAML_READ_HPP_
+#define RFL_YAML_READ_HPP_
+
+#include <yaml-cpp/yaml.h>
+
+#include <istream>
+#include <string>
+
+#include "../Processors.hpp"
+#include "../internal/wrap_in_rfl_array_t.hpp"
+#include "Parser.hpp"
+#include "Reader.hpp"
+namespace rfl {
+namespace yaml {
+
+using InputVarType = typename Reader::InputVarType;
+
+/// Parses an object from a YAML var.
+template <class T, class... Ps>
+auto read(const InputVarType& _var) {
+  const auto r = Reader();
+  return Parser<T, Processors<Ps...>>::read(r, _var);
+}
+
+/// Parses an object from YAML using reflection.
+template <class T, class... Ps>
+Result<internal::wrap_in_rfl_array_t<T>> read(const std::string& _yaml_str) {
+  try {
+    const auto var = InputVarType(YAML::Load(_yaml_str));
+    return read<T, Ps...>(var);
+  } catch (std::exception& e) {
+    return Error(e.what());
+  }
+}
+
+/// Parses an object from a stringstream.
+template <class T, class... Ps>
+auto read(std::istream& _stream) {
+  const auto yaml_str = std::string(std::istreambuf_iterator<char>(_stream),
+                                    std::istreambuf_iterator<char>());
+  return read<T, Ps...>(yaml_str);
+}
+
+}  // namespace yaml
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/yaml/save.hpp b/include/rfl/yaml/save.hpp
new file mode 100644
index 0000000..6333c99
--- /dev/null
+++ b/include/rfl/yaml/save.hpp
@@ -0,0 +1,27 @@
+#ifndef RFL_YAML_SAVE_HPP_
+#define RFL_YAML_SAVE_HPP_
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#include "../Processors.hpp"
+#include "../Result.hpp"
+#include "../io/save_string.hpp"
+#include "write.hpp"
+
+namespace rfl {
+namespace yaml {
+
+template <class... Ps>
+Result<Nothing> save(const std::string& _fname, const auto& _obj) {
+  const auto write_func = [](const auto& _obj, auto& _stream) -> auto& {
+    return write<Ps...>(_obj, _stream);
+  };
+  return rfl::io::save_string(_fname, _obj, write_func);
+}
+
+}  // namespace yaml
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/yaml/write.hpp b/include/rfl/yaml/write.hpp
new file mode 100644
index 0000000..f6613ce
--- /dev/null
+++ b/include/rfl/yaml/write.hpp
@@ -0,0 +1,44 @@
+#ifndef RFL_YAML_WRITE_HPP_
+#define RFL_YAML_WRITE_HPP_
+
+#include <yaml-cpp/yaml.h>
+
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+#include "../Processors.hpp"
+#include "../parsing/Parent.hpp"
+#include "Parser.hpp"
+
+namespace rfl {
+namespace yaml {
+
+/// Writes a YAML into an ostream.
+template <class... Ps>
+std::ostream& write(const auto& _obj, std::ostream& _stream) {
+  using T = std::remove_cvref_t<decltype(_obj)>;
+  using ParentType = parsing::Parent<Writer>;
+  const auto out = Ref<YAML::Emitter>::make();
+  auto w = Writer(out);
+  Parser<T, Processors<Ps...>>::write(w, _obj, typename ParentType::Root{});
+  _stream << out->c_str();
+  return _stream;
+}
+
+/// Returns a YAML string.
+template <class... Ps>
+std::string write(const auto& _obj) {
+  using T = std::remove_cvref_t<decltype(_obj)>;
+  using ParentType = parsing::Parent<Writer>;
+  const auto out = Ref<YAML::Emitter>::make();
+  auto w = Writer(out);
+  Parser<T, Processors<Ps...>>::write(w, _obj, typename ParentType::Root{});
+  return out->c_str();
+}
+
+}  // namespace yaml
+}  // namespace rfl
+
+#endif
diff --git a/include/yyjson.h b/include/yyjson.h
new file mode 100644
index 0000000..7b3a5b7
--- /dev/null
+++ b/include/yyjson.h
@@ -0,0 +1,7690 @@
+/*==============================================================================
+ * Created by Yaoyuan on 2019/3/9.
+ * Copyright (C) 2019 Yaoyuan <ibireme@gmail.com>.
+ *
+ * Released under the MIT License:
+ * https://github.com/ibireme/yyjson/blob/master/LICENSE
+ *============================================================================*/
+
+/** @file yyjson.h */
+
+#ifndef YYJSON_H
+#define YYJSON_H
+
+
+
+/*==============================================================================
+ * Header Files
+ *============================================================================*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <limits.h>
+#include <string.h>
+#include <float.h>
+
+
+
+/*==============================================================================
+ * Compile-time Options
+ *============================================================================*/
+
+/*
+ Define as 1 to disable JSON reader if JSON parsing is not required.
+ 
+ This will disable these functions at compile-time:
+    - yyjson_read_opts()
+    - yyjson_read_file()
+    - yyjson_read()
+    - yyjson_read_number()
+    - yyjson_mut_read_number()
+ 
+ This will reduce the binary size by about 60%.
+ */
+#ifndef YYJSON_DISABLE_READER
+#endif
+
+/*
+ Define as 1 to disable JSON writer if JSON serialization is not required.
+ 
+ This will disable these functions at compile-time:
+    - yyjson_write()
+    - yyjson_write_file()
+    - yyjson_write_opts()
+    - yyjson_val_write()
+    - yyjson_val_write_file()
+    - yyjson_val_write_opts()
+    - yyjson_mut_write()
+    - yyjson_mut_write_file()
+    - yyjson_mut_write_opts()
+    - yyjson_mut_val_write()
+    - yyjson_mut_val_write_file()
+    - yyjson_mut_val_write_opts()
+ 
+ This will reduce the binary size by about 30%.
+ */
+#ifndef YYJSON_DISABLE_WRITER
+#endif
+
+/*
+ Define as 1 to disable JSON Pointer, JSON Patch and JSON Merge Patch supports.
+ 
+ This will disable these functions at compile-time:
+    - yyjson_ptr_xxx()
+    - yyjson_mut_ptr_xxx()
+    - yyjson_doc_ptr_xxx()
+    - yyjson_mut_doc_ptr_xxx()
+    - yyjson_patch()
+    - yyjson_mut_patch()
+    - yyjson_merge_patch()
+    - yyjson_mut_merge_patch()
+ */
+#ifndef YYJSON_DISABLE_UTILS
+#endif
+
+/*
+ Define as 1 to disable the fast floating-point number conversion in yyjson,
+ and use libc's `strtod/snprintf` instead.
+ 
+ This will reduce the binary size by about 30%, but significantly slow down the
+ floating-point read/write speed.
+ */
+#ifndef YYJSON_DISABLE_FAST_FP_CONV
+#endif
+
+/*
+ Define as 1 to disable non-standard JSON support at compile-time:
+    - Reading and writing inf/nan literal, such as `NaN`, `-Infinity`.
+    - Single line and multiple line comments.
+    - Single trailing comma at the end of an object or array.
+    - Invalid unicode in string value.
+ 
+ This will also invalidate these run-time options:
+    - YYJSON_READ_ALLOW_INF_AND_NAN
+    - YYJSON_READ_ALLOW_COMMENTS
+    - YYJSON_READ_ALLOW_TRAILING_COMMAS
+    - YYJSON_READ_ALLOW_INVALID_UNICODE
+    - YYJSON_WRITE_ALLOW_INF_AND_NAN
+    - YYJSON_WRITE_ALLOW_INVALID_UNICODE
+ 
+ This will reduce the binary size by about 10%, and slightly improve the JSON
+ read/write speed.
+ */
+#ifndef YYJSON_DISABLE_NON_STANDARD
+#endif
+
+/*
+ Define as 1 to disable unaligned memory access if target architecture does not
+ support unaligned memory access (such as some embedded processors).
+ 
+ If this value is not defined, yyjson will perform some automatic detection.
+ The wrong definition of this option may cause some performance degradation,
+ but will not cause any run-time errors.
+ */
+#ifndef YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS
+#endif
+
+/* Define as 1 to export symbols when building this library as Windows DLL. */
+#ifndef YYJSON_EXPORTS
+#endif
+
+/* Define as 1 to import symbols when using this library as Windows DLL. */
+#ifndef YYJSON_IMPORTS
+#endif
+
+/* Define as 1 to include <stdint.h> for compiler which doesn't support C99. */
+#ifndef YYJSON_HAS_STDINT_H
+#endif
+
+/* Define as 1 to include <stdbool.h> for compiler which doesn't support C99. */
+#ifndef YYJSON_HAS_STDBOOL_H
+#endif
+
+
+
+/*==============================================================================
+ * Compiler Macros
+ *============================================================================*/
+
+/** compiler version (MSVC) */
+#ifdef _MSC_VER
+#   define YYJSON_MSC_VER _MSC_VER
+#else
+#   define YYJSON_MSC_VER 0
+#endif
+
+/** compiler version (GCC) */
+#ifdef __GNUC__
+#   define YYJSON_GCC_VER __GNUC__
+#else
+#   define YYJSON_GCC_VER 0
+#endif
+
+/** C version (STDC) */
+#if defined(__STDC__) && (__STDC__ >= 1) && defined(__STDC_VERSION__)
+#   define YYJSON_STDC_VER __STDC_VERSION__
+#else
+#   define YYJSON_STDC_VER 0
+#endif
+
+/** C++ version */
+#if defined(__cplusplus)
+#   define YYJSON_CPP_VER __cplusplus
+#else
+#   define YYJSON_CPP_VER 0
+#endif
+
+/** compiler builtin check (since gcc 10.0, clang 2.6, icc 2021) */
+#ifndef yyjson_has_builtin
+#   ifdef __has_builtin
+#       define yyjson_has_builtin(x) __has_builtin(x)
+#   else
+#       define yyjson_has_builtin(x) 0
+#   endif
+#endif
+
+/** compiler attribute check (since gcc 5.0, clang 2.9, icc 17) */
+#ifndef yyjson_has_attribute
+#   ifdef __has_attribute
+#       define yyjson_has_attribute(x) __has_attribute(x)
+#   else
+#       define yyjson_has_attribute(x) 0
+#   endif
+#endif
+
+/** compiler feature check (since clang 2.6, icc 17) */
+#ifndef yyjson_has_feature
+#   ifdef __has_feature
+#       define yyjson_has_feature(x) __has_feature(x)
+#   else
+#       define yyjson_has_feature(x) 0
+#   endif
+#endif
+
+/** include check (since gcc 5.0, clang 2.7, icc 16, msvc 2017 15.3) */
+#ifndef yyjson_has_include
+#   ifdef __has_include
+#       define yyjson_has_include(x) __has_include(x)
+#   else
+#       define yyjson_has_include(x) 0
+#   endif
+#endif
+
+/** inline for compiler */
+#ifndef yyjson_inline
+#   if YYJSON_MSC_VER >= 1200
+#       define yyjson_inline __forceinline
+#   elif defined(_MSC_VER)
+#       define yyjson_inline __inline
+#   elif yyjson_has_attribute(always_inline) || YYJSON_GCC_VER >= 4
+#       define yyjson_inline __inline__ __attribute__((always_inline))
+#   elif defined(__clang__) || defined(__GNUC__)
+#       define yyjson_inline __inline__
+#   elif defined(__cplusplus) || YYJSON_STDC_VER >= 199901L
+#       define yyjson_inline inline
+#   else
+#       define yyjson_inline
+#   endif
+#endif
+
+/** noinline for compiler */
+#ifndef yyjson_noinline
+#   if YYJSON_MSC_VER >= 1400
+#       define yyjson_noinline __declspec(noinline)
+#   elif yyjson_has_attribute(noinline) || YYJSON_GCC_VER >= 4
+#       define yyjson_noinline __attribute__((noinline))
+#   else
+#       define yyjson_noinline
+#   endif
+#endif
+
+/** align for compiler */
+#ifndef yyjson_align
+#   if YYJSON_MSC_VER >= 1300
+#       define yyjson_align(x) __declspec(align(x))
+#   elif yyjson_has_attribute(aligned) || defined(__GNUC__)
+#       define yyjson_align(x) __attribute__((aligned(x)))
+#   elif YYJSON_CPP_VER >= 201103L
+#       define yyjson_align(x) alignas(x)
+#   else
+#       define yyjson_align(x)
+#   endif
+#endif
+
+/** likely for compiler */
+#ifndef yyjson_likely
+#   if yyjson_has_builtin(__builtin_expect) || \
+    (YYJSON_GCC_VER >= 4 && YYJSON_GCC_VER != 5)
+#       define yyjson_likely(expr) __builtin_expect(!!(expr), 1)
+#   else
+#       define yyjson_likely(expr) (expr)
+#   endif
+#endif
+
+/** unlikely for compiler */
+#ifndef yyjson_unlikely
+#   if yyjson_has_builtin(__builtin_expect) || \
+    (YYJSON_GCC_VER >= 4 && YYJSON_GCC_VER != 5)
+#       define yyjson_unlikely(expr) __builtin_expect(!!(expr), 0)
+#   else
+#       define yyjson_unlikely(expr) (expr)
+#   endif
+#endif
+
+/** deprecate warning */
+#ifndef yyjson_deprecated
+#   if YYJSON_MSC_VER >= 1400
+#       define yyjson_deprecated(msg) __declspec(deprecated(msg))
+#   elif yyjson_has_feature(attribute_deprecated_with_message) || \
+        (YYJSON_GCC_VER > 4 || (YYJSON_GCC_VER == 4 && __GNUC_MINOR__ >= 5))
+#       define yyjson_deprecated(msg) __attribute__((deprecated(msg)))
+#   elif YYJSON_GCC_VER >= 3
+#       define yyjson_deprecated(msg) __attribute__((deprecated))
+#   else
+#       define yyjson_deprecated(msg)
+#   endif
+#endif
+
+/** function export */
+#ifndef yyjson_api
+#   if defined(_WIN32)
+#       if defined(YYJSON_EXPORTS) && YYJSON_EXPORTS
+#           define yyjson_api __declspec(dllexport)
+#       elif defined(YYJSON_IMPORTS) && YYJSON_IMPORTS
+#           define yyjson_api __declspec(dllimport)
+#       else
+#           define yyjson_api
+#       endif
+#   elif yyjson_has_attribute(visibility) || YYJSON_GCC_VER >= 4
+#       define yyjson_api __attribute__((visibility("default")))
+#   else
+#       define yyjson_api
+#   endif
+#endif
+
+/** inline function export */
+#ifndef yyjson_api_inline
+#   define yyjson_api_inline static yyjson_inline
+#endif
+
+/** stdint (C89 compatible) */
+#if (defined(YYJSON_HAS_STDINT_H) && YYJSON_HAS_STDINT_H) || \
+    YYJSON_MSC_VER >= 1600 || YYJSON_STDC_VER >= 199901L || \
+    defined(_STDINT_H) || defined(_STDINT_H_) || \
+    defined(__CLANG_STDINT_H) || defined(_STDINT_H_INCLUDED) || \
+    yyjson_has_include(<stdint.h>)
+#   include <stdint.h>
+#elif defined(_MSC_VER)
+#   if _MSC_VER < 1300
+        typedef signed char         int8_t;
+        typedef signed short        int16_t;
+        typedef signed int          int32_t;
+        typedef unsigned char       uint8_t;
+        typedef unsigned short      uint16_t;
+        typedef unsigned int        uint32_t;
+        typedef signed __int64      int64_t;
+        typedef unsigned __int64    uint64_t;
+#   else
+        typedef signed __int8       int8_t;
+        typedef signed __int16      int16_t;
+        typedef signed __int32      int32_t;
+        typedef unsigned __int8     uint8_t;
+        typedef unsigned __int16    uint16_t;
+        typedef unsigned __int32    uint32_t;
+        typedef signed __int64      int64_t;
+        typedef unsigned __int64    uint64_t;
+#   endif
+#else
+#   if UCHAR_MAX == 0xFFU
+        typedef signed char     int8_t;
+        typedef unsigned char   uint8_t;
+#   else
+#       error cannot find 8-bit integer type
+#   endif
+#   if USHRT_MAX == 0xFFFFU
+        typedef unsigned short  uint16_t;
+        typedef signed short    int16_t;
+#   elif UINT_MAX == 0xFFFFU
+        typedef unsigned int    uint16_t;
+        typedef signed int      int16_t;
+#   else
+#       error cannot find 16-bit integer type
+#   endif
+#   if UINT_MAX == 0xFFFFFFFFUL
+        typedef unsigned int    uint32_t;
+        typedef signed int      int32_t;
+#   elif ULONG_MAX == 0xFFFFFFFFUL
+        typedef unsigned long   uint32_t;
+        typedef signed long     int32_t;
+#   elif USHRT_MAX == 0xFFFFFFFFUL
+        typedef unsigned short  uint32_t;
+        typedef signed short    int32_t;
+#   else
+#       error cannot find 32-bit integer type
+#   endif
+#   if defined(__INT64_TYPE__) && defined(__UINT64_TYPE__)
+        typedef __INT64_TYPE__  int64_t;
+        typedef __UINT64_TYPE__ uint64_t;
+#   elif defined(__GNUC__) || defined(__clang__)
+#       if !defined(_SYS_TYPES_H) && !defined(__int8_t_defined)
+        __extension__ typedef long long             int64_t;
+#       endif
+        __extension__ typedef unsigned long long    uint64_t;
+#   elif defined(_LONG_LONG) || defined(__MWERKS__) || defined(_CRAYC) || \
+        defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+        typedef long long           int64_t;
+        typedef unsigned long long  uint64_t;
+#   elif (defined(__BORLANDC__) && __BORLANDC__ > 0x460) || \
+        defined(__WATCOM_INT64__) || defined (__alpha) || defined (__DECC)
+        typedef __int64             int64_t;
+        typedef unsigned __int64    uint64_t;
+#   else
+#       error cannot find 64-bit integer type
+#   endif
+#endif
+
+/** stdbool (C89 compatible) */
+#if (defined(YYJSON_HAS_STDBOOL_H) && YYJSON_HAS_STDBOOL_H) || \
+    (yyjson_has_include(<stdbool.h>) && !defined(__STRICT_ANSI__)) || \
+    YYJSON_MSC_VER >= 1800 || YYJSON_STDC_VER >= 199901L
+#   include <stdbool.h>
+#elif !defined(__bool_true_false_are_defined)
+#   define __bool_true_false_are_defined 1
+#   if defined(__cplusplus)
+#       if defined(__GNUC__) && !defined(__STRICT_ANSI__)
+#           define _Bool bool
+#           if __cplusplus < 201103L
+#               define bool bool
+#               define false false
+#               define true true
+#           endif
+#       endif
+#   else
+#       define bool unsigned char
+#       define true 1
+#       define false 0
+#   endif
+#endif
+
+/** char bit check */
+#if defined(CHAR_BIT)
+#   if CHAR_BIT != 8
+#       error non 8-bit char is not supported
+#   endif
+#endif
+
+/**
+ Microsoft Visual C++ 6.0 doesn't support converting number from u64 to f64:
+ error C2520: conversion from unsigned __int64 to double not implemented.
+ */
+#ifndef YYJSON_U64_TO_F64_NO_IMPL
+#   if (0 < YYJSON_MSC_VER) && (YYJSON_MSC_VER <= 1200)
+#       define YYJSON_U64_TO_F64_NO_IMPL 1
+#   else
+#       define YYJSON_U64_TO_F64_NO_IMPL 0
+#   endif
+#endif
+
+
+
+/*==============================================================================
+ * Compile Hint Begin
+ *============================================================================*/
+
+/* extern "C" begin */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* warning suppress begin */
+#if defined(__clang__)
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wunused-function"
+#   pragma clang diagnostic ignored "-Wunused-parameter"
+#elif defined(__GNUC__)
+#   if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#   pragma GCC diagnostic push
+#   endif
+#   pragma GCC diagnostic ignored "-Wunused-function"
+#   pragma GCC diagnostic ignored "-Wunused-parameter"
+#elif defined(_MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable:4800) /* 'int': forcing value to 'true' or 'false' */
+#endif
+
+
+
+/*==============================================================================
+ * Version
+ *============================================================================*/
+
+/** The major version of yyjson. */
+#define YYJSON_VERSION_MAJOR  0
+
+/** The minor version of yyjson. */
+#define YYJSON_VERSION_MINOR  7
+
+/** The patch version of yyjson. */
+#define YYJSON_VERSION_PATCH  0
+
+/** The version of yyjson in hex: `(major << 16) | (minor << 8) | (patch)`. */
+#define YYJSON_VERSION_HEX    0x000700
+
+/** The version string of yyjson. */
+#define YYJSON_VERSION_STRING "0.7.0"
+
+/** The version of yyjson in hex, same as `YYJSON_VERSION_HEX`. */
+yyjson_api uint32_t yyjson_version(void);
+
+
+
+/*==============================================================================
+ * JSON Types
+ *============================================================================*/
+
+/** Type of JSON value (3 bit). */
+typedef uint8_t yyjson_type;
+#define YYJSON_TYPE_NONE        ((uint8_t)0)        /* _____000 */
+#define YYJSON_TYPE_RAW         ((uint8_t)1)        /* _____001 */
+#define YYJSON_TYPE_NULL        ((uint8_t)2)        /* _____010 */
+#define YYJSON_TYPE_BOOL        ((uint8_t)3)        /* _____011 */
+#define YYJSON_TYPE_NUM         ((uint8_t)4)        /* _____100 */
+#define YYJSON_TYPE_STR         ((uint8_t)5)        /* _____101 */
+#define YYJSON_TYPE_ARR         ((uint8_t)6)        /* _____110 */
+#define YYJSON_TYPE_OBJ         ((uint8_t)7)        /* _____111 */
+
+/** Subtype of JSON value (2 bit). */
+typedef uint8_t yyjson_subtype;
+#define YYJSON_SUBTYPE_NONE     ((uint8_t)(0 << 3)) /* ___00___ */
+#define YYJSON_SUBTYPE_FALSE    ((uint8_t)(0 << 3)) /* ___00___ */
+#define YYJSON_SUBTYPE_TRUE     ((uint8_t)(1 << 3)) /* ___01___ */
+#define YYJSON_SUBTYPE_UINT     ((uint8_t)(0 << 3)) /* ___00___ */
+#define YYJSON_SUBTYPE_SINT     ((uint8_t)(1 << 3)) /* ___01___ */
+#define YYJSON_SUBTYPE_REAL     ((uint8_t)(2 << 3)) /* ___10___ */
+
+/** Mask and bits of JSON value tag. */
+#define YYJSON_TYPE_MASK        ((uint8_t)0x07)     /* _____111 */
+#define YYJSON_TYPE_BIT         ((uint8_t)3)
+#define YYJSON_SUBTYPE_MASK     ((uint8_t)0x18)     /* ___11___ */
+#define YYJSON_SUBTYPE_BIT      ((uint8_t)2)
+#define YYJSON_RESERVED_MASK    ((uint8_t)0xE0)     /* 111_____ */
+#define YYJSON_RESERVED_BIT     ((uint8_t)3)
+#define YYJSON_TAG_MASK         ((uint8_t)0xFF)     /* 11111111 */
+#define YYJSON_TAG_BIT          ((uint8_t)8)
+
+/** Padding size for JSON reader. */
+#define YYJSON_PADDING_SIZE     4
+
+
+
+/*==============================================================================
+ * Allocator
+ *============================================================================*/
+
+/**
+ A memory allocator.
+ 
+ Typically you don't need to use it, unless you want to customize your own
+ memory allocator.
+ */
+typedef struct yyjson_alc {
+    /** Same as libc's malloc(size), should not be NULL. */
+    void *(*malloc)(void *ctx, size_t size);
+    /** Same as libc's realloc(ptr, size), should not be NULL. */
+    void *(*realloc)(void *ctx, void *ptr, size_t old_size, size_t size);
+    /** Same as libc's free(ptr), should not be NULL. */
+    void (*free)(void *ctx, void *ptr);
+    /** A context for malloc/realloc/free, can be NULL. */
+    void *ctx;
+} yyjson_alc;
+
+/**
+ A pool allocator uses fixed length pre-allocated memory.
+ 
+ This allocator may be used to avoid malloc/realloc calls. The pre-allocated 
+ memory should be held by the caller. The maximum amount of memory required to
+ read a JSON can be calculated using the `yyjson_read_max_memory_usage()`
+ function, but the amount of memory required to write a JSON cannot be directly 
+ calculated.
+ 
+ This is not a general-purpose allocator. If used to read multiple JSON 
+ documents and only some of them are released, it may cause memory
+ fragmentation, leading to performance degradation and memory waste. Therefore, 
+ it is recommended to use this allocator only for reading or writing a single 
+ JSON document.
+ 
+ @param alc The allocator to be initialized.
+    If this parameter is NULL, the function will fail and return false.
+    If `buf` or `size` is invalid, this will be set to an empty allocator.
+ @param buf The buffer memory for this allocator.
+    If this parameter is NULL, the function will fail and return false.
+ @param size The size of `buf`, in bytes.
+    If this parameter is less than 8 words (32/64 bytes on 32/64-bit OS), the
+    function will fail and return false.
+ @return true if the `alc` has been successfully initialized.
+ 
+ @par Example
+ @code
+    // parse JSON with stack memory
+    char buf[1024];
+    yyjson_alc alc;
+    yyjson_alc_pool_init(&alc, buf, 1024);
+    
+    const char *json = "{\"name\":\"Helvetica\",\"size\":16}"
+    yyjson_doc *doc = yyjson_read_opts(json, strlen(json), 0, &alc, NULL);
+    // the memory of `doc` is on the stack
+ @endcode
+ */
+yyjson_api bool yyjson_alc_pool_init(yyjson_alc *alc, void *buf, size_t size);
+
+
+
+/*==============================================================================
+ * JSON Structure
+ *============================================================================*/
+
+/**
+ An immutable document for reading JSON.
+ This document holds memory for all its JSON values and strings. When it is no
+ longer used, the user should call `yyjson_doc_free()` to free its memory.
+ */
+typedef struct yyjson_doc yyjson_doc;
+
+/**
+ An immutable value for reading JSON.
+ A JSON Value has the same lifetime as its document. The memory is held by its
+ document and and cannot be freed alone.
+ */
+typedef struct yyjson_val yyjson_val;
+
+/**
+ A mutable document for building JSON.
+ This document holds memory for all its JSON values and strings. When it is no
+ longer used, the user should call `yyjson_mut_doc_free()` to free its memory.
+ */
+typedef struct yyjson_mut_doc yyjson_mut_doc;
+
+/**
+ A mutable value for building JSON.
+ A JSON Value has the same lifetime as its document. The memory is held by its
+ document and and cannot be freed alone.
+ */
+typedef struct yyjson_mut_val yyjson_mut_val;
+
+
+
+/*==============================================================================
+ * JSON Reader API
+ *============================================================================*/
+
+/** Run-time options for JSON reader. */
+typedef uint32_t yyjson_read_flag;
+
+/** Default option (RFC 8259 compliant):
+    - Read positive integer as uint64_t.
+    - Read negative integer as int64_t.
+    - Read floating-point number as double with round-to-nearest mode.
+    - Read integer which cannot fit in uint64_t or int64_t as double.
+    - Report error if double number is infinity.
+    - Report error if string contains invalid UTF-8 character or BOM.
+    - Report error on trailing commas, comments, inf and nan literals. */
+static const yyjson_read_flag YYJSON_READ_NOFLAG                = 0 << 0;
+
+/** Read the input data in-situ.
+    This option allows the reader to modify and use input data to store string
+    values, which can increase reading speed slightly.
+    The caller should hold the input data before free the document.
+    The input data must be padded by at least `YYJSON_PADDING_SIZE` bytes.
+    For example: `[1,2]` should be `[1,2]\0\0\0\0`, input length should be 5. */
+static const yyjson_read_flag YYJSON_READ_INSITU                = 1 << 0;
+
+/** Stop when done instead of issuing an error if there's additional content
+    after a JSON document. This option may be used to parse small pieces of JSON
+    in larger data, such as `NDJSON`. */
+static const yyjson_read_flag YYJSON_READ_STOP_WHEN_DONE        = 1 << 1;
+
+/** Allow single trailing comma at the end of an object or array,
+    such as `[1,2,3,]`, `{"a":1,"b":2,}` (non-standard). */
+static const yyjson_read_flag YYJSON_READ_ALLOW_TRAILING_COMMAS = 1 << 2;
+
+/** Allow C-style single line and multiple line comments (non-standard). */
+static const yyjson_read_flag YYJSON_READ_ALLOW_COMMENTS        = 1 << 3;
+
+/** Allow inf/nan number and literal, case-insensitive,
+    such as 1e999, NaN, inf, -Infinity (non-standard). */
+static const yyjson_read_flag YYJSON_READ_ALLOW_INF_AND_NAN     = 1 << 4;
+
+/** Read all numbers as raw strings (value with `YYJSON_TYPE_RAW` type),
+    inf/nan literal is also read as raw with `ALLOW_INF_AND_NAN` flag. */
+static const yyjson_read_flag YYJSON_READ_NUMBER_AS_RAW         = 1 << 5;
+
+/** Allow reading invalid unicode when parsing string values (non-standard).
+    Invalid characters will be allowed to appear in the string values, but
+    invalid escape sequences will still be reported as errors.
+    This flag does not affect the performance of correctly encoded strings.
+    
+    @warning Strings in JSON values may contain incorrect encoding when this
+    option is used, you need to handle these strings carefully to avoid security
+    risks. */
+static const yyjson_read_flag YYJSON_READ_ALLOW_INVALID_UNICODE = 1 << 6;
+
+/** Read big numbers as raw strings. These big numbers include integers that
+    cannot be represented by `int64_t` and `uint64_t`, and floating-point
+    numbers that cannot be represented by finite `double`.
+    The flag will be overridden by `YYJSON_READ_NUMBER_AS_RAW` flag. */
+static const yyjson_read_flag YYJSON_READ_BIGNUM_AS_RAW         = 1 << 7;
+
+
+
+/** Result code for JSON reader. */
+typedef uint32_t yyjson_read_code;
+
+/** Success, no error. */
+static const yyjson_read_code YYJSON_READ_SUCCESS                       = 0;
+
+/** Invalid parameter, such as NULL input string or 0 input length. */
+static const yyjson_read_code YYJSON_READ_ERROR_INVALID_PARAMETER       = 1;
+
+/** Memory allocation failure occurs. */
+static const yyjson_read_code YYJSON_READ_ERROR_MEMORY_ALLOCATION       = 2;
+
+/** Input JSON string is empty. */
+static const yyjson_read_code YYJSON_READ_ERROR_EMPTY_CONTENT           = 3;
+
+/** Unexpected content after document, such as `[123]abc`. */
+static const yyjson_read_code YYJSON_READ_ERROR_UNEXPECTED_CONTENT      = 4;
+
+/** Unexpected ending, such as `[123`. */
+static const yyjson_read_code YYJSON_READ_ERROR_UNEXPECTED_END          = 5;
+
+/** Unexpected character inside the document, such as `[abc]`. */
+static const yyjson_read_code YYJSON_READ_ERROR_UNEXPECTED_CHARACTER    = 6;
+
+/** Invalid JSON structure, such as `[1,]`. */
+static const yyjson_read_code YYJSON_READ_ERROR_JSON_STRUCTURE          = 7;
+
+/** Invalid comment, such as unclosed multi-line comment. */
+static const yyjson_read_code YYJSON_READ_ERROR_INVALID_COMMENT         = 8;
+
+/** Invalid number, such as `123.e12`, `000`. */
+static const yyjson_read_code YYJSON_READ_ERROR_INVALID_NUMBER          = 9;
+
+/** Invalid string, such as invalid escaped character inside a string. */
+static const yyjson_read_code YYJSON_READ_ERROR_INVALID_STRING          = 10;
+
+/** Invalid JSON literal, such as `truu`. */
+static const yyjson_read_code YYJSON_READ_ERROR_LITERAL                 = 11;
+
+/** Failed to open a file. */
+static const yyjson_read_code YYJSON_READ_ERROR_FILE_OPEN               = 12;
+
+/** Failed to read a file. */
+static const yyjson_read_code YYJSON_READ_ERROR_FILE_READ               = 13;
+
+/** Error information for JSON reader. */
+typedef struct yyjson_read_err {
+    /** Error code, see `yyjson_read_code` for all possible values. */
+    yyjson_read_code code;
+    /** Error message, constant, no need to free (NULL if success). */
+    const char *msg;
+    /** Error byte position for input data (0 if success). */
+    size_t pos;
+} yyjson_read_err;
+
+
+
+/**
+ Read JSON with options.
+ 
+ This function is thread-safe when:
+ 1. The `dat` is not modified by other threads.
+ 2. The `alc` is thread-safe or NULL.
+ 
+ @param dat The JSON data (UTF-8 without BOM), null-terminator is not required.
+    If this parameter is NULL, the function will fail and return NULL.
+    The `dat` will not be modified without the flag `YYJSON_READ_INSITU`, so you
+    can pass a `const char *` string and case it to `char *` if you don't use
+    the `YYJSON_READ_INSITU` flag.
+ @param len The length of JSON data in bytes.
+    If this parameter is 0, the function will fail and return NULL.
+ @param flg The JSON read options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON reader.
+    Pass NULL to use the libc's default allocator.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return A new JSON document, or NULL if an error occurs.
+    When it's no longer needed, it should be freed with `yyjson_doc_free()`.
+ */
+yyjson_api yyjson_doc *yyjson_read_opts(char *dat,
+                                        size_t len,
+                                        yyjson_read_flag flg,
+                                        const yyjson_alc *alc,
+                                        yyjson_read_err *err);
+
+/**
+ Read a JSON file.
+ 
+ This function is thread-safe when:
+ 1. The file is not modified by other threads.
+ 2. The `alc` is thread-safe or NULL.
+ 
+ @param path The JSON file's path.
+    If this path is NULL or invalid, the function will fail and return NULL.
+ @param flg The JSON read options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON reader.
+    Pass NULL to use the libc's default allocator.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return A new JSON document, or NULL if an error occurs.
+    When it's no longer needed, it should be freed with `yyjson_doc_free()`.
+ 
+ @warning On 32-bit operating system, files larger than 2GB may fail to read.
+ */
+yyjson_api yyjson_doc *yyjson_read_file(const char *path,
+                                        yyjson_read_flag flg,
+                                        const yyjson_alc *alc,
+                                        yyjson_read_err *err);
+
+/**
+ Read JSON from a file pointer.
+ 
+ @param fp The file pointer.
+    The data will be read from the current position of the FILE to the end.
+    If this fp is NULL or invalid, the function will fail and return NULL.
+ @param flg The JSON read options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON reader.
+    Pass NULL to use the libc's default allocator.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return A new JSON document, or NULL if an error occurs.
+    When it's no longer needed, it should be freed with `yyjson_doc_free()`.
+ 
+ @warning On 32-bit operating system, files larger than 2GB may fail to read.
+ */
+yyjson_api yyjson_doc *yyjson_read_fp(FILE *fp,
+                                      yyjson_read_flag flg,
+                                      const yyjson_alc *alc,
+                                      yyjson_read_err *err);
+
+/**
+ Read a JSON string.
+ 
+ This function is thread-safe.
+ 
+ @param dat The JSON data (UTF-8 without BOM), null-terminator is not required.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param len The length of JSON data in bytes.
+    If this parameter is 0, the function will fail and return NULL.
+ @param flg The JSON read options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @return A new JSON document, or NULL if an error occurs.
+    When it's no longer needed, it should be freed with `yyjson_doc_free()`.
+ */
+yyjson_api_inline yyjson_doc *yyjson_read(const char *dat,
+                                          size_t len,
+                                          yyjson_read_flag flg) {
+    flg &= ~YYJSON_READ_INSITU; /* const string cannot be modified */
+    return yyjson_read_opts((char *)(void *)(size_t)(const void *)dat,
+                            len, flg, NULL, NULL);
+}
+
+/**
+ Returns the size of maximum memory usage to read a JSON data.
+ 
+ You may use this value to avoid malloc() or calloc() call inside the reader
+ to get better performance, or read multiple JSON with one piece of memory.
+ 
+ @param len The length of JSON data in bytes.
+ @param flg The JSON read options.
+ @return The maximum memory size to read this JSON, or 0 if overflow.
+ 
+ @par Example
+ @code
+    // read multiple JSON with same pre-allocated memory
+    
+    char *dat1, *dat2, *dat3; // JSON data
+    size_t len1, len2, len3; // JSON length
+    size_t max_len = MAX(len1, MAX(len2, len3));
+    yyjson_doc *doc;
+    
+    // use one allocator for multiple JSON
+    size_t size = yyjson_read_max_memory_usage(max_len, 0);
+    void *buf = malloc(size);
+    yyjson_alc alc;
+    yyjson_alc_pool_init(&alc, buf, size);
+    
+    // no more alloc() or realloc() call during reading
+    doc = yyjson_read_opts(dat1, len1, 0, &alc, NULL);
+    yyjson_doc_free(doc);
+    doc = yyjson_read_opts(dat2, len2, 0, &alc, NULL);
+    yyjson_doc_free(doc);
+    doc = yyjson_read_opts(dat3, len3, 0, &alc, NULL);
+    yyjson_doc_free(doc);
+    
+    free(buf);
+ @endcode
+ @see yyjson_alc_pool_init()
+ */
+yyjson_api_inline size_t yyjson_read_max_memory_usage(size_t len,
+                                                      yyjson_read_flag flg) {
+    /*
+     1. The max value count is (json_size / 2 + 1),
+        for example: "[1,2,3,4]" size is 9, value count is 5.
+     2. Some broken JSON may cost more memory during reading, but fail at end,
+        for example: "[[[[[[[[".
+     3. yyjson use 16 bytes per value, see struct yyjson_val.
+     4. yyjson use dynamic memory with a growth factor of 1.5.
+     
+     The max memory size is (json_size / 2 * 16 * 1.5 + padding).
+     */
+    size_t mul = (size_t)12 + !(flg & YYJSON_READ_INSITU);
+    size_t pad = 256;
+    size_t max = (size_t)(~(size_t)0);
+    if (flg & YYJSON_READ_STOP_WHEN_DONE) len = len < 256 ? 256 : len;
+    if (len >= (max - pad - mul) / mul) return 0;
+    return len * mul + pad;
+}
+
+/**
+ Read a JSON number.
+
+ This function is thread-safe when data is not modified by other threads.
+
+ @param dat The JSON data (UTF-8 without BOM), null-terminator is required.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param val The output value where result is stored.
+    If this parameter is NULL, the function will fail and return NULL.
+    The value will hold either UINT or SINT or REAL number;
+ @param flg The JSON read options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+    Supports `YYJSON_READ_NUMBER_AS_RAW` and `YYJSON_READ_ALLOW_INF_AND_NAN`.
+ @param alc The memory allocator used for long number.
+    It is only used when the built-in floating point reader is disabled.
+    Pass NULL to use the libc's default allocator.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return If successful, a pointer to the character after the last character
+    used in the conversion, NULL if an error occurs.
+ */
+yyjson_api const char *yyjson_read_number(const char *dat,
+                                          yyjson_val *val,
+                                          yyjson_read_flag flg,
+                                          const yyjson_alc *alc,
+                                          yyjson_read_err *err);
+
+/**
+ Read a JSON number.
+
+ This function is thread-safe when data is not modified by other threads.
+
+ @param dat The JSON data (UTF-8 without BOM), null-terminator is required.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param val The output value where result is stored.
+    If this parameter is NULL, the function will fail and return NULL.
+    The value will hold either UINT or SINT or REAL number;
+ @param flg The JSON read options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+    Supports `YYJSON_READ_NUMBER_AS_RAW` and `YYJSON_READ_ALLOW_INF_AND_NAN`.
+ @param alc The memory allocator used for long number.
+    It is only used when the built-in floating point reader is disabled.
+    Pass NULL to use the libc's default allocator.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return If successful, a pointer to the character after the last character
+    used in the conversion, NULL if an error occurs.
+ */
+yyjson_api_inline const char *yyjson_mut_read_number(const char *dat,
+                                                     yyjson_mut_val *val,
+                                                     yyjson_read_flag flg,
+                                                     const yyjson_alc *alc,
+                                                     yyjson_read_err *err) {
+    return yyjson_read_number(dat, (yyjson_val *)val, flg, alc, err);
+}
+
+
+/*==============================================================================
+ * JSON Writer API
+ *============================================================================*/
+
+/** Run-time options for JSON writer. */
+typedef uint32_t yyjson_write_flag;
+
+/** Default option:
+    - Write JSON minify.
+    - Report error on inf or nan number.
+    - Report error on invalid UTF-8 string.
+    - Do not escape unicode or slash. */
+static const yyjson_write_flag YYJSON_WRITE_NOFLAG                  = 0 << 0;
+
+/** Write JSON pretty with 4 space indent. */
+static const yyjson_write_flag YYJSON_WRITE_PRETTY                  = 1 << 0;
+
+/** Escape unicode as `uXXXX`, make the output ASCII only. */
+static const yyjson_write_flag YYJSON_WRITE_ESCAPE_UNICODE          = 1 << 1;
+
+/** Escape '/' as '\/'. */
+static const yyjson_write_flag YYJSON_WRITE_ESCAPE_SLASHES          = 1 << 2;
+
+/** Write inf and nan number as 'Infinity' and 'NaN' literal (non-standard). */
+static const yyjson_write_flag YYJSON_WRITE_ALLOW_INF_AND_NAN       = 1 << 3;
+
+/** Write inf and nan number as null literal.
+    This flag will override `YYJSON_WRITE_ALLOW_INF_AND_NAN` flag. */
+static const yyjson_write_flag YYJSON_WRITE_INF_AND_NAN_AS_NULL     = 1 << 4;
+
+/** Allow invalid unicode when encoding string values (non-standard).
+    Invalid characters in string value will be copied byte by byte.
+    If `YYJSON_WRITE_ESCAPE_UNICODE` flag is also set, invalid character will be
+    escaped as `U+FFFD` (replacement character).
+    This flag does not affect the performance of correctly encoded strings. */
+static const yyjson_write_flag YYJSON_WRITE_ALLOW_INVALID_UNICODE   = 1 << 5;
+
+/** Write JSON pretty with 2 space indent.
+    This flag will override `YYJSON_WRITE_PRETTY` flag. */
+static const yyjson_write_flag YYJSON_WRITE_PRETTY_TWO_SPACES       = 1 << 6;
+
+
+
+/** Result code for JSON writer */
+typedef uint32_t yyjson_write_code;
+
+/** Success, no error. */
+static const yyjson_write_code YYJSON_WRITE_SUCCESS                     = 0;
+
+/** Invalid parameter, such as NULL document. */
+static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_PARAMETER     = 1;
+
+/** Memory allocation failure occurs. */
+static const yyjson_write_code YYJSON_WRITE_ERROR_MEMORY_ALLOCATION     = 2;
+
+/** Invalid value type in JSON document. */
+static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_VALUE_TYPE    = 3;
+
+/** NaN or Infinity number occurs. */
+static const yyjson_write_code YYJSON_WRITE_ERROR_NAN_OR_INF            = 4;
+
+/** Failed to open a file. */
+static const yyjson_write_code YYJSON_WRITE_ERROR_FILE_OPEN             = 5;
+
+/** Failed to write a file. */
+static const yyjson_write_code YYJSON_WRITE_ERROR_FILE_WRITE            = 6;
+
+/** Invalid unicode in string. */
+static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_STRING        = 7;
+
+/** Error information for JSON writer. */
+typedef struct yyjson_write_err {
+    /** Error code, see `yyjson_write_code` for all possible values. */
+    yyjson_write_code code;
+    /** Error message, constant, no need to free (NULL if success). */
+    const char *msg;
+} yyjson_write_err;
+
+
+
+/*==============================================================================
+ * JSON Document Writer API
+ *============================================================================*/
+
+/**
+ Write a document to JSON string with options.
+ 
+ This function is thread-safe when:
+ The `alc` is thread-safe or NULL.
+ 
+ @param doc The JSON document.
+    If this doc is NULL or has no root, the function will fail and return false.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON writer.
+    Pass NULL to use the libc's default allocator.
+ @param len A pointer to receive output length in bytes (not including the
+    null-terminator). Pass NULL if you don't need length information.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return A new JSON string, or NULL if an error occurs.
+    This string is encoded as UTF-8 with a null-terminator.
+    When it's no longer needed, it should be freed with free() or alc->free().
+ */
+yyjson_api char *yyjson_write_opts(const yyjson_doc *doc,
+                                   yyjson_write_flag flg,
+                                   const yyjson_alc *alc,
+                                   size_t *len,
+                                   yyjson_write_err *err);
+
+/**
+ Write a document to JSON file with options.
+ 
+ This function is thread-safe when:
+ 1. The file is not accessed by other threads.
+ 2. The `alc` is thread-safe or NULL.
+
+ @param path The JSON file's path.
+    If this path is NULL or invalid, the function will fail and return false.
+    If this file is not empty, the content will be discarded.
+ @param doc The JSON document.
+    If this doc is NULL or has no root, the function will fail and return false.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON writer.
+    Pass NULL to use the libc's default allocator.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return true if successful, false if an error occurs.
+ 
+ @warning On 32-bit operating system, files larger than 2GB may fail to write.
+ */
+yyjson_api bool yyjson_write_file(const char *path,
+                                  const yyjson_doc *doc,
+                                  yyjson_write_flag flg,
+                                  const yyjson_alc *alc,
+                                  yyjson_write_err *err);
+
+/**
+ Write a document to file pointer with options.
+ 
+ @param fp The file pointer.
+    The data will be written to the current position of the file.
+    If this fp is NULL or invalid, the function will fail and return false.
+ @param doc The JSON document.
+    If this doc is NULL or has no root, the function will fail and return false.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON writer.
+    Pass NULL to use the libc's default allocator.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return true if successful, false if an error occurs.
+ 
+ @warning On 32-bit operating system, files larger than 2GB may fail to write.
+ */
+yyjson_api bool yyjson_write_fp(FILE *fp,
+                                const yyjson_doc *doc,
+                                yyjson_write_flag flg,
+                                const yyjson_alc *alc,
+                                yyjson_write_err *err);
+
+/**
+ Write a document to JSON string.
+ 
+ This function is thread-safe.
+ 
+ @param doc The JSON document.
+    If this doc is NULL or has no root, the function will fail and return false.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param len A pointer to receive output length in bytes (not including the
+    null-terminator). Pass NULL if you don't need length information.
+ @return A new JSON string, or NULL if an error occurs.
+    This string is encoded as UTF-8 with a null-terminator.
+    When it's no longer needed, it should be freed with free().
+ */
+yyjson_api_inline char *yyjson_write(const yyjson_doc *doc,
+                                     yyjson_write_flag flg,
+                                     size_t *len) {
+    return yyjson_write_opts(doc, flg, NULL, len, NULL);
+}
+
+
+
+/**
+ Write a document to JSON string with options.
+ 
+ This function is thread-safe when:
+ 1. The `doc` is not modified by other threads.
+ 2. The `alc` is thread-safe or NULL.
+
+ @param doc The mutable JSON document.
+    If this doc is NULL or has no root, the function will fail and return false.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON writer.
+    Pass NULL to use the libc's default allocator.
+ @param len A pointer to receive output length in bytes (not including the
+    null-terminator). Pass NULL if you don't need length information.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return A new JSON string, or NULL if an error occurs.
+    This string is encoded as UTF-8 with a null-terminator.
+    When it's no longer needed, it should be freed with free() or alc->free().
+ */
+yyjson_api char *yyjson_mut_write_opts(const yyjson_mut_doc *doc,
+                                       yyjson_write_flag flg,
+                                       const yyjson_alc *alc,
+                                       size_t *len,
+                                       yyjson_write_err *err);
+
+/**
+ Write a document to JSON file with options.
+ 
+ This function is thread-safe when:
+ 1. The file is not accessed by other threads.
+ 2. The `doc` is not modified by other threads.
+ 3. The `alc` is thread-safe or NULL.
+ 
+ @param path The JSON file's path.
+    If this path is NULL or invalid, the function will fail and return false.
+    If this file is not empty, the content will be discarded.
+ @param doc The mutable JSON document.
+    If this doc is NULL or has no root, the function will fail and return false.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON writer.
+    Pass NULL to use the libc's default allocator.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return true if successful, false if an error occurs.
+ 
+ @warning On 32-bit operating system, files larger than 2GB may fail to write.
+ */
+yyjson_api bool yyjson_mut_write_file(const char *path,
+                                      const yyjson_mut_doc *doc,
+                                      yyjson_write_flag flg,
+                                      const yyjson_alc *alc,
+                                      yyjson_write_err *err);
+
+/**
+ Write a document to file pointer with options.
+ 
+ @param fp The file pointer.
+    The data will be written to the current position of the file.
+    If this fp is NULL or invalid, the function will fail and return false.
+ @param doc The mutable JSON document.
+    If this doc is NULL or has no root, the function will fail and return false.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON writer.
+    Pass NULL to use the libc's default allocator.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return true if successful, false if an error occurs.
+ 
+ @warning On 32-bit operating system, files larger than 2GB may fail to write.
+ */
+yyjson_api bool yyjson_mut_write_fp(FILE *fp,
+                                    const yyjson_mut_doc *doc,
+                                    yyjson_write_flag flg,
+                                    const yyjson_alc *alc,
+                                    yyjson_write_err *err);
+
+/**
+ Write a document to JSON string.
+ 
+ This function is thread-safe when:
+ The `doc` is not modified by other threads.
+ 
+ @param doc The JSON document.
+    If this doc is NULL or has no root, the function will fail and return false.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param len A pointer to receive output length in bytes (not including the
+    null-terminator). Pass NULL if you don't need length information.
+ @return A new JSON string, or NULL if an error occurs.
+    This string is encoded as UTF-8 with a null-terminator.
+    When it's no longer needed, it should be freed with free().
+ */
+yyjson_api_inline char *yyjson_mut_write(const yyjson_mut_doc *doc,
+                                         yyjson_write_flag flg,
+                                         size_t *len) {
+    return yyjson_mut_write_opts(doc, flg, NULL, len, NULL);
+}
+
+
+
+/*==============================================================================
+ * JSON Value Writer API
+ *============================================================================*/
+
+/**
+ Write a value to JSON string with options.
+ 
+ This function is thread-safe when:
+ The `alc` is thread-safe or NULL.
+ 
+ @param val The JSON root value.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON writer.
+    Pass NULL to use the libc's default allocator.
+ @param len A pointer to receive output length in bytes (not including the
+    null-terminator). Pass NULL if you don't need length information.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return A new JSON string, or NULL if an error occurs.
+    This string is encoded as UTF-8 with a null-terminator.
+    When it's no longer needed, it should be freed with free() or alc->free().
+ */
+yyjson_api char *yyjson_val_write_opts(const yyjson_val *val,
+                                       yyjson_write_flag flg,
+                                       const yyjson_alc *alc,
+                                       size_t *len,
+                                       yyjson_write_err *err);
+
+/**
+ Write a value to JSON file with options.
+ 
+ This function is thread-safe when:
+ 1. The file is not accessed by other threads.
+ 2. The `alc` is thread-safe or NULL.
+ 
+ @param path The JSON file's path.
+    If this path is NULL or invalid, the function will fail and return false.
+    If this file is not empty, the content will be discarded.
+ @param val The JSON root value.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON writer.
+    Pass NULL to use the libc's default allocator.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return true if successful, false if an error occurs.
+ 
+ @warning On 32-bit operating system, files larger than 2GB may fail to write.
+ */
+yyjson_api bool yyjson_val_write_file(const char *path,
+                                      const yyjson_val *val,
+                                      yyjson_write_flag flg,
+                                      const yyjson_alc *alc,
+                                      yyjson_write_err *err);
+
+/**
+ Write a value to file pointer with options.
+ 
+ @param fp The file pointer.
+    The data will be written to the current position of the file.
+    If this path is NULL or invalid, the function will fail and return false.
+ @param val The JSON root value.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON writer.
+    Pass NULL to use the libc's default allocator.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return true if successful, false if an error occurs.
+ 
+ @warning On 32-bit operating system, files larger than 2GB may fail to write.
+ */
+yyjson_api bool yyjson_val_write_fp(FILE *fp,
+                                    const yyjson_val *val,
+                                    yyjson_write_flag flg,
+                                    const yyjson_alc *alc,
+                                    yyjson_write_err *err);
+
+/**
+ Write a value to JSON string.
+ 
+ This function is thread-safe.
+ 
+ @param val The JSON root value.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param len A pointer to receive output length in bytes (not including the
+    null-terminator). Pass NULL if you don't need length information.
+ @return A new JSON string, or NULL if an error occurs.
+    This string is encoded as UTF-8 with a null-terminator.
+    When it's no longer needed, it should be freed with free().
+ */
+yyjson_api_inline char *yyjson_val_write(const yyjson_val *val,
+                                         yyjson_write_flag flg,
+                                         size_t *len) {
+    return yyjson_val_write_opts(val, flg, NULL, len, NULL);
+}
+
+/**
+ Write a value to JSON string with options.
+ 
+ This function is thread-safe when:
+ 1. The `val` is not modified by other threads.
+ 2. The `alc` is thread-safe or NULL.
+ 
+ @param val The mutable JSON root value.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON writer.
+    Pass NULL to use the libc's default allocator.
+ @param len A pointer to receive output length in bytes (not including the
+    null-terminator). Pass NULL if you don't need length information.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return  A new JSON string, or NULL if an error occurs.
+    This string is encoded as UTF-8 with a null-terminator.
+    When it's no longer needed, it should be freed with free() or alc->free().
+ */
+yyjson_api char *yyjson_mut_val_write_opts(const yyjson_mut_val *val,
+                                           yyjson_write_flag flg,
+                                           const yyjson_alc *alc,
+                                           size_t *len,
+                                           yyjson_write_err *err);
+
+/**
+ Write a value to JSON file with options.
+ 
+ This function is thread-safe when:
+ 1. The file is not accessed by other threads.
+ 2. The `val` is not modified by other threads.
+ 3. The `alc` is thread-safe or NULL.
+ 
+ @param path The JSON file's path.
+    If this path is NULL or invalid, the function will fail and return false.
+    If this file is not empty, the content will be discarded.
+ @param val The mutable JSON root value.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON writer.
+    Pass NULL to use the libc's default allocator.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return true if successful, false if an error occurs.
+ 
+ @warning On 32-bit operating system, files larger than 2GB may fail to write.
+ */
+yyjson_api bool yyjson_mut_val_write_file(const char *path,
+                                          const yyjson_mut_val *val,
+                                          yyjson_write_flag flg,
+                                          const yyjson_alc *alc,
+                                          yyjson_write_err *err);
+
+/**
+ Write a value to JSON file with options.
+ 
+ @param fp The file pointer.
+    The data will be written to the current position of the file.
+    If this path is NULL or invalid, the function will fail and return false.
+ @param val The mutable JSON root value.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param alc The memory allocator used by JSON writer.
+    Pass NULL to use the libc's default allocator.
+ @param err A pointer to receive error information.
+    Pass NULL if you don't need error information.
+ @return true if successful, false if an error occurs.
+ 
+ @warning On 32-bit operating system, files larger than 2GB may fail to write.
+ */
+yyjson_api bool yyjson_mut_val_write_fp(FILE *fp,
+                                        const yyjson_mut_val *val,
+                                        yyjson_write_flag flg,
+                                        const yyjson_alc *alc,
+                                        yyjson_write_err *err);
+
+/**
+ Write a value to JSON string.
+ 
+ This function is thread-safe when:
+ The `val` is not modified by other threads.
+ 
+ @param val The JSON root value.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param flg The JSON write options.
+    Multiple options can be combined with `|` operator. 0 means no options.
+ @param len A pointer to receive output length in bytes (not including the
+    null-terminator). Pass NULL if you don't need length information.
+ @return A new JSON string, or NULL if an error occurs.
+    This string is encoded as UTF-8 with a null-terminator.
+    When it's no longer needed, it should be freed with free().
+ */
+yyjson_api_inline char *yyjson_mut_val_write(const yyjson_mut_val *val,
+                                             yyjson_write_flag flg,
+                                             size_t *len) {
+    return yyjson_mut_val_write_opts(val, flg, NULL, len, NULL);
+}
+
+
+
+/*==============================================================================
+ * JSON Document API
+ *============================================================================*/
+
+/** Returns the root value of this JSON document.
+    Returns NULL if `doc` is NULL. */
+yyjson_api_inline yyjson_val *yyjson_doc_get_root(yyjson_doc *doc);
+
+/** Returns read size of input JSON data.
+    Returns 0 if `doc` is NULL.
+    For example: the read size of `[1,2,3]` is 7 bytes.  */
+yyjson_api_inline size_t yyjson_doc_get_read_size(yyjson_doc *doc);
+
+/** Returns total value count in this JSON document.
+    Returns 0 if `doc` is NULL.
+    For example: the value count of `[1,2,3]` is 4. */
+yyjson_api_inline size_t yyjson_doc_get_val_count(yyjson_doc *doc);
+
+/** Release the JSON document and free the memory.
+    After calling this function, the `doc` and all values from the `doc` are no
+    longer available. This function will do nothing if the `doc` is NULL. */
+yyjson_api_inline void yyjson_doc_free(yyjson_doc *doc);
+
+
+
+/*==============================================================================
+ * JSON Value Type API
+ *============================================================================*/
+
+/** Returns whether the JSON value is raw.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_raw(yyjson_val *val);
+
+/** Returns whether the JSON value is `null`.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_null(yyjson_val *val);
+
+/** Returns whether the JSON value is `true`.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_true(yyjson_val *val);
+
+/** Returns whether the JSON value is `false`.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_false(yyjson_val *val);
+
+/** Returns whether the JSON value is bool (true/false).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_bool(yyjson_val *val);
+
+/** Returns whether the JSON value is unsigned integer (uint64_t).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_uint(yyjson_val *val);
+
+/** Returns whether the JSON value is signed integer (int64_t).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_sint(yyjson_val *val);
+
+/** Returns whether the JSON value is integer (uint64_t/int64_t).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_int(yyjson_val *val);
+
+/** Returns whether the JSON value is real number (double).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_real(yyjson_val *val);
+
+/** Returns whether the JSON value is number (uint64_t/int64_t/double).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_num(yyjson_val *val);
+
+/** Returns whether the JSON value is string.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_str(yyjson_val *val);
+
+/** Returns whether the JSON value is array.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_arr(yyjson_val *val);
+
+/** Returns whether the JSON value is object.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_obj(yyjson_val *val);
+
+/** Returns whether the JSON value is container (array/object).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_is_ctn(yyjson_val *val);
+
+
+
+/*==============================================================================
+ * JSON Value Content API
+ *============================================================================*/
+
+/** Returns the JSON value's type.
+    Returns YYJSON_TYPE_NONE if `val` is NULL. */
+yyjson_api_inline yyjson_type yyjson_get_type(yyjson_val *val);
+
+/** Returns the JSON value's subtype.
+    Returns YYJSON_SUBTYPE_NONE if `val` is NULL. */
+yyjson_api_inline yyjson_subtype yyjson_get_subtype(yyjson_val *val);
+
+/** Returns the JSON value's tag.
+    Returns 0 if `val` is NULL. */
+yyjson_api_inline uint8_t yyjson_get_tag(yyjson_val *val);
+
+/** Returns the JSON value's type description.
+    The return value should be one of these strings: "raw", "null", "string",
+    "array", "object", "true", "false", "uint", "sint", "real", "unknown". */
+yyjson_api_inline const char *yyjson_get_type_desc(yyjson_val *val);
+
+/** Returns the content if the value is raw.
+    Returns NULL if `val` is NULL or type is not raw. */
+yyjson_api_inline const char *yyjson_get_raw(yyjson_val *val);
+
+/** Returns the content if the value is bool.
+    Returns NULL if `val` is NULL or type is not bool. */
+yyjson_api_inline bool yyjson_get_bool(yyjson_val *val);
+
+/** Returns the content and cast to uint64_t.
+    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
+yyjson_api_inline uint64_t yyjson_get_uint(yyjson_val *val);
+
+/** Returns the content and cast to int64_t.
+    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
+yyjson_api_inline int64_t yyjson_get_sint(yyjson_val *val);
+
+/** Returns the content and cast to int.
+    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
+yyjson_api_inline int yyjson_get_int(yyjson_val *val);
+
+/** Returns the content if the value is real number, or 0.0 on error.
+    Returns 0.0 if `val` is NULL or type is not real(double). */
+yyjson_api_inline double yyjson_get_real(yyjson_val *val);
+
+/** Returns the content and typecast to `double` if the value is number.
+    Returns 0.0 if `val` is NULL or type is not number(uint/sint/real). */
+yyjson_api_inline double yyjson_get_num(yyjson_val *val);
+
+/** Returns the content if the value is string.
+    Returns NULL if `val` is NULL or type is not string. */
+yyjson_api_inline const char *yyjson_get_str(yyjson_val *val);
+
+/** Returns the content length (string length, array size, object size.
+    Returns 0 if `val` is NULL or type is not string/array/object. */
+yyjson_api_inline size_t yyjson_get_len(yyjson_val *val);
+
+/** Returns whether the JSON value is equals to a string.
+    Returns false if input is NULL or type is not string. */
+yyjson_api_inline bool yyjson_equals_str(yyjson_val *val, const char *str);
+
+/** Returns whether the JSON value is equals to a string.
+    The `str` should be a UTF-8 string, null-terminator is not required.
+    Returns false if input is NULL or type is not string. */
+yyjson_api_inline bool yyjson_equals_strn(yyjson_val *val, const char *str,
+                                          size_t len);
+
+/** Returns whether two JSON values are equal (deep compare).
+    Returns false if input is NULL.
+    @note the result may be inaccurate if object has duplicate keys.
+    @warning This function is recursive and may cause a stack overflow
+        if the object level is too deep. */
+yyjson_api_inline bool yyjson_equals(yyjson_val *lhs, yyjson_val *rhs);
+
+/** Set the value to raw.
+    Returns false if input is NULL or `val` is object or array.
+    @warning This will modify the `immutable` value, use with caution. */
+yyjson_api_inline bool yyjson_set_raw(yyjson_val *val,
+                                      const char *raw, size_t len);
+
+/** Set the value to null.
+    Returns false if input is NULL or `val` is object or array.
+    @warning This will modify the `immutable` value, use with caution. */
+yyjson_api_inline bool yyjson_set_null(yyjson_val *val);
+
+/** Set the value to bool.
+    Returns false if input is NULL or `val` is object or array.
+    @warning This will modify the `immutable` value, use with caution. */
+yyjson_api_inline bool yyjson_set_bool(yyjson_val *val, bool num);
+
+/** Set the value to uint.
+    Returns false if input is NULL or `val` is object or array.
+    @warning This will modify the `immutable` value, use with caution. */
+yyjson_api_inline bool yyjson_set_uint(yyjson_val *val, uint64_t num);
+
+/** Set the value to sint.
+    Returns false if input is NULL or `val` is object or array.
+    @warning This will modify the `immutable` value, use with caution. */
+yyjson_api_inline bool yyjson_set_sint(yyjson_val *val, int64_t num);
+
+/** Set the value to int.
+    Returns false if input is NULL or `val` is object or array.
+    @warning This will modify the `immutable` value, use with caution. */
+yyjson_api_inline bool yyjson_set_int(yyjson_val *val, int num);
+
+/** Set the value to real.
+    Returns false if input is NULL or `val` is object or array.
+    @warning This will modify the `immutable` value, use with caution. */
+yyjson_api_inline bool yyjson_set_real(yyjson_val *val, double num);
+
+/** Set the value to string (null-terminated).
+    Returns false if input is NULL or `val` is object or array.
+    @warning This will modify the `immutable` value, use with caution. */
+yyjson_api_inline bool yyjson_set_str(yyjson_val *val, const char *str);
+
+/** Set the value to string (with length).
+    Returns false if input is NULL or `val` is object or array.
+    @warning This will modify the `immutable` value, use with caution. */
+yyjson_api_inline bool yyjson_set_strn(yyjson_val *val,
+                                       const char *str, size_t len);
+
+
+
+/*==============================================================================
+ * JSON Array API
+ *============================================================================*/
+
+/** Returns the number of elements in this array.
+    Returns 0 if `arr` is NULL or type is not array. */
+yyjson_api_inline size_t yyjson_arr_size(yyjson_val *arr);
+
+/** Returns the element at the specified position in this array.
+    Returns NULL if array is NULL/empty or the index is out of bounds.
+    @warning This function takes a linear search time if array is not flat.
+        For example: `[1,{},3]` is flat, `[1,[2],3]` is not flat. */
+yyjson_api_inline yyjson_val *yyjson_arr_get(yyjson_val *arr, size_t idx);
+
+/** Returns the first element of this array.
+    Returns NULL if `arr` is NULL/empty or type is not array. */
+yyjson_api_inline yyjson_val *yyjson_arr_get_first(yyjson_val *arr);
+
+/** Returns the last element of this array.
+    Returns NULL if `arr` is NULL/empty or type is not array.
+    @warning This function takes a linear search time if array is not flat.
+        For example: `[1,{},3]` is flat, `[1,[2],3]` is not flat.*/
+yyjson_api_inline yyjson_val *yyjson_arr_get_last(yyjson_val *arr);
+
+
+
+/*==============================================================================
+ * JSON Array Iterator API
+ *============================================================================*/
+
+/**
+ A JSON array iterator.
+ 
+ @par Example
+ @code
+    yyjson_val *val;
+    yyjson_arr_iter iter = yyjson_arr_iter_with(arr);
+    while ((val = yyjson_arr_iter_next(&iter))) {
+        your_func(val);
+    }
+ @endcode
+ */
+typedef struct yyjson_arr_iter {
+    size_t idx; /**< next value's index */
+    size_t max; /**< maximum index (arr.size) */
+    yyjson_val *cur; /**< next value */
+} yyjson_arr_iter;
+
+/**
+ Initialize an iterator for this array.
+ 
+ @param arr The array to be iterated over.
+    If this parameter is NULL or not an array, `iter` will be set to empty.
+ @param iter The iterator to be initialized.
+    If this parameter is NULL, the function will fail and return false.
+ @return true if the `iter` has been successfully initialized.
+ 
+ @note The iterator does not need to be destroyed.
+ */
+yyjson_api_inline bool yyjson_arr_iter_init(yyjson_val *arr,
+                                            yyjson_arr_iter *iter);
+
+/**
+ Create an iterator with an array , same as `yyjson_arr_iter_init()`.
+ 
+ @param arr The array to be iterated over.
+    If this parameter is NULL or not an array, an empty iterator will returned.
+ @return A new iterator for the array.
+ 
+ @note The iterator does not need to be destroyed.
+ */
+yyjson_api_inline yyjson_arr_iter yyjson_arr_iter_with(yyjson_val *arr);
+
+/**
+ Returns whether the iteration has more elements.
+ If `iter` is NULL, this function will return false.
+ */
+yyjson_api_inline bool yyjson_arr_iter_has_next(yyjson_arr_iter *iter);
+
+/**
+ Returns the next element in the iteration, or NULL on end.
+ If `iter` is NULL, this function will return NULL.
+ */
+yyjson_api_inline yyjson_val *yyjson_arr_iter_next(yyjson_arr_iter *iter);
+
+/**
+ Macro for iterating over an array.
+ It works like iterator, but with a more intuitive API.
+ 
+ @par Example
+ @code
+    size_t idx, max;
+    yyjson_val *val;
+    yyjson_arr_foreach(arr, idx, max, val) {
+        your_func(idx, val);
+    }
+ @endcode
+ */
+#define yyjson_arr_foreach(arr, idx, max, val) \
+    for ((idx) = 0, \
+        (max) = yyjson_arr_size(arr), \
+        (val) = yyjson_arr_get_first(arr); \
+        (idx) < (max); \
+        (idx)++, \
+        (val) = unsafe_yyjson_get_next(val))
+
+
+
+/*==============================================================================
+ * JSON Object API
+ *============================================================================*/
+
+/** Returns the number of key-value pairs in this object.
+    Returns 0 if `obj` is NULL or type is not object. */
+yyjson_api_inline size_t yyjson_obj_size(yyjson_val *obj);
+
+/** Returns the value to which the specified key is mapped.
+    Returns NULL if this object contains no mapping for the key.
+    Returns NULL if `obj/key` is NULL, or type is not object.
+    
+    The `key` should be a null-terminated UTF-8 string.
+    
+    @warning This function takes a linear search time. */
+yyjson_api_inline yyjson_val *yyjson_obj_get(yyjson_val *obj, const char *key);
+
+/** Returns the value to which the specified key is mapped.
+    Returns NULL if this object contains no mapping for the key.
+    Returns NULL if `obj/key` is NULL, or type is not object.
+    
+    The `key` should be a UTF-8 string, null-terminator is not required.
+    The `key_len` should be the length of the key, in bytes.
+    
+    @warning This function takes a linear search time. */
+yyjson_api_inline yyjson_val *yyjson_obj_getn(yyjson_val *obj, const char *key,
+                                              size_t key_len);
+
+
+
+/*==============================================================================
+ * JSON Object Iterator API
+ *============================================================================*/
+
+/**
+ A JSON object iterator.
+ 
+ @par Example
+ @code
+    yyjson_val *key, *val;
+    yyjson_obj_iter iter = yyjson_obj_iter_with(obj);
+    while ((key = yyjson_obj_iter_next(&iter))) {
+        val = yyjson_obj_iter_get_val(key);
+        your_func(key, val);
+    }
+ @endcode
+ 
+ If the ordering of the keys is known at compile-time, you can use this method
+ to speed up value lookups:
+ @code
+    // {"k1":1, "k2": 3, "k3": 3}
+    yyjson_val *key, *val;
+    yyjson_obj_iter iter = yyjson_obj_iter_with(obj);
+    yyjson_val *v1 = yyjson_obj_iter_get(&iter, "k1");
+    yyjson_val *v3 = yyjson_obj_iter_get(&iter, "k3");
+ @endcode
+ @see yyjson_obj_iter_get() and yyjson_obj_iter_getn()
+ */
+typedef struct yyjson_obj_iter {
+    size_t idx; /**< next key's index */
+    size_t max; /**< maximum key index (obj.size) */
+    yyjson_val *cur; /**< next key */
+    yyjson_val *obj; /**< the object being iterated */
+} yyjson_obj_iter;
+
+/**
+ Initialize an iterator for this object.
+ 
+ @param obj The object to be iterated over.
+    If this parameter is NULL or not an object, `iter` will be set to empty.
+ @param iter The iterator to be initialized.
+    If this parameter is NULL, the function will fail and return false.
+ @return true if the `iter` has been successfully initialized.
+ 
+ @note The iterator does not need to be destroyed.
+ */
+yyjson_api_inline bool yyjson_obj_iter_init(yyjson_val *obj,
+                                            yyjson_obj_iter *iter);
+
+/**
+ Create an iterator with an object, same as `yyjson_obj_iter_init()`.
+ 
+ @param obj The object to be iterated over.
+    If this parameter is NULL or not an object, an empty iterator will returned.
+ @return A new iterator for the object.
+ 
+ @note The iterator does not need to be destroyed.
+ */
+yyjson_api_inline yyjson_obj_iter yyjson_obj_iter_with(yyjson_val *obj);
+
+/**
+ Returns whether the iteration has more elements.
+ If `iter` is NULL, this function will return false.
+ */
+yyjson_api_inline bool yyjson_obj_iter_has_next(yyjson_obj_iter *iter);
+
+/**
+ Returns the next key in the iteration, or NULL on end.
+ If `iter` is NULL, this function will return NULL.
+ */
+yyjson_api_inline yyjson_val *yyjson_obj_iter_next(yyjson_obj_iter *iter);
+
+/**
+ Returns the value for key inside the iteration.
+ If `iter` is NULL, this function will return NULL.
+ */
+yyjson_api_inline yyjson_val *yyjson_obj_iter_get_val(yyjson_val *key);
+
+/**
+ Iterates to a specified key and returns the value.
+ 
+ This function does the same thing as `yyjson_obj_get()`, but is much faster
+ if the ordering of the keys is known at compile-time and you are using the same
+ order to look up the values. If the key exists in this object, then the
+ iterator will stop at the next key, otherwise the iterator will not change and
+ NULL is returned.
+ 
+ @param iter The object iterator, should not be NULL.
+ @param key The key, should be a UTF-8 string with null-terminator.
+ @return The value to which the specified key is mapped.
+    NULL if this object contains no mapping for the key or input is invalid.
+ 
+ @warning This function takes a linear search time if the key is not nearby.
+ */
+yyjson_api_inline yyjson_val *yyjson_obj_iter_get(yyjson_obj_iter *iter,
+                                                  const char *key);
+
+/**
+ Iterates to a specified key and returns the value.
+
+ This function does the same thing as `yyjson_obj_getn()`, but is much faster
+ if the ordering of the keys is known at compile-time and you are using the same
+ order to look up the values. If the key exists in this object, then the
+ iterator will stop at the next key, otherwise the iterator will not change and
+ NULL is returned.
+ 
+ @param iter The object iterator, should not be NULL.
+ @param key The key, should be a UTF-8 string, null-terminator is not required.
+ @param key_len The the length of `key`, in bytes.
+ @return The value to which the specified key is mapped.
+    NULL if this object contains no mapping for the key or input is invalid.
+ 
+ @warning This function takes a linear search time if the key is not nearby.
+ */
+yyjson_api_inline yyjson_val *yyjson_obj_iter_getn(yyjson_obj_iter *iter,
+                                                   const char *key,
+                                                   size_t key_len);
+
+/**
+ Macro for iterating over an object.
+ It works like iterator, but with a more intuitive API.
+ 
+ @par Example
+ @code
+    size_t idx, max;
+    yyjson_val *key, *val;
+    yyjson_obj_foreach(obj, idx, max, key, val) {
+        your_func(key, val);
+    }
+ @endcode
+ */
+#define yyjson_obj_foreach(obj, idx, max, key, val) \
+    for ((idx) = 0, \
+        (max) = yyjson_obj_size(obj), \
+        (key) = (obj) ? unsafe_yyjson_get_first(obj) : NULL, \
+        (val) = (key) + 1; \
+        (idx) < (max); \
+        (idx)++, \
+        (key) = unsafe_yyjson_get_next(val), \
+        (val) = (key) + 1)
+
+
+
+/*==============================================================================
+ * Mutable JSON Document API
+ *============================================================================*/
+
+/** Returns the root value of this JSON document.
+    Returns NULL if `doc` is NULL. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_root(yyjson_mut_doc *doc);
+
+/** Sets the root value of this JSON document.
+    Pass NULL to clear root value of the document. */
+yyjson_api_inline void yyjson_mut_doc_set_root(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *root);
+
+/**
+ Set the string pool size for a mutable document.
+ This function does not allocate memory immediately, but uses the size when
+ the next memory allocation is needed.
+ 
+ If the caller knows the approximate bytes of strings that the document needs to
+ store (e.g. copy string with `yyjson_mut_strcpy` function), setting a larger
+ size can avoid multiple memory allocations and improve performance.
+ 
+ @param doc The mutable document.
+ @param len The desired string pool size in bytes (total string length).
+ @return true if successful, false if size is 0 or overflow.
+ */
+yyjson_api bool yyjson_mut_doc_set_str_pool_size(yyjson_mut_doc *doc,
+                                                 size_t len);
+
+/**
+ Set the value pool size for a mutable document.
+ This function does not allocate memory immediately, but uses the size when
+ the next memory allocation is needed.
+ 
+ If the caller knows the approximate number of values that the document needs to
+ store (e.g. create new value with `yyjson_mut_xxx` functions), setting a larger
+ size can avoid multiple memory allocations and improve performance.
+ 
+ @param doc The mutable document.
+ @param count The desired value pool size (number of `yyjson_mut_val`).
+ @return true if successful, false if size is 0 or overflow.
+ */
+yyjson_api bool yyjson_mut_doc_set_val_pool_size(yyjson_mut_doc *doc,
+                                                 size_t count);
+
+/** Release the JSON document and free the memory.
+    After calling this function, the `doc` and all values from the `doc` are no
+    longer available. This function will do nothing if the `doc` is NULL.  */
+yyjson_api void yyjson_mut_doc_free(yyjson_mut_doc *doc);
+
+/** Creates and returns a new mutable JSON document, returns NULL on error.
+    If allocator is NULL, the default allocator will be used. */
+yyjson_api yyjson_mut_doc *yyjson_mut_doc_new(const yyjson_alc *alc);
+
+/** Copies and returns a new mutable document from input, returns NULL on error.
+    This makes a `deep-copy` on the immutable document.
+    If allocator is NULL, the default allocator will be used.
+    @note `imut_doc` -> `mut_doc`. */
+yyjson_api yyjson_mut_doc *yyjson_doc_mut_copy(yyjson_doc *doc,
+                                               const yyjson_alc *alc);
+
+/** Copies and returns a new mutable document from input, returns NULL on error.
+    This makes a `deep-copy` on the mutable document.
+    If allocator is NULL, the default allocator will be used.
+    @note `mut_doc` -> `mut_doc`. */
+yyjson_api yyjson_mut_doc *yyjson_mut_doc_mut_copy(yyjson_mut_doc *doc,
+                                                   const yyjson_alc *alc);
+
+/** Copies and returns a new mutable value from input, returns NULL on error.
+    This makes a `deep-copy` on the immutable value.
+    The memory was managed by mutable document.
+    @note `imut_val` -> `mut_val`. */
+yyjson_api yyjson_mut_val *yyjson_val_mut_copy(yyjson_mut_doc *doc,
+                                               yyjson_val *val);
+
+/** Copies and returns a new mutable value from input, returns NULL on error.
+    This makes a `deep-copy` on the mutable value.
+    The memory was managed by mutable document.
+    @note `mut_val` -> `mut_val`.
+    @warning This function is recursive and may cause a stack overflow
+        if the object level is too deep. */
+yyjson_api yyjson_mut_val *yyjson_mut_val_mut_copy(yyjson_mut_doc *doc,
+                                                   yyjson_mut_val *val);
+
+/** Copies and returns a new immutable document from input,
+    returns NULL on error. This makes a `deep-copy` on the mutable document.
+    The returned document should be freed with `yyjson_doc_free()`.
+    @note `mut_doc` -> `imut_doc`.
+    @warning This function is recursive and may cause a stack overflow
+        if the object level is too deep. */
+yyjson_api yyjson_doc *yyjson_mut_doc_imut_copy(yyjson_mut_doc *doc,
+                                                const yyjson_alc *alc);
+
+/** Copies and returns a new immutable document from input,
+    returns NULL on error. This makes a `deep-copy` on the mutable value.
+    The returned document should be freed with `yyjson_doc_free()`.
+    @note `mut_val` -> `imut_doc`.
+    @warning This function is recursive and may cause a stack overflow
+        if the object level is too deep. */
+yyjson_api yyjson_doc *yyjson_mut_val_imut_copy(yyjson_mut_val *val,
+                                                const yyjson_alc *alc);
+
+
+
+/*==============================================================================
+ * Mutable JSON Value Type API
+ *============================================================================*/
+
+/** Returns whether the JSON value is raw.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_raw(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is `null`.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_null(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is `true`.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_true(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is `false`.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_false(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is bool (true/false).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_bool(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is unsigned integer (uint64_t).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_uint(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is signed integer (int64_t).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_sint(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is integer (uint64_t/int64_t).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_int(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is real number (double).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_real(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is number (uint/sint/real).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_num(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is string.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_str(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is array.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_arr(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is object.
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_obj(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is container (array/object).
+    Returns false if `val` is NULL. */
+yyjson_api_inline bool yyjson_mut_is_ctn(yyjson_mut_val *val);
+
+
+
+/*==============================================================================
+ * Mutable JSON Value Content API
+ *============================================================================*/
+
+/** Returns the JSON value's type.
+    Returns `YYJSON_TYPE_NONE` if `val` is NULL. */
+yyjson_api_inline yyjson_type yyjson_mut_get_type(yyjson_mut_val *val);
+
+/** Returns the JSON value's subtype.
+    Returns `YYJSON_SUBTYPE_NONE` if `val` is NULL. */
+yyjson_api_inline yyjson_subtype yyjson_mut_get_subtype(yyjson_mut_val *val);
+
+/** Returns the JSON value's tag.
+    Returns 0 if `val` is NULL. */
+yyjson_api_inline uint8_t yyjson_mut_get_tag(yyjson_mut_val *val);
+
+/** Returns the JSON value's type description.
+    The return value should be one of these strings: "raw", "null", "string",
+    "array", "object", "true", "false", "uint", "sint", "real", "unknown". */
+yyjson_api_inline const char *yyjson_mut_get_type_desc(yyjson_mut_val *val);
+
+/** Returns the content if the value is raw.
+    Returns NULL if `val` is NULL or type is not raw. */
+yyjson_api_inline const char *yyjson_mut_get_raw(yyjson_mut_val *val);
+
+/** Returns the content if the value is bool.
+    Returns NULL if `val` is NULL or type is not bool. */
+yyjson_api_inline bool yyjson_mut_get_bool(yyjson_mut_val *val);
+
+/** Returns the content and cast to uint64_t.
+    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
+yyjson_api_inline uint64_t yyjson_mut_get_uint(yyjson_mut_val *val);
+
+/** Returns the content and cast to int64_t.
+    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
+yyjson_api_inline int64_t yyjson_mut_get_sint(yyjson_mut_val *val);
+
+/** Returns the content and cast to int.
+    Returns 0 if `val` is NULL or type is not integer(sint/uint). */
+yyjson_api_inline int yyjson_mut_get_int(yyjson_mut_val *val);
+
+/** Returns the content if the value is real number.
+    Returns 0.0 if `val` is NULL or type is not real(double). */
+yyjson_api_inline double yyjson_mut_get_real(yyjson_mut_val *val);
+
+/** Returns the content and typecast to `double` if the value is number.
+    Returns 0.0 if `val` is NULL or type is not number(uint/sint/real). */
+yyjson_api_inline double yyjson_mut_get_num(yyjson_mut_val *val);
+
+/** Returns the content if the value is string.
+    Returns NULL if `val` is NULL or type is not string. */
+yyjson_api_inline const char *yyjson_mut_get_str(yyjson_mut_val *val);
+
+/** Returns the content length (string length, array size, object size.
+    Returns 0 if `val` is NULL or type is not string/array/object. */
+yyjson_api_inline size_t yyjson_mut_get_len(yyjson_mut_val *val);
+
+/** Returns whether the JSON value is equals to a string.
+    The `str` should be a null-terminated UTF-8 string.
+    Returns false if input is NULL or type is not string. */
+yyjson_api_inline bool yyjson_mut_equals_str(yyjson_mut_val *val,
+                                             const char *str);
+
+/** Returns whether the JSON value is equals to a string.
+    The `str` should be a UTF-8 string, null-terminator is not required.
+    Returns false if input is NULL or type is not string. */
+yyjson_api_inline bool yyjson_mut_equals_strn(yyjson_mut_val *val,
+                                              const char *str, size_t len);
+
+/** Returns whether two JSON values are equal (deep compare).
+    Returns false if input is NULL.
+    @note the result may be inaccurate if object has duplicate keys.
+    @warning This function is recursive and may cause a stack overflow
+        if the object level is too deep. */
+yyjson_api_inline bool yyjson_mut_equals(yyjson_mut_val *lhs,
+                                         yyjson_mut_val *rhs);
+
+/** Set the value to raw.
+    Returns false if input is NULL.
+    @warning This function should not be used on an existing object or array. */
+yyjson_api_inline bool yyjson_mut_set_raw(yyjson_mut_val *val,
+                                          const char *raw, size_t len);
+
+/** Set the value to null.
+    Returns false if input is NULL.
+    @warning This function should not be used on an existing object or array. */
+yyjson_api_inline bool yyjson_mut_set_null(yyjson_mut_val *val);
+
+/** Set the value to bool.
+    Returns false if input is NULL.
+    @warning This function should not be used on an existing object or array. */
+yyjson_api_inline bool yyjson_mut_set_bool(yyjson_mut_val *val, bool num);
+
+/** Set the value to uint.
+    Returns false if input is NULL.
+    @warning This function should not be used on an existing object or array. */
+yyjson_api_inline bool yyjson_mut_set_uint(yyjson_mut_val *val, uint64_t num);
+
+/** Set the value to sint.
+    Returns false if input is NULL.
+    @warning This function should not be used on an existing object or array. */
+yyjson_api_inline bool yyjson_mut_set_sint(yyjson_mut_val *val, int64_t num);
+
+/** Set the value to int.
+    Returns false if input is NULL.
+    @warning This function should not be used on an existing object or array. */
+yyjson_api_inline bool yyjson_mut_set_int(yyjson_mut_val *val, int num);
+
+/** Set the value to real.
+    Returns false if input is NULL.
+    @warning This function should not be used on an existing object or array. */
+yyjson_api_inline bool yyjson_mut_set_real(yyjson_mut_val *val, double num);
+
+/** Set the value to string (null-terminated).
+    Returns false if input is NULL.
+    @warning This function should not be used on an existing object or array. */
+yyjson_api_inline bool yyjson_mut_set_str(yyjson_mut_val *val, const char *str);
+
+/** Set the value to string (with length).
+    Returns false if input is NULL.
+    @warning This function should not be used on an existing object or array. */
+yyjson_api_inline bool yyjson_mut_set_strn(yyjson_mut_val *val,
+                                           const char *str, size_t len);
+
+/** Set the value to array.
+    Returns false if input is NULL.
+    @warning This function should not be used on an existing object or array. */
+yyjson_api_inline bool yyjson_mut_set_arr(yyjson_mut_val *val);
+
+/** Set the value to array.
+    Returns false if input is NULL.
+    @warning This function should not be used on an existing object or array. */
+yyjson_api_inline bool yyjson_mut_set_obj(yyjson_mut_val *val);
+
+
+
+/*==============================================================================
+ * Mutable JSON Value Creation API
+ *============================================================================*/
+
+/** Creates and returns a raw value, returns NULL on error.
+    The `str` should be a null-terminated UTF-8 string.
+    
+    @warning The input string is not copied, you should keep this string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_raw(yyjson_mut_doc *doc,
+                                                 const char *str);
+
+/** Creates and returns a raw value, returns NULL on error.
+    The `str` should be a UTF-8 string, null-terminator is not required.
+    
+    @warning The input string is not copied, you should keep this string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_rawn(yyjson_mut_doc *doc,
+                                                  const char *str,
+                                                  size_t len);
+
+/** Creates and returns a raw value, returns NULL on error.
+    The `str` should be a null-terminated UTF-8 string.
+    The input string is copied and held by the document. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_rawcpy(yyjson_mut_doc *doc,
+                                                    const char *str);
+
+/** Creates and returns a raw value, returns NULL on error.
+    The `str` should be a UTF-8 string, null-terminator is not required.
+    The input string is copied and held by the document. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_rawncpy(yyjson_mut_doc *doc,
+                                                     const char *str,
+                                                     size_t len);
+
+/** Creates and returns a null value, returns NULL on error. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_null(yyjson_mut_doc *doc);
+
+/** Creates and returns a true value, returns NULL on error. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_true(yyjson_mut_doc *doc);
+
+/** Creates and returns a false value, returns NULL on error. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_false(yyjson_mut_doc *doc);
+
+/** Creates and returns a bool value, returns NULL on error. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_bool(yyjson_mut_doc *doc,
+                                                  bool val);
+
+/** Creates and returns an unsigned integer value, returns NULL on error. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_uint(yyjson_mut_doc *doc,
+                                                  uint64_t num);
+
+/** Creates and returns a signed integer value, returns NULL on error. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_sint(yyjson_mut_doc *doc,
+                                                  int64_t num);
+
+/** Creates and returns a signed integer value, returns NULL on error. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_int(yyjson_mut_doc *doc,
+                                                 int64_t num);
+
+/** Creates and returns an real number value, returns NULL on error. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_real(yyjson_mut_doc *doc,
+                                                  double num);
+
+/** Creates and returns a string value, returns NULL on error.
+    The `str` should be a null-terminated UTF-8 string.
+    @warning The input string is not copied, you should keep this string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_str(yyjson_mut_doc *doc,
+                                                 const char *str);
+
+/** Creates and returns a string value, returns NULL on error.
+    The `str` should be a UTF-8 string, null-terminator is not required.
+    @warning The input string is not copied, you should keep this string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_strn(yyjson_mut_doc *doc,
+                                                  const char *str,
+                                                  size_t len);
+
+/** Creates and returns a string value, returns NULL on error.
+    The `str` should be a null-terminated UTF-8 string.
+    The input string is copied and held by the document. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_strcpy(yyjson_mut_doc *doc,
+                                                    const char *str);
+
+/** Creates and returns a string value, returns NULL on error.
+    The `str` should be a UTF-8 string, null-terminator is not required.
+    The input string is copied and held by the document. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_strncpy(yyjson_mut_doc *doc,
+                                                     const char *str,
+                                                     size_t len);
+
+
+
+/*==============================================================================
+ * Mutable JSON Array API
+ *============================================================================*/
+
+/** Returns the number of elements in this array.
+    Returns 0 if `arr` is NULL or type is not array. */
+yyjson_api_inline size_t yyjson_mut_arr_size(yyjson_mut_val *arr);
+
+/** Returns the element at the specified position in this array.
+    Returns NULL if array is NULL/empty or the index is out of bounds.
+    @warning This function takes a linear search time. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get(yyjson_mut_val *arr,
+                                                     size_t idx);
+
+/** Returns the first element of this array.
+    Returns NULL if `arr` is NULL/empty or type is not array. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_first(yyjson_mut_val *arr);
+
+/** Returns the last element of this array.
+    Returns NULL if `arr` is NULL/empty or type is not array. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_last(yyjson_mut_val *arr);
+
+
+
+/*==============================================================================
+ * Mutable JSON Array Iterator API
+ *============================================================================*/
+
+/**
+ A mutable JSON array iterator.
+ 
+ @warning You should not modify the array while iterating over it, but you can
+    use `yyjson_mut_arr_iter_remove()` to remove current value.
+ 
+ @par Example
+ @code
+    yyjson_mut_val *val;
+    yyjson_mut_arr_iter iter = yyjson_mut_arr_iter_with(arr);
+    while ((val = yyjson_mut_arr_iter_next(&iter))) {
+        your_func(val);
+        if (your_val_is_unused(val)) {
+            yyjson_mut_arr_iter_remove(&iter);
+        }
+    }
+ @endcode
+ */
+typedef struct yyjson_mut_arr_iter {
+    size_t idx; /**< next value's index */
+    size_t max; /**< maximum index (arr.size) */
+    yyjson_mut_val *cur; /**< current value */
+    yyjson_mut_val *pre; /**< previous value */
+    yyjson_mut_val *arr; /**< the array being iterated */
+} yyjson_mut_arr_iter;
+
+/**
+ Initialize an iterator for this array.
+ 
+ @param arr The array to be iterated over.
+    If this parameter is NULL or not an array, `iter` will be set to empty.
+ @param iter The iterator to be initialized.
+    If this parameter is NULL, the function will fail and return false.
+ @return true if the `iter` has been successfully initialized.
+ 
+ @note The iterator does not need to be destroyed.
+ */
+yyjson_api_inline bool yyjson_mut_arr_iter_init(yyjson_mut_val *arr,
+    yyjson_mut_arr_iter *iter);
+
+/**
+ Create an iterator with an array , same as `yyjson_mut_arr_iter_init()`.
+ 
+ @param arr The array to be iterated over.
+    If this parameter is NULL or not an array, an empty iterator will returned.
+ @return A new iterator for the array.
+ 
+ @note The iterator does not need to be destroyed.
+ */
+yyjson_api_inline yyjson_mut_arr_iter yyjson_mut_arr_iter_with(
+    yyjson_mut_val *arr);
+
+/**
+ Returns whether the iteration has more elements.
+ If `iter` is NULL, this function will return false.
+ */
+yyjson_api_inline bool yyjson_mut_arr_iter_has_next(
+    yyjson_mut_arr_iter *iter);
+
+/**
+ Returns the next element in the iteration, or NULL on end.
+ If `iter` is NULL, this function will return NULL.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_next(
+    yyjson_mut_arr_iter *iter);
+
+/**
+ Removes and returns current element in the iteration.
+ If `iter` is NULL, this function will return NULL.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_remove(
+    yyjson_mut_arr_iter *iter);
+
+/**
+ Macro for iterating over an array.
+ It works like iterator, but with a more intuitive API.
+ 
+ @warning You should not modify the array while iterating over it.
+ 
+ @par Example
+ @code
+    size_t idx, max;
+    yyjson_mut_val *val;
+    yyjson_mut_arr_foreach(arr, idx, max, val) {
+        your_func(idx, val);
+    }
+ @endcode
+ */
+#define yyjson_mut_arr_foreach(arr, idx, max, val) \
+    for ((idx) = 0, \
+        (max) = yyjson_mut_arr_size(arr), \
+        (val) = yyjson_mut_arr_get_first(arr); \
+        (idx) < (max); \
+        (idx)++, \
+        (val) = (val)->next)
+
+
+
+/*==============================================================================
+ * Mutable JSON Array Creation API
+ *============================================================================*/
+
+/**
+ Creates and returns an empty mutable array.
+ @param doc A mutable document, used for memory allocation only.
+ @return The new array. NULL if input is NULL or memory allocation failed.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr(yyjson_mut_doc *doc);
+
+/**
+ Creates and returns a new mutable array with the given boolean values.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of boolean values.
+ @param count The value count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const bool vals[3] = { true, false, true };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_bool(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_bool(
+    yyjson_mut_doc *doc, const bool *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given sint numbers.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of sint numbers.
+ @param count The number count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const int64_t vals[3] = { -1, 0, 1 };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_sint64(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint(
+    yyjson_mut_doc *doc, const int64_t *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given uint numbers.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of uint numbers.
+ @param count The number count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const uint64_t vals[3] = { 0, 1, 0 };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_uint(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint(
+    yyjson_mut_doc *doc, const uint64_t *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given real numbers.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of real numbers.
+ @param count The number count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const double vals[3] = { 0.1, 0.2, 0.3 };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_real(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_real(
+    yyjson_mut_doc *doc, const double *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given int8 numbers.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of int8 numbers.
+ @param count The number count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const int8_t vals[3] = { -1, 0, 1 };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_sint8(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint8(
+    yyjson_mut_doc *doc, const int8_t *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given int16 numbers.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of int16 numbers.
+ @param count The number count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const int16_t vals[3] = { -1, 0, 1 };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_sint16(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint16(
+    yyjson_mut_doc *doc, const int16_t *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given int32 numbers.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of int32 numbers.
+ @param count The number count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const int32_t vals[3] = { -1, 0, 1 };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_sint32(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint32(
+    yyjson_mut_doc *doc, const int32_t *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given int64 numbers.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of int64 numbers.
+ @param count The number count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const int64_t vals[3] = { -1, 0, 1 };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_sint64(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint64(
+    yyjson_mut_doc *doc, const int64_t *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given uint8 numbers.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of uint8 numbers.
+ @param count The number count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const uint8_t vals[3] = { 0, 1, 0 };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_uint8(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint8(
+    yyjson_mut_doc *doc, const uint8_t *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given uint16 numbers.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of uint16 numbers.
+ @param count The number count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const uint16_t vals[3] = { 0, 1, 0 };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_uint16(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint16(
+    yyjson_mut_doc *doc, const uint16_t *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given uint32 numbers.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of uint32 numbers.
+ @param count The number count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const uint32_t vals[3] = { 0, 1, 0 };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_uint32(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint32(
+    yyjson_mut_doc *doc, const uint32_t *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given uint64 numbers.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of uint64 numbers.
+ @param count The number count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+     const uint64_t vals[3] = { 0, 1, 0 };
+     yyjson_mut_val *arr = yyjson_mut_arr_with_uint64(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint64(
+    yyjson_mut_doc *doc, const uint64_t *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given float numbers.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of float numbers.
+ @param count The number count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const float vals[3] = { -1.0f, 0.0f, 1.0f };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_float(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_float(
+    yyjson_mut_doc *doc, const float *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given double numbers.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of double numbers.
+ @param count The number count. If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const double vals[3] = { -1.0, 0.0, 1.0 };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_double(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_double(
+    yyjson_mut_doc *doc, const double *vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given strings, these strings
+ will not be copied.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of UTF-8 null-terminator strings.
+    If this array contains NULL, the function will fail and return NULL.
+ @param count The number of values in `vals`.
+    If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @warning The input strings are not copied, you should keep these strings
+    unmodified for the lifetime of this JSON document. If these strings will be
+    modified, you should use `yyjson_mut_arr_with_strcpy()` instead.
+ 
+ @par Example
+ @code
+    const char *vals[3] = { "a", "b", "c" };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_str(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_str(
+    yyjson_mut_doc *doc, const char **vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given strings and string
+ lengths, these strings will not be copied.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of UTF-8 strings, null-terminator is not required.
+    If this array contains NULL, the function will fail and return NULL.
+ @param lens A C array of string lengths, in bytes.
+ @param count The number of strings in `vals`.
+    If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @warning The input strings are not copied, you should keep these strings
+    unmodified for the lifetime of this JSON document. If these strings will be
+    modified, you should use `yyjson_mut_arr_with_strncpy()` instead.
+ 
+ @par Example
+ @code
+    const char *vals[3] = { "a", "bb", "c" };
+    const size_t lens[3] = { 1, 2, 1 };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_strn(doc, vals, lens, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strn(
+    yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given strings, these strings
+ will be copied.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of UTF-8 null-terminator strings.
+    If this array contains NULL, the function will fail and return NULL.
+ @param count The number of values in `vals`.
+    If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const char *vals[3] = { "a", "b", "c" };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_strcpy(doc, vals, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strcpy(
+    yyjson_mut_doc *doc, const char **vals, size_t count);
+
+/**
+ Creates and returns a new mutable array with the given strings and string
+ lengths, these strings will be copied.
+ 
+ @param doc A mutable document, used for memory allocation only.
+    If this parameter is NULL, the function will fail and return NULL.
+ @param vals A C array of UTF-8 strings, null-terminator is not required.
+    If this array contains NULL, the function will fail and return NULL.
+ @param lens A C array of string lengths, in bytes.
+ @param count The number of strings in `vals`.
+    If this value is 0, an empty array will return.
+ @return The new array. NULL if input is invalid or memory allocation failed.
+ 
+ @par Example
+ @code
+    const char *vals[3] = { "a", "bb", "c" };
+    const size_t lens[3] = { 1, 2, 1 };
+    yyjson_mut_val *arr = yyjson_mut_arr_with_strn(doc, vals, lens, 3);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strncpy(
+    yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count);
+
+
+
+/*==============================================================================
+ * Mutable JSON Array Modification API
+ *============================================================================*/
+
+/**
+ Inserts a value into an array at a given index.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @param val The value to be inserted. Returns false if it is NULL.
+ @param idx The index to which to insert the new value.
+    Returns false if the index is out of range.
+ @return Whether successful.
+ @warning This function takes a linear search time.
+ */
+yyjson_api_inline bool yyjson_mut_arr_insert(yyjson_mut_val *arr,
+                                             yyjson_mut_val *val, size_t idx);
+
+/**
+ Inserts a value at the end of the array.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @param val The value to be inserted. Returns false if it is NULL.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_append(yyjson_mut_val *arr,
+                                             yyjson_mut_val *val);
+
+/**
+ Inserts a value at the head of the array.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @param val The value to be inserted. Returns false if it is NULL.
+ @return    Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_prepend(yyjson_mut_val *arr,
+                                              yyjson_mut_val *val);
+
+/**
+ Replaces a value at index and returns old value.
+ @param arr The array to which the value is to be replaced.
+    Returns false if it is NULL or not an array.
+ @param idx The index to which to replace the value.
+    Returns false if the index is out of range.
+ @param val The new value to replace. Returns false if it is NULL.
+ @return Old value, or NULL on error.
+ @warning This function takes a linear search time.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_replace(yyjson_mut_val *arr,
+                                                         size_t idx,
+                                                         yyjson_mut_val *val);
+
+/**
+ Removes and returns a value at index.
+ @param arr The array from which the value is to be removed.
+    Returns false if it is NULL or not an array.
+ @param idx The index from which to remove the value.
+    Returns false if the index is out of range.
+ @return Old value, or NULL on error.
+ @warning This function takes a linear search time.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove(yyjson_mut_val *arr,
+                                                        size_t idx);
+
+/**
+ Removes and returns the first value in this array.
+ @param arr The array from which the value is to be removed.
+    Returns false if it is NULL or not an array.
+ @return The first value, or NULL on error.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_first(
+    yyjson_mut_val *arr);
+
+/**
+ Removes and returns the last value in this array.
+ @param arr The array from which the value is to be removed.
+    Returns false if it is NULL or not an array.
+ @return The last value, or NULL on error.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_last(
+    yyjson_mut_val *arr);
+
+/**
+ Removes all values within a specified range in the array.
+ @param arr The array from which the value is to be removed.
+    Returns false if it is NULL or not an array.
+ @param idx The start index of the range (0 is the first).
+ @param len The number of items in the range (can be 0).
+ @return Whether successful.
+ @warning This function takes a linear search time.
+ */
+yyjson_api_inline bool yyjson_mut_arr_remove_range(yyjson_mut_val *arr,
+                                                   size_t idx, size_t len);
+
+/**
+ Removes all values in this array.
+ @param arr The array from which all of the values are to be removed.
+    Returns false if it is NULL or not an array.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_clear(yyjson_mut_val *arr);
+
+/**
+ Rotates values in this array for the given number of times.
+ For example: `[1,2,3,4,5]` rotate 2 is `[3,4,5,1,2]`.
+ @param arr The array to be rotated.
+ @param idx Index (or times) to rotate.
+ @warning This function takes a linear search time.
+ */
+yyjson_api_inline bool yyjson_mut_arr_rotate(yyjson_mut_val *arr,
+                                             size_t idx);
+
+
+
+/*==============================================================================
+ * Mutable JSON Array Modification Convenience API
+ *============================================================================*/
+
+/**
+ Adds a value at the end of the array.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @param val The value to be inserted. Returns false if it is NULL.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_add_val(yyjson_mut_val *arr,
+                                              yyjson_mut_val *val);
+
+/**
+ Adds a `null` value at the end of the array.
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_add_null(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr);
+
+/**
+ Adds a `true` value at the end of the array.
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_add_true(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr);
+
+/**
+ Adds a `false` value at the end of the array.
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_add_false(yyjson_mut_doc *doc,
+                                                yyjson_mut_val *arr);
+
+/**
+ Adds a bool value at the end of the array.
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @param val The bool value to be added.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_add_bool(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr,
+                                               bool val);
+
+/**
+ Adds an unsigned integer value at the end of the array.
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @param num The number to be added.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_add_uint(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr,
+                                               uint64_t num);
+
+/**
+ Adds a signed integer value at the end of the array.
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @param num The number to be added.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_add_sint(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr,
+                                               int64_t num);
+
+/**
+ Adds a integer value at the end of the array.
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @param num The number to be added.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_add_int(yyjson_mut_doc *doc,
+                                              yyjson_mut_val *arr,
+                                              int64_t num);
+
+/**
+ Adds a double value at the end of the array.
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @param num The number to be added.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_add_real(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr,
+                                               double num);
+
+/**
+ Adds a string value at the end of the array (no copy).
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @param str A null-terminated UTF-8 string.
+ @return Whether successful.
+ @warning The input string is not copied, you should keep this string unmodified
+    for the lifetime of this JSON document.
+ */
+yyjson_api_inline bool yyjson_mut_arr_add_str(yyjson_mut_doc *doc,
+                                              yyjson_mut_val *arr,
+                                              const char *str);
+
+/**
+ Adds a string value at the end of the array (no copy).
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @param str A UTF-8 string, null-terminator is not required.
+ @param len The length of the string, in bytes.
+ @return Whether successful.
+ @warning The input string is not copied, you should keep this string unmodified
+    for the lifetime of this JSON document.
+ */
+yyjson_api_inline bool yyjson_mut_arr_add_strn(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr,
+                                               const char *str,
+                                               size_t len);
+
+/**
+ Adds a string value at the end of the array (copied).
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @param str A null-terminated UTF-8 string.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_add_strcpy(yyjson_mut_doc *doc,
+                                                 yyjson_mut_val *arr,
+                                                 const char *str);
+
+/**
+ Adds a string value at the end of the array (copied).
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @param str A UTF-8 string, null-terminator is not required.
+ @param len The length of the string, in bytes.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_arr_add_strncpy(yyjson_mut_doc *doc,
+                                                  yyjson_mut_val *arr,
+                                                  const char *str,
+                                                  size_t len);
+
+/**
+ Creates and adds a new array at the end of the array.
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @return The new array, or NULL on error.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_arr(yyjson_mut_doc *doc,
+                                                         yyjson_mut_val *arr);
+
+/**
+ Creates and adds a new object at the end of the array.
+ @param doc The `doc` is only used for memory allocation.
+ @param arr The array to which the value is to be inserted.
+    Returns false if it is NULL or not an array.
+ @return The new object, or NULL on error.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_obj(yyjson_mut_doc *doc,
+                                                         yyjson_mut_val *arr);
+
+
+
+/*==============================================================================
+ * Mutable JSON Object API
+ *============================================================================*/
+
+/** Returns the number of key-value pairs in this object.
+    Returns 0 if `obj` is NULL or type is not object. */
+yyjson_api_inline size_t yyjson_mut_obj_size(yyjson_mut_val *obj);
+
+/** Returns the value to which the specified key is mapped.
+    Returns NULL if this object contains no mapping for the key.
+    Returns NULL if `obj/key` is NULL, or type is not object.
+    
+    The `key` should be a null-terminated UTF-8 string.
+    
+    @warning This function takes a linear search time. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_get(yyjson_mut_val *obj,
+                                                     const char *key);
+
+/** Returns the value to which the specified key is mapped.
+    Returns NULL if this object contains no mapping for the key.
+    Returns NULL if `obj/key` is NULL, or type is not object.
+    
+    The `key` should be a UTF-8 string, null-terminator is not required.
+    The `key_len` should be the length of the key, in bytes.
+    
+    @warning This function takes a linear search time. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_getn(yyjson_mut_val *obj,
+                                                      const char *key,
+                                                      size_t key_len);
+
+
+
+/*==============================================================================
+ * Mutable JSON Object Iterator API
+ *============================================================================*/
+
+/**
+ A mutable JSON object iterator.
+ 
+ @warning You should not modify the object while iterating over it, but you can
+    use `yyjson_mut_obj_iter_remove()` to remove current value.
+ 
+ @par Example
+ @code
+    yyjson_mut_val *key, *val;
+    yyjson_mut_obj_iter iter = yyjson_mut_obj_iter_with(obj);
+    while ((key = yyjson_mut_obj_iter_next(&iter))) {
+        val = yyjson_mut_obj_iter_get_val(key);
+        your_func(key, val);
+        if (your_val_is_unused(key, val)) {
+            yyjson_mut_obj_iter_remove(&iter);
+        }
+    }
+ @endcode
+ 
+ If the ordering of the keys is known at compile-time, you can use this method
+ to speed up value lookups:
+ @code
+    // {"k1":1, "k2": 3, "k3": 3}
+    yyjson_mut_val *key, *val;
+    yyjson_mut_obj_iter iter = yyjson_mut_obj_iter_with(obj);
+    yyjson_mut_val *v1 = yyjson_mut_obj_iter_get(&iter, "k1");
+    yyjson_mut_val *v3 = yyjson_mut_obj_iter_get(&iter, "k3");
+ @endcode
+ @see `yyjson_mut_obj_iter_get()` and `yyjson_mut_obj_iter_getn()`
+ */
+typedef struct yyjson_mut_obj_iter {
+    size_t idx; /**< next key's index */
+    size_t max; /**< maximum key index (obj.size) */
+    yyjson_mut_val *cur; /**< current key */
+    yyjson_mut_val *pre; /**< previous key */
+    yyjson_mut_val *obj; /**< the object being iterated */
+} yyjson_mut_obj_iter;
+
+/**
+ Initialize an iterator for this object.
+ 
+ @param obj The object to be iterated over.
+    If this parameter is NULL or not an array, `iter` will be set to empty.
+ @param iter The iterator to be initialized.
+    If this parameter is NULL, the function will fail and return false.
+ @return true if the `iter` has been successfully initialized.
+ 
+ @note The iterator does not need to be destroyed.
+ */
+yyjson_api_inline bool yyjson_mut_obj_iter_init(yyjson_mut_val *obj,
+    yyjson_mut_obj_iter *iter);
+
+/**
+ Create an iterator with an object, same as `yyjson_obj_iter_init()`.
+ 
+ @param obj The object to be iterated over.
+    If this parameter is NULL or not an object, an empty iterator will returned.
+ @return A new iterator for the object.
+ 
+ @note The iterator does not need to be destroyed.
+ */
+yyjson_api_inline yyjson_mut_obj_iter yyjson_mut_obj_iter_with(
+    yyjson_mut_val *obj);
+
+/**
+ Returns whether the iteration has more elements.
+ If `iter` is NULL, this function will return false.
+ */
+yyjson_api_inline bool yyjson_mut_obj_iter_has_next(
+    yyjson_mut_obj_iter *iter);
+
+/**
+ Returns the next key in the iteration, or NULL on end.
+ If `iter` is NULL, this function will return NULL.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_next(
+    yyjson_mut_obj_iter *iter);
+
+/**
+ Returns the value for key inside the iteration.
+ If `iter` is NULL, this function will return NULL.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get_val(
+    yyjson_mut_val *key);
+
+/**
+ Removes current key-value pair in the iteration, returns the removed value.
+ If `iter` is NULL, this function will return NULL.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_remove(
+    yyjson_mut_obj_iter *iter);
+
+/**
+ Iterates to a specified key and returns the value.
+ 
+ This function does the same thing as `yyjson_mut_obj_get()`, but is much faster
+ if the ordering of the keys is known at compile-time and you are using the same
+ order to look up the values. If the key exists in this object, then the
+ iterator will stop at the next key, otherwise the iterator will not change and
+ NULL is returned.
+ 
+ @param iter The object iterator, should not be NULL.
+ @param key The key, should be a UTF-8 string with null-terminator.
+ @return The value to which the specified key is mapped.
+    NULL if this object contains no mapping for the key or input is invalid.
+ 
+ @warning This function takes a linear search time if the key is not nearby.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get(
+    yyjson_mut_obj_iter *iter, const char *key);
+
+/**
+ Iterates to a specified key and returns the value.
+ 
+ This function does the same thing as `yyjson_mut_obj_getn()` but is much faster
+ if the ordering of the keys is known at compile-time and you are using the same
+ order to look up the values. If the key exists in this object, then the
+ iterator will stop at the next key, otherwise the iterator will not change and
+ NULL is returned.
+ 
+ @param iter The object iterator, should not be NULL.
+ @param key The key, should be a UTF-8 string, null-terminator is not required.
+ @param key_len The the length of `key`, in bytes.
+ @return The value to which the specified key is mapped.
+    NULL if this object contains no mapping for the key or input is invalid.
+ 
+ @warning This function takes a linear search time if the key is not nearby.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_getn(
+    yyjson_mut_obj_iter *iter, const char *key, size_t key_len);
+
+/**
+ Macro for iterating over an object.
+ It works like iterator, but with a more intuitive API.
+ 
+ @warning You should not modify the object while iterating over it.
+ 
+ @par Example
+ @code
+    size_t idx, max;
+    yyjson_val *key, *val;
+    yyjson_obj_foreach(obj, idx, max, key, val) {
+        your_func(key, val);
+    }
+ @endcode
+ */
+#define yyjson_mut_obj_foreach(obj, idx, max, key, val) \
+    for ((idx) = 0, \
+        (max) = yyjson_mut_obj_size(obj), \
+        (key) = (max) ? ((yyjson_mut_val *)(obj)->uni.ptr)->next->next : NULL, \
+        (val) = (key) ? (key)->next : NULL; \
+        (idx) < (max); \
+        (idx)++, \
+        (key) = (val)->next, \
+        (val) = (key)->next)
+
+
+
+/*==============================================================================
+ * Mutable JSON Object Creation API
+ *============================================================================*/
+
+/** Creates and returns a mutable object, returns NULL on error. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj(yyjson_mut_doc *doc);
+
+/**
+ Creates and returns a mutable object with keys and values, returns NULL on
+ error. The keys and values are not copied. The strings should be a
+ null-terminated UTF-8 string.
+ 
+ @warning The input string is not copied, you should keep this string
+    unmodified for the lifetime of this JSON document.
+ 
+ @par Example
+ @code
+    const char *keys[2] = { "id", "name" };
+    const char *vals[2] = { "01", "Harry" };
+    yyjson_mut_val *obj = yyjson_mut_obj_with_str(doc, keys, vals, 2);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_str(yyjson_mut_doc *doc,
+                                                          const char **keys,
+                                                          const char **vals,
+                                                          size_t count);
+
+/**
+ Creates and returns a mutable object with key-value pairs and pair count,
+ returns NULL on error. The keys and values are not copied. The strings should
+ be a null-terminated UTF-8 string.
+ 
+ @warning The input string is not copied, you should keep this string
+    unmodified for the lifetime of this JSON document.
+ 
+ @par Example
+ @code
+    const char *kv_pairs[4] = { "id", "01", "name", "Harry" };
+    yyjson_mut_val *obj = yyjson_mut_obj_with_kv(doc, kv_pairs, 2);
+ @endcode
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_kv(yyjson_mut_doc *doc,
+                                                         const char **kv_pairs,
+                                                         size_t pair_count);
+
+
+
+/*==============================================================================
+ * Mutable JSON Object Modification API
+ *============================================================================*/
+
+/**
+ Adds a key-value pair at the end of the object.
+ This function allows duplicated key in one object.
+ @param obj The object to which the new key-value pair is to be added.
+ @param key The key, should be a string which is created by `yyjson_mut_str()`,
+    `yyjson_mut_strn()`, `yyjson_mut_strcpy()` or `yyjson_mut_strncpy()`.
+ @param val The value to add to the object.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_obj_add(yyjson_mut_val *obj,
+                                          yyjson_mut_val *key,
+                                          yyjson_mut_val *val);
+/**
+ Sets a key-value pair at the end of the object.
+ This function may remove all key-value pairs for the given key before add.
+ @param obj The object to which the new key-value pair is to be added.
+ @param key The key, should be a string which is created by `yyjson_mut_str()`,
+    `yyjson_mut_strn()`, `yyjson_mut_strcpy()` or `yyjson_mut_strncpy()`.
+ @param val The value to add to the object. If this value is null, the behavior
+    is same as `yyjson_mut_obj_remove()`.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_obj_put(yyjson_mut_val *obj,
+                                          yyjson_mut_val *key,
+                                          yyjson_mut_val *val);
+
+/**
+ Inserts a key-value pair to the object at the given position.
+ This function allows duplicated key in one object.
+ @param obj The object to which the new key-value pair is to be added.
+ @param key The key, should be a string which is created by `yyjson_mut_str()`,
+    `yyjson_mut_strn()`, `yyjson_mut_strcpy()` or `yyjson_mut_strncpy()`.
+ @param val The value to add to the object.
+ @param idx The index to which to insert the new pair.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_obj_insert(yyjson_mut_val *obj,
+                                             yyjson_mut_val *key,
+                                             yyjson_mut_val *val,
+                                             size_t idx);
+
+/**
+ Removes all key-value pair from the object with given key.
+ @param obj The object from which the key-value pair is to be removed.
+ @param key The key, should be a string value.
+ @return The first matched value, or NULL if no matched value.
+ @warning This function takes a linear search time.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove(yyjson_mut_val *obj,
+                                                        yyjson_mut_val *key);
+
+/**
+ Removes all key-value pair from the object with given key.
+ @param obj The object from which the key-value pair is to be removed.
+ @param key The key, should be a UTF-8 string with null-terminator.
+ @return The first matched value, or NULL if no matched value.
+ @warning This function takes a linear search time.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_key(
+    yyjson_mut_val *obj, const char *key);
+
+/**
+ Removes all key-value pair from the object with given key.
+ @param obj The object from which the key-value pair is to be removed.
+ @param key The key, should be a UTF-8 string, null-terminator is not required.
+ @param key_len The length of the key.
+ @return The first matched value, or NULL if no matched value.
+ @warning This function takes a linear search time.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_keyn(
+    yyjson_mut_val *obj, const char *key, size_t key_len);
+
+/**
+ Removes all key-value pairs in this object.
+ @param obj The object from which all of the values are to be removed.
+ @return Whether successful.
+ */
+yyjson_api_inline bool yyjson_mut_obj_clear(yyjson_mut_val *obj);
+
+/**
+ Replaces value from the object with given key.
+ If the key is not exist, or the value is NULL, it will fail.
+ @param obj The object to which the value is to be replaced.
+ @param key The key, should be a string value.
+ @param val The value to replace into the object.
+ @return Whether successful.
+ @warning This function takes a linear search time.
+ */
+yyjson_api_inline bool yyjson_mut_obj_replace(yyjson_mut_val *obj,
+                                              yyjson_mut_val *key,
+                                              yyjson_mut_val *val);
+
+/**
+ Rotates key-value pairs in the object for the given number of times.
+ For example: `{"a":1,"b":2,"c":3,"d":4}` rotate 1 is
+ `{"b":2,"c":3,"d":4,"a":1}`.
+ @param obj The object to be rotated.
+ @param idx Index (or times) to rotate.
+ @return Whether successful.
+ @warning This function takes a linear search time.
+ */
+yyjson_api_inline bool yyjson_mut_obj_rotate(yyjson_mut_val *obj,
+                                             size_t idx);
+
+
+
+/*==============================================================================
+ * Mutable JSON Object Modification Convenience API
+ *============================================================================*/
+
+/** Adds a `null` value at the end of the object.
+    The `key` should be a null-terminated UTF-8 string.
+    This function allows duplicated key in one object.
+    
+    @warning The key string are not copied, you should keep the string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline bool yyjson_mut_obj_add_null(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *key);
+
+/** Adds a `true` value at the end of the object.
+    The `key` should be a null-terminated UTF-8 string.
+    This function allows duplicated key in one object.
+    
+    @warning The key string are not copied, you should keep the string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline bool yyjson_mut_obj_add_true(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *key);
+
+/** Adds a `false` value at the end of the object.
+    The `key` should be a null-terminated UTF-8 string.
+    This function allows duplicated key in one object.
+    
+    @warning The key string are not copied, you should keep the string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline bool yyjson_mut_obj_add_false(yyjson_mut_doc *doc,
+                                                yyjson_mut_val *obj,
+                                                const char *key);
+
+/** Adds a bool value at the end of the object.
+    The `key` should be a null-terminated UTF-8 string.
+    This function allows duplicated key in one object.
+    
+    @warning The key string are not copied, you should keep the string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline bool yyjson_mut_obj_add_bool(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *key, bool val);
+
+/** Adds an unsigned integer value at the end of the object.
+    The `key` should be a null-terminated UTF-8 string.
+    This function allows duplicated key in one object.
+    
+    @warning The key string are not copied, you should keep the string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline bool yyjson_mut_obj_add_uint(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *key, uint64_t val);
+
+/** Adds a signed integer value at the end of the object.
+    The `key` should be a null-terminated UTF-8 string.
+    This function allows duplicated key in one object.
+    
+    @warning The key string are not copied, you should keep the string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline bool yyjson_mut_obj_add_sint(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *key, int64_t val);
+
+/** Adds an int value at the end of the object.
+    The `key` should be a null-terminated UTF-8 string.
+    This function allows duplicated key in one object.
+    
+    @warning The key string are not copied, you should keep the string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline bool yyjson_mut_obj_add_int(yyjson_mut_doc *doc,
+                                              yyjson_mut_val *obj,
+                                              const char *key, int64_t val);
+
+/** Adds a double value at the end of the object.
+    The `key` should be a null-terminated UTF-8 string.
+    This function allows duplicated key in one object.
+    
+    @warning The key string are not copied, you should keep the string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline bool yyjson_mut_obj_add_real(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *key, double val);
+
+/** Adds a string value at the end of the object.
+    The `key` and `val` should be null-terminated UTF-8 strings.
+    This function allows duplicated key in one object.
+    
+    @warning The key/value string are not copied, you should keep these strings
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline bool yyjson_mut_obj_add_str(yyjson_mut_doc *doc,
+                                              yyjson_mut_val *obj,
+                                              const char *key, const char *val);
+
+/** Adds a string value at the end of the object.
+    The `key` should be a null-terminated UTF-8 string.
+    The `val` should be a UTF-8 string, null-terminator is not required.
+    The `len` should be the length of the `val`, in bytes.
+    This function allows duplicated key in one object.
+    
+    @warning The key/value string are not copied, you should keep these strings
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline bool yyjson_mut_obj_add_strn(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *key,
+                                               const char *val, size_t len);
+
+/** Adds a string value at the end of the object.
+    The `key` and `val` should be null-terminated UTF-8 strings.
+    The value string is copied.
+    This function allows duplicated key in one object.
+    
+    @warning The key string are not copied, you should keep the string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline bool yyjson_mut_obj_add_strcpy(yyjson_mut_doc *doc,
+                                                 yyjson_mut_val *obj,
+                                                 const char *key,
+                                                 const char *val);
+
+/** Adds a string value at the end of the object.
+    The `key` should be a null-terminated UTF-8 string.
+    The `val` should be a UTF-8 string, null-terminator is not required.
+    The `len` should be the length of the `val`, in bytes.
+    This function allows duplicated key in one object.
+    
+    @warning The key/value string are not copied, you should keep these strings
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline bool yyjson_mut_obj_add_strncpy(yyjson_mut_doc *doc,
+                                                  yyjson_mut_val *obj,
+                                                  const char *key,
+                                                  const char *val, size_t len);
+
+/** Adds a JSON value at the end of the object.
+    The `key` should be a null-terminated UTF-8 string.
+    This function allows duplicated key in one object.
+    
+    @warning The key string are not copied, you should keep the string
+        unmodified for the lifetime of this JSON document. */
+yyjson_api_inline bool yyjson_mut_obj_add_val(yyjson_mut_doc *doc,
+                                              yyjson_mut_val *obj,
+                                              const char *key,
+                                              yyjson_mut_val *val);
+
+/** Removes all key-value pairs for the given key.
+    Returns the first value to which the specified key is mapped or NULL if this
+    object contains no mapping for the key.
+    The `key` should be a null-terminated UTF-8 string.
+    
+    @warning This function takes a linear search time. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_str(
+    yyjson_mut_val *obj, const char *key);
+
+/** Removes all key-value pairs for the given key.
+    Returns the first value to which the specified key is mapped or NULL if this
+    object contains no mapping for the key.
+    The `key` should be a UTF-8 string, null-terminator is not required.
+    The `len` should be the length of the key, in bytes.
+    
+    @warning This function takes a linear search time. */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_strn(
+    yyjson_mut_val *obj, const char *key, size_t len);
+
+/** Replaces all matching keys with the new key.
+    Returns true if at least one key was renamed.
+    The `key` and `new_key` should be a null-terminated UTF-8 string.
+    The `new_key` is copied and held by doc.
+    
+    @warning This function takes a linear search time.
+    If `new_key` already exists, it will cause duplicate keys.
+ */
+yyjson_api_inline bool yyjson_mut_obj_rename_key(yyjson_mut_doc *doc,
+                                                 yyjson_mut_val *obj,
+                                                 const char *key,
+                                                 const char *new_key);
+
+/** Replaces all matching keys with the new key.
+    Returns true if at least one key was renamed.
+    The `key` and `new_key` should be a UTF-8 string,
+    null-terminator is not required. The `new_key` is copied and held by doc.
+    
+    @warning This function takes a linear search time.
+    If `new_key` already exists, it will cause duplicate keys.
+ */
+yyjson_api_inline bool yyjson_mut_obj_rename_keyn(yyjson_mut_doc *doc,
+                                                  yyjson_mut_val *obj,
+                                                  const char *key,
+                                                  size_t len,
+                                                  const char *new_key,
+                                                  size_t new_len);
+
+
+
+/*==============================================================================
+ * JSON Pointer API (RFC 6901)
+ * https://tools.ietf.org/html/rfc6901
+ *============================================================================*/
+
+/** JSON Pointer error code. */
+typedef uint32_t yyjson_ptr_code;
+
+/** No JSON pointer error. */
+static const yyjson_ptr_code YYJSON_PTR_ERR_NONE = 0;
+
+/** Invalid input parameter, such as NULL input. */
+static const yyjson_ptr_code YYJSON_PTR_ERR_PARAMETER = 1;
+
+/** JSON pointer syntax error, such as invalid escape, token no prefix. */
+static const yyjson_ptr_code YYJSON_PTR_ERR_SYNTAX = 2;
+
+/** JSON pointer resolve failed, such as index out of range, key not found. */
+static const yyjson_ptr_code YYJSON_PTR_ERR_RESOLVE = 3;
+
+/** Document's root is NULL, but it is required for the function call. */
+static const yyjson_ptr_code YYJSON_PTR_ERR_NULL_ROOT = 4;
+
+/** Cannot set root as the target is not a document. */
+static const yyjson_ptr_code YYJSON_PTR_ERR_SET_ROOT = 5;
+
+/** The memory allocation failed and a new value could not be created. */
+static const yyjson_ptr_code YYJSON_PTR_ERR_MEMORY_ALLOCATION = 6;
+
+/** Error information for JSON pointer. */
+typedef struct yyjson_ptr_err {
+    /** Error code, see `yyjson_ptr_code` for all possible values. */
+    yyjson_ptr_code code;
+    /** Error message, constant, no need to free (NULL if no error). */
+    const char *msg;
+    /** Error byte position for input JSON pointer (0 if no error). */
+    size_t pos;
+} yyjson_ptr_err;
+
+/**
+ A context for JSON pointer operation.
+ 
+ This struct stores the context of JSON Pointer operation result. The struct
+ can be used with three helper functions: `ctx_append()`, `ctx_replace()`, and
+ `ctx_remove()`, which perform the corresponding operations on the container
+ without re-parsing the JSON Pointer.
+ 
+ For example:
+ @code
+    // doc before: {"a":[0,1,null]}
+    // ptr: "/a/2"
+    val = yyjson_mut_doc_ptr_getx(doc, ptr, strlen(ptr), &ctx, &err);
+    if (yyjson_is_null(val)) {
+        yyjson_ptr_ctx_remove(&ctx);
+    }
+    // doc after: {"a":[0,1]}
+ @endcode
+ */
+typedef struct yyjson_ptr_ctx {
+    /**
+     The container (parent) of the target value. It can be either an array or
+     an object. If the target location has no value, but all its parent
+     containers exist, and the target location can be used to insert a new
+     value, then `ctn` is the parent container of the target location.
+     Otherwise, `ctn` is NULL.
+     */
+    yyjson_mut_val *ctn;
+    /**
+     The previous sibling of the target value. It can be either a value in an
+     array or a key in an object. As the container is a `circular linked list`
+     of elements, `pre` is the previous node of the target value. If the
+     operation is `add` or `set`, then `pre` is the previous node of the new
+     value, not the original target value. If the target value does not exist,
+     `pre` is NULL.
+     */
+    yyjson_mut_val *pre;
+    /**
+     The removed value if the operation is `set`, `replace` or `remove`. It can
+     be used to restore the original state of the document if needed.
+     */
+    yyjson_mut_val *old;
+} yyjson_ptr_ctx;
+
+/**
+ Get value by a JSON Pointer.
+ @param doc The JSON document to be queried.
+ @param ptr The JSON pointer string (UTF-8 with null-terminator).
+ @return The value referenced by the JSON pointer.
+    NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
+ */
+yyjson_api_inline yyjson_val *yyjson_doc_ptr_get(yyjson_doc *doc,
+                                                 const char *ptr);
+
+/**
+ Get value by a JSON Pointer.
+ @param doc The JSON document to be queried.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @return The value referenced by the JSON pointer.
+    NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
+ */
+yyjson_api_inline yyjson_val *yyjson_doc_ptr_getn(yyjson_doc *doc,
+                                                  const char *ptr, size_t len);
+
+/**
+ Get value by a JSON Pointer.
+ @param doc The JSON document to be queried.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param err A pointer to store the error information, or NULL if not needed.
+ @return The value referenced by the JSON pointer.
+    NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
+ */
+yyjson_api_inline yyjson_val *yyjson_doc_ptr_getx(yyjson_doc *doc,
+                                                  const char *ptr, size_t len,
+                                                  yyjson_ptr_err *err);
+
+/**
+ Get value by a JSON Pointer.
+ @param val The JSON value to be queried.
+ @param ptr The JSON pointer string (UTF-8 with null-terminator).
+ @return The value referenced by the JSON pointer.
+    NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
+ */
+yyjson_api_inline yyjson_val *yyjson_ptr_get(yyjson_val *val,
+                                             const char *ptr);
+
+/**
+ Get value by a JSON Pointer.
+ @param val The JSON value to be queried.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @return The value referenced by the JSON pointer.
+    NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
+ */
+yyjson_api_inline yyjson_val *yyjson_ptr_getn(yyjson_val *val,
+                                              const char *ptr, size_t len);
+
+/**
+ Get value by a JSON Pointer.
+ @param val The JSON value to be queried.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param err A pointer to store the error information, or NULL if not needed.
+ @return The value referenced by the JSON pointer.
+    NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
+ */
+yyjson_api_inline yyjson_val *yyjson_ptr_getx(yyjson_val *val,
+                                              const char *ptr, size_t len,
+                                              yyjson_ptr_err *err);
+
+/**
+ Get value by a JSON Pointer.
+ @param doc The JSON document to be queried.
+ @param ptr The JSON pointer string (UTF-8 with null-terminator).
+ @return The value referenced by the JSON pointer.
+    NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_get(yyjson_mut_doc *doc,
+                                                         const char *ptr);
+
+/**
+ Get value by a JSON Pointer.
+ @param doc The JSON document to be queried.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @return The value referenced by the JSON pointer.
+    NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_getn(yyjson_mut_doc *doc,
+                                                          const char *ptr,
+                                                          size_t len);
+
+/**
+ Get value by a JSON Pointer.
+ @param doc The JSON document to be queried.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param ctx A pointer to store the result context, or NULL if not needed.
+ @param err A pointer to store the error information, or NULL if not needed.
+ @return The value referenced by the JSON pointer.
+    NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_getx(yyjson_mut_doc *doc,
+                                                          const char *ptr,
+                                                          size_t len,
+                                                          yyjson_ptr_ctx *ctx,
+                                                          yyjson_ptr_err *err);
+
+/**
+ Get value by a JSON Pointer.
+ @param val The JSON value to be queried.
+ @param ptr The JSON pointer string (UTF-8 with null-terminator).
+ @return The value referenced by the JSON pointer.
+    NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_get(yyjson_mut_val *val,
+                                                     const char *ptr);
+
+/**
+ Get value by a JSON Pointer.
+ @param val The JSON value to be queried.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @return The value referenced by the JSON pointer.
+    NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_getn(yyjson_mut_val *val,
+                                                      const char *ptr,
+                                                      size_t len);
+
+/**
+ Get value by a JSON Pointer.
+ @param val The JSON value to be queried.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param ctx A pointer to store the result context, or NULL if not needed.
+ @param err A pointer to store the error information, or NULL if not needed.
+ @return The value referenced by the JSON pointer.
+    NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_getx(yyjson_mut_val *val,
+                                                      const char *ptr,
+                                                      size_t len,
+                                                      yyjson_ptr_ctx *ctx,
+                                                      yyjson_ptr_err *err);
+
+/**
+ Add (insert) value by a JSON pointer.
+ @param doc The target JSON document.
+ @param ptr The JSON pointer string (UTF-8 with null-terminator).
+ @param new_val The value to be added.
+ @return true if JSON pointer is valid and new value is added, false otherwise.
+ @note The parent nodes will be created if they do not exist.
+ */
+yyjson_api_inline bool yyjson_mut_doc_ptr_add(yyjson_mut_doc *doc,
+                                              const char *ptr,
+                                              yyjson_mut_val *new_val);
+
+/**
+ Add (insert) value by a JSON pointer.
+ @param doc The target JSON document.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param new_val The value to be added.
+ @return true if JSON pointer is valid and new value is added, false otherwise.
+ @note The parent nodes will be created if they do not exist.
+ */
+yyjson_api_inline bool yyjson_mut_doc_ptr_addn(yyjson_mut_doc *doc,
+                                               const char *ptr, size_t len,
+                                               yyjson_mut_val *new_val);
+
+/**
+ Add (insert) value by a JSON pointer.
+ @param doc The target JSON document.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param new_val The value to be added.
+ @param create_parent Whether to create parent nodes if not exist.
+ @param ctx A pointer to store the result context, or NULL if not needed.
+ @param err A pointer to store the error information, or NULL if not needed.
+ @return true if JSON pointer is valid and new value is added, false otherwise.
+ */
+yyjson_api_inline bool yyjson_mut_doc_ptr_addx(yyjson_mut_doc *doc,
+                                               const char *ptr, size_t len,
+                                               yyjson_mut_val *new_val,
+                                               bool create_parent,
+                                               yyjson_ptr_ctx *ctx,
+                                               yyjson_ptr_err *err);
+
+/**
+ Add (insert) value by a JSON pointer.
+ @param val The target JSON value.
+ @param ptr The JSON pointer string (UTF-8 with null-terminator).
+ @param doc Only used to create new values when needed.
+ @param new_val The value to be added.
+ @return true if JSON pointer is valid and new value is added, false otherwise.
+ @note The parent nodes will be created if they do not exist.
+ */
+yyjson_api_inline bool yyjson_mut_ptr_add(yyjson_mut_val *val,
+                                          const char *ptr,
+                                          yyjson_mut_val *new_val,
+                                          yyjson_mut_doc *doc);
+
+/**
+ Add (insert) value by a JSON pointer.
+ @param val The target JSON value.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param doc Only used to create new values when needed.
+ @param new_val The value to be added.
+ @return true if JSON pointer is valid and new value is added, false otherwise.
+ @note The parent nodes will be created if they do not exist.
+ */
+yyjson_api_inline bool yyjson_mut_ptr_addn(yyjson_mut_val *val,
+                                           const char *ptr, size_t len,
+                                           yyjson_mut_val *new_val,
+                                           yyjson_mut_doc *doc);
+
+/**
+ Add (insert) value by a JSON pointer.
+ @param val The target JSON value.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param doc Only used to create new values when needed.
+ @param new_val The value to be added.
+ @param create_parent Whether to create parent nodes if not exist.
+ @param ctx A pointer to store the result context, or NULL if not needed.
+ @param err A pointer to store the error information, or NULL if not needed.
+ @return true if JSON pointer is valid and new value is added, false otherwise.
+ */
+yyjson_api_inline bool yyjson_mut_ptr_addx(yyjson_mut_val *val,
+                                           const char *ptr, size_t len,
+                                           yyjson_mut_val *new_val,
+                                           yyjson_mut_doc *doc,
+                                           bool create_parent,
+                                           yyjson_ptr_ctx *ctx,
+                                           yyjson_ptr_err *err);
+
+/**
+ Set value by a JSON pointer.
+ @param doc The target JSON document.
+ @param ptr The JSON pointer string (UTF-8 with null-terminator).
+ @param new_val The value to be set, pass NULL to remove.
+ @return true if JSON pointer is valid and new value is set, false otherwise.
+ @note The parent nodes will be created if they do not exist.
+    If the target value already exists, it will be replaced by the new value.
+ */
+yyjson_api_inline bool yyjson_mut_doc_ptr_set(yyjson_mut_doc *doc,
+                                              const char *ptr,
+                                              yyjson_mut_val *new_val);
+
+/**
+ Set value by a JSON pointer.
+ @param doc The target JSON document.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param new_val The value to be set, pass NULL to remove.
+ @return true if JSON pointer is valid and new value is set, false otherwise.
+ @note The parent nodes will be created if they do not exist.
+    If the target value already exists, it will be replaced by the new value.
+ */
+yyjson_api_inline bool yyjson_mut_doc_ptr_setn(yyjson_mut_doc *doc,
+                                               const char *ptr, size_t len,
+                                               yyjson_mut_val *new_val);
+
+/**
+ Set value by a JSON pointer.
+ @param doc The target JSON document.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param new_val The value to be set, pass NULL to remove.
+ @param create_parent Whether to create parent nodes if not exist.
+ @param ctx A pointer to store the result context, or NULL if not needed.
+ @param err A pointer to store the error information, or NULL if not needed.
+ @return true if JSON pointer is valid and new value is set, false otherwise.
+ @note If the target value already exists, it will be replaced by the new value.
+ */
+yyjson_api_inline bool yyjson_mut_doc_ptr_setx(yyjson_mut_doc *doc,
+                                               const char *ptr, size_t len,
+                                               yyjson_mut_val *new_val,
+                                               bool create_parent,
+                                               yyjson_ptr_ctx *ctx,
+                                               yyjson_ptr_err *err);
+
+/**
+ Set value by a JSON pointer.
+ @param val The target JSON value.
+ @param ptr The JSON pointer string (UTF-8 with null-terminator).
+ @param new_val The value to be set, pass NULL to remove.
+ @param doc Only used to create new values when needed.
+ @return true if JSON pointer is valid and new value is set, false otherwise.
+ @note The parent nodes will be created if they do not exist.
+    If the target value already exists, it will be replaced by the new value.
+ */
+yyjson_api_inline bool yyjson_mut_ptr_set(yyjson_mut_val *val,
+                                          const char *ptr,
+                                          yyjson_mut_val *new_val,
+                                          yyjson_mut_doc *doc);
+
+/**
+ Set value by a JSON pointer.
+ @param val The target JSON value.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param new_val The value to be set, pass NULL to remove.
+ @param doc Only used to create new values when needed.
+ @return true if JSON pointer is valid and new value is set, false otherwise.
+ @note The parent nodes will be created if they do not exist.
+    If the target value already exists, it will be replaced by the new value.
+ */
+yyjson_api_inline bool yyjson_mut_ptr_setn(yyjson_mut_val *val,
+                                           const char *ptr, size_t len,
+                                           yyjson_mut_val *new_val,
+                                           yyjson_mut_doc *doc);
+
+/**
+ Set value by a JSON pointer.
+ @param val The target JSON value.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param new_val The value to be set, pass NULL to remove.
+ @param doc Only used to create new values when needed.
+ @param create_parent Whether to create parent nodes if not exist.
+ @param ctx A pointer to store the result context, or NULL if not needed.
+ @param err A pointer to store the error information, or NULL if not needed.
+ @return true if JSON pointer is valid and new value is set, false otherwise.
+ @note If the target value already exists, it will be replaced by the new value.
+ */
+yyjson_api_inline bool yyjson_mut_ptr_setx(yyjson_mut_val *val,
+                                           const char *ptr, size_t len,
+                                           yyjson_mut_val *new_val,
+                                           yyjson_mut_doc *doc,
+                                           bool create_parent,
+                                           yyjson_ptr_ctx *ctx,
+                                           yyjson_ptr_err *err);
+
+/**
+ Replace value by a JSON pointer.
+ @param doc The target JSON document.
+ @param ptr The JSON pointer string (UTF-8 with null-terminator).
+ @param new_val The new value to replace the old one.
+ @return The old value that was replaced, or NULL if not found.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replace(
+    yyjson_mut_doc *doc, const char *ptr, yyjson_mut_val *new_val);
+
+/**
+ Replace value by a JSON pointer.
+ @param doc The target JSON document.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param new_val The new value to replace the old one.
+ @return The old value that was replaced, or NULL if not found.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replacen(
+    yyjson_mut_doc *doc, const char *ptr, size_t len, yyjson_mut_val *new_val);
+
+/**
+ Replace value by a JSON pointer.
+ @param doc The target JSON document.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param new_val The new value to replace the old one.
+ @param ctx A pointer to store the result context, or NULL if not needed.
+ @param err A pointer to store the error information, or NULL if not needed.
+ @return The old value that was replaced, or NULL if not found.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replacex(
+    yyjson_mut_doc *doc, const char *ptr, size_t len, yyjson_mut_val *new_val,
+    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err);
+
+/**
+ Replace value by a JSON pointer.
+ @param val The target JSON value.
+ @param ptr The JSON pointer string (UTF-8 with null-terminator).
+ @param new_val The new value to replace the old one.
+ @return The old value that was replaced, or NULL if not found.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replace(
+    yyjson_mut_val *val, const char *ptr, yyjson_mut_val *new_val);
+
+/**
+ Replace value by a JSON pointer.
+ @param val The target JSON value.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param new_val The new value to replace the old one.
+ @return The old value that was replaced, or NULL if not found.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replacen(
+    yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val);
+
+/**
+ Replace value by a JSON pointer.
+ @param val The target JSON value.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param new_val The new value to replace the old one.
+ @param ctx A pointer to store the result context, or NULL if not needed.
+ @param err A pointer to store the error information, or NULL if not needed.
+ @return The old value that was replaced, or NULL if not found.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replacex(
+    yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val,
+    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err);
+
+/**
+ Remove value by a JSON pointer.
+ @param doc The target JSON document.
+ @param ptr The JSON pointer string (UTF-8 with null-terminator).
+ @return The removed value, or NULL on error.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_remove(
+    yyjson_mut_doc *doc, const char *ptr);
+
+/**
+ Remove value by a JSON pointer.
+ @param doc The target JSON document.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @return The removed value, or NULL on error.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_removen(
+    yyjson_mut_doc *doc, const char *ptr, size_t len);
+
+/**
+ Remove value by a JSON pointer.
+ @param doc The target JSON document.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param ctx A pointer to store the result context, or NULL if not needed.
+ @param err A pointer to store the error information, or NULL if not needed.
+ @return The removed value, or NULL on error.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_removex(
+    yyjson_mut_doc *doc, const char *ptr, size_t len,
+    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err);
+
+/**
+ Remove value by a JSON pointer.
+ @param val The target JSON value.
+ @param ptr The JSON pointer string (UTF-8 with null-terminator).
+ @return The removed value, or NULL on error.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_remove(yyjson_mut_val *val,
+                                                        const char *ptr);
+
+/**
+ Remove value by a JSON pointer.
+ @param val The target JSON value.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @return The removed value, or NULL on error.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_removen(yyjson_mut_val *val,
+                                                         const char *ptr,
+                                                         size_t len);
+
+/**
+ Remove value by a JSON pointer.
+ @param val The target JSON value.
+ @param ptr The JSON pointer string (UTF-8, null-terminator is not required).
+ @param len The length of `ptr` in bytes.
+ @param ctx A pointer to store the result context, or NULL if not needed.
+ @param err A pointer to store the error information, or NULL if not needed.
+ @return The removed value, or NULL on error.
+ */
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_removex(yyjson_mut_val *val,
+                                                         const char *ptr,
+                                                         size_t len,
+                                                         yyjson_ptr_ctx *ctx,
+                                                         yyjson_ptr_err *err);
+
+/**
+ Append value by JSON pointer context.
+ @param ctx The context from the `yyjson_mut_ptr_xxx()` calls.
+ @param key New key if `ctx->ctn` is object, or NULL if `ctx->ctn` is array.
+ @param val New value to be added.
+ @return true on success or false on fail.
+ */
+yyjson_api_inline bool yyjson_ptr_ctx_append(yyjson_ptr_ctx *ctx,
+                                             yyjson_mut_val *key,
+                                             yyjson_mut_val *val);
+
+/**
+ Replace value by JSON pointer context.
+ @param ctx The context from the `yyjson_mut_ptr_xxx()` calls.
+ @param val New value to be replaced.
+ @return true on success or false on fail.
+ @note If success, the old value will be returned via `ctx->old`.
+ */
+yyjson_api_inline bool yyjson_ptr_ctx_replace(yyjson_ptr_ctx *ctx,
+                                              yyjson_mut_val *val);
+
+/**
+ Remove value by JSON pointer context.
+ @param ctx The context from the `yyjson_mut_ptr_xxx()` calls.
+ @return true on success or false on fail.
+ @note If success, the old value will be returned via `ctx->old`.
+ */
+yyjson_api_inline bool yyjson_ptr_ctx_remove(yyjson_ptr_ctx *ctx);
+
+
+
+/*==============================================================================
+ * JSON Patch API (RFC 6902)
+ * https://tools.ietf.org/html/rfc6902
+ *============================================================================*/
+
+/** Result code for JSON patch. */
+typedef uint32_t yyjson_patch_code;
+
+/** Success, no error. */
+static const yyjson_patch_code YYJSON_PATCH_SUCCESS = 0;
+
+/** Invalid parameter, such as NULL input or non-array patch. */
+static const yyjson_patch_code YYJSON_PATCH_ERROR_INVALID_PARAMETER = 1;
+
+/** Memory allocation failure occurs. */
+static const yyjson_patch_code YYJSON_PATCH_ERROR_MEMORY_ALLOCATION = 2;
+
+/** JSON patch operation is not object type. */
+static const yyjson_patch_code YYJSON_PATCH_ERROR_INVALID_OPERATION = 3;
+
+/** JSON patch operation is missing a required key. */
+static const yyjson_patch_code YYJSON_PATCH_ERROR_MISSING_KEY = 4;
+
+/** JSON patch operation member is invalid. */
+static const yyjson_patch_code YYJSON_PATCH_ERROR_INVALID_MEMBER = 5;
+
+/** JSON patch operation `test` not equal. */
+static const yyjson_patch_code YYJSON_PATCH_ERROR_EQUAL = 6;
+
+/** JSON patch operation failed on JSON pointer. */
+static const yyjson_patch_code YYJSON_PATCH_ERROR_POINTER = 7;
+
+/** Error information for JSON patch. */
+typedef struct yyjson_patch_err {
+    /** Error code, see `yyjson_patch_code` for all possible values. */
+    yyjson_patch_code code;
+    /** Index of the error operation (0 if no error). */
+    size_t idx;
+    /** Error message, constant, no need to free (NULL if no error). */
+    const char *msg;
+    /** JSON pointer error if `code == YYJSON_PATCH_ERROR_POINTER`. */
+    yyjson_ptr_err ptr;
+} yyjson_patch_err;
+
+/**
+ Creates and returns a patched JSON value (RFC 6902).
+ The memory of the returned value is allocated by the `doc`.
+ The `err` is used to receive error information, pass NULL if not needed.
+ Returns NULL if the patch could not be applied.
+ */
+yyjson_api yyjson_mut_val *yyjson_patch(yyjson_mut_doc *doc,
+                                        yyjson_val *orig,
+                                        yyjson_val *patch,
+                                        yyjson_patch_err *err);
+
+/**
+ Creates and returns a patched JSON value (RFC 6902).
+ The memory of the returned value is allocated by the `doc`.
+ The `err` is used to receive error information, pass NULL if not needed.
+ Returns NULL if the patch could not be applied.
+ */
+yyjson_api yyjson_mut_val *yyjson_mut_patch(yyjson_mut_doc *doc,
+                                            yyjson_mut_val *orig,
+                                            yyjson_mut_val *patch,
+                                            yyjson_patch_err *err);
+
+
+
+/*==============================================================================
+ * JSON Merge-Patch API (RFC 7386)
+ * https://tools.ietf.org/html/rfc7386
+ *============================================================================*/
+
+/**
+ Creates and returns a merge-patched JSON value (RFC 7386).
+ The memory of the returned value is allocated by the `doc`.
+ Returns NULL if the patch could not be applied.
+
+ @warning This function is recursive and may cause a stack overflow if the
+    object level is too deep.
+ */
+yyjson_api yyjson_mut_val *yyjson_merge_patch(yyjson_mut_doc *doc,
+                                              yyjson_val *orig,
+                                              yyjson_val *patch);
+
+/**
+ Creates and returns a merge-patched JSON value (RFC 7386).
+ The memory of the returned value is allocated by the `doc`.
+ Returns NULL if the patch could not be applied.
+
+ @warning This function is recursive and may cause a stack overflow if the
+    object level is too deep.
+ */
+yyjson_api yyjson_mut_val *yyjson_mut_merge_patch(yyjson_mut_doc *doc,
+                                                  yyjson_mut_val *orig,
+                                                  yyjson_mut_val *patch);
+
+
+
+/*==============================================================================
+ * JSON Structure (Implementation)
+ *============================================================================*/
+
+/** Payload of a JSON value (8 bytes). */
+typedef union yyjson_val_uni {
+    uint64_t    u64;
+    int64_t     i64;
+    double      f64;
+    const char *str;
+    void       *ptr;
+    size_t      ofs;
+} yyjson_val_uni;
+
+/**
+ Immutable JSON value, 16 bytes.
+ */
+struct yyjson_val {
+    uint64_t tag; /**< type, subtype and length */
+    yyjson_val_uni uni; /**< payload */
+};
+
+struct yyjson_doc {
+    /** Root value of the document (nonnull). */
+    yyjson_val *root;
+    /** Allocator used by document (nonnull). */
+    yyjson_alc alc;
+    /** The total number of bytes read when parsing JSON (nonzero). */
+    size_t dat_read;
+    /** The total number of value read when parsing JSON (nonzero). */
+    size_t val_read;
+    /** The string pool used by JSON values (nullable). */
+    char *str_pool;
+};
+
+
+
+/*==============================================================================
+ * Unsafe JSON Value API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline yyjson_type unsafe_yyjson_get_type(void *val) {
+    uint8_t tag = (uint8_t)((yyjson_val *)val)->tag;
+    return (yyjson_type)(tag & YYJSON_TYPE_MASK);
+}
+
+yyjson_api_inline yyjson_subtype unsafe_yyjson_get_subtype(void *val) {
+    uint8_t tag = (uint8_t)((yyjson_val *)val)->tag;
+    return (yyjson_subtype)(tag & YYJSON_SUBTYPE_MASK);
+}
+
+yyjson_api_inline uint8_t unsafe_yyjson_get_tag(void *val) {
+    uint8_t tag = (uint8_t)((yyjson_val *)val)->tag;
+    return (uint8_t)(tag & YYJSON_TAG_MASK);
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_raw(void *val) {
+    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_RAW;
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_null(void *val) {
+    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_NULL;
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_bool(void *val) {
+    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_BOOL;
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_num(void *val) {
+    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_NUM;
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_str(void *val) {
+    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_STR;
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_arr(void *val) {
+    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_ARR;
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_obj(void *val) {
+    return unsafe_yyjson_get_type(val) == YYJSON_TYPE_OBJ;
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_ctn(void *val) {
+    uint8_t mask = YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ;
+    return (unsafe_yyjson_get_tag(val) & mask) == mask;
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_uint(void *val) {
+    const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
+    return unsafe_yyjson_get_tag(val) == patt;
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_sint(void *val) {
+    const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
+    return unsafe_yyjson_get_tag(val) == patt;
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_int(void *val) {
+    const uint8_t mask = YYJSON_TAG_MASK & (~YYJSON_SUBTYPE_SINT);
+    const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
+    return (unsafe_yyjson_get_tag(val) & mask) == patt;
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_real(void *val) {
+    const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
+    return unsafe_yyjson_get_tag(val) == patt;
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_true(void *val) {
+    const uint8_t patt = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE;
+    return unsafe_yyjson_get_tag(val) == patt;
+}
+
+yyjson_api_inline bool unsafe_yyjson_is_false(void *val) {
+    const uint8_t patt = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE;
+    return unsafe_yyjson_get_tag(val) == patt;
+}
+
+yyjson_api_inline bool unsafe_yyjson_arr_is_flat(yyjson_val *val) {
+    size_t ofs = val->uni.ofs;
+    size_t len = (size_t)(val->tag >> YYJSON_TAG_BIT);
+    return len * sizeof(yyjson_val) + sizeof(yyjson_val) == ofs;
+}
+
+yyjson_api_inline const char *unsafe_yyjson_get_raw(void *val) {
+    return ((yyjson_val *)val)->uni.str;
+}
+
+yyjson_api_inline bool unsafe_yyjson_get_bool(void *val) {
+    uint8_t tag = unsafe_yyjson_get_tag(val);
+    return (bool)((tag & YYJSON_SUBTYPE_MASK) >> YYJSON_TYPE_BIT);
+}
+
+yyjson_api_inline uint64_t unsafe_yyjson_get_uint(void *val) {
+    return ((yyjson_val *)val)->uni.u64;
+}
+
+yyjson_api_inline int64_t unsafe_yyjson_get_sint(void *val) {
+    return ((yyjson_val *)val)->uni.i64;
+}
+
+yyjson_api_inline int unsafe_yyjson_get_int(void *val) {
+    return (int)((yyjson_val *)val)->uni.i64;
+}
+
+yyjson_api_inline double unsafe_yyjson_get_real(void *val) {
+    return ((yyjson_val *)val)->uni.f64;
+}
+
+yyjson_api_inline double unsafe_yyjson_get_num(void *val) {
+    uint8_t tag = unsafe_yyjson_get_tag(val);
+    if (tag == (YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL)) {
+        return ((yyjson_val *)val)->uni.f64;
+    } else if (tag == (YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT)) {
+        return (double)((yyjson_val *)val)->uni.i64;
+    } else if (tag == (YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT)) {
+#if YYJSON_U64_TO_F64_NO_IMPL
+        uint64_t msb = ((uint64_t)1) << 63;
+        uint64_t num = ((yyjson_val *)val)->uni.u64;
+        if ((num & msb) == 0) {
+            return (double)(int64_t)num;
+        } else {
+            return ((double)(int64_t)((num >> 1) | (num & 1))) * (double)2.0;
+        }
+#else
+        return (double)((yyjson_val *)val)->uni.u64;
+#endif
+    }
+    return 0.0;
+}
+
+yyjson_api_inline const char *unsafe_yyjson_get_str(void *val) {
+    return ((yyjson_val *)val)->uni.str;
+}
+
+yyjson_api_inline size_t unsafe_yyjson_get_len(void *val) {
+    return (size_t)(((yyjson_val *)val)->tag >> YYJSON_TAG_BIT);
+}
+
+yyjson_api_inline yyjson_val *unsafe_yyjson_get_first(yyjson_val *ctn) {
+    return ctn + 1;
+}
+
+yyjson_api_inline yyjson_val *unsafe_yyjson_get_next(yyjson_val *val) {
+    bool is_ctn = unsafe_yyjson_is_ctn(val);
+    size_t ctn_ofs = val->uni.ofs;
+    size_t ofs = (is_ctn ? ctn_ofs : sizeof(yyjson_val));
+    return (yyjson_val *)(void *)((uint8_t *)val + ofs);
+}
+
+yyjson_api_inline bool unsafe_yyjson_equals_strn(void *val, const char *str,
+                                                 size_t len) {
+    uint64_t tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+    return ((yyjson_val *)val)->tag == tag &&
+    memcmp(((yyjson_val *)val)->uni.str, str, len) == 0;
+}
+
+yyjson_api_inline bool unsafe_yyjson_equals_str(void *val, const char *str) {
+    return unsafe_yyjson_equals_strn(val, str, strlen(str));
+}
+
+yyjson_api_inline void unsafe_yyjson_set_type(void *val, yyjson_type type,
+                                              yyjson_subtype subtype) {
+    uint8_t tag = (type | subtype);
+    uint64_t new_tag = ((yyjson_val *)val)->tag;
+    new_tag = (new_tag & (~(uint64_t)YYJSON_TAG_MASK)) | (uint64_t)tag;
+    ((yyjson_val *)val)->tag = new_tag;
+}
+
+yyjson_api_inline void unsafe_yyjson_set_len(void *val, size_t len) {
+    uint64_t tag = ((yyjson_val *)val)->tag & YYJSON_TAG_MASK;
+    tag |= (uint64_t)len << YYJSON_TAG_BIT;
+    ((yyjson_val *)val)->tag = tag;
+}
+
+yyjson_api_inline void unsafe_yyjson_inc_len(void *val) {
+    uint64_t tag = ((yyjson_val *)val)->tag;
+    tag += (uint64_t)(1 << YYJSON_TAG_BIT);
+    ((yyjson_val *)val)->tag = tag;
+}
+
+yyjson_api_inline void unsafe_yyjson_set_raw(void *val, const char *raw,
+                                             size_t len) {
+    unsafe_yyjson_set_type(val, YYJSON_TYPE_RAW, YYJSON_SUBTYPE_NONE);
+    unsafe_yyjson_set_len(val, len);
+    ((yyjson_val *)val)->uni.str = raw;
+}
+
+yyjson_api_inline void unsafe_yyjson_set_null(void *val) {
+    unsafe_yyjson_set_type(val, YYJSON_TYPE_NULL, YYJSON_SUBTYPE_NONE);
+    unsafe_yyjson_set_len(val, 0);
+}
+
+yyjson_api_inline void unsafe_yyjson_set_bool(void *val, bool num) {
+    yyjson_subtype subtype = num ? YYJSON_SUBTYPE_TRUE : YYJSON_SUBTYPE_FALSE;
+    unsafe_yyjson_set_type(val, YYJSON_TYPE_BOOL, subtype);
+    unsafe_yyjson_set_len(val, 0);
+}
+
+yyjson_api_inline void unsafe_yyjson_set_uint(void *val, uint64_t num) {
+    unsafe_yyjson_set_type(val, YYJSON_TYPE_NUM, YYJSON_SUBTYPE_UINT);
+    unsafe_yyjson_set_len(val, 0);
+    ((yyjson_val *)val)->uni.u64 = num;
+}
+
+yyjson_api_inline void unsafe_yyjson_set_sint(void *val, int64_t num) {
+    unsafe_yyjson_set_type(val, YYJSON_TYPE_NUM, YYJSON_SUBTYPE_SINT);
+    unsafe_yyjson_set_len(val, 0);
+    ((yyjson_val *)val)->uni.i64 = num;
+}
+
+yyjson_api_inline void unsafe_yyjson_set_real(void *val, double num) {
+    unsafe_yyjson_set_type(val, YYJSON_TYPE_NUM, YYJSON_SUBTYPE_REAL);
+    unsafe_yyjson_set_len(val, 0);
+    ((yyjson_val *)val)->uni.f64 = num;
+}
+
+yyjson_api_inline void unsafe_yyjson_set_str(void *val, const char *str) {
+    unsafe_yyjson_set_type(val, YYJSON_TYPE_STR, YYJSON_SUBTYPE_NONE);
+    unsafe_yyjson_set_len(val, strlen(str));
+    ((yyjson_val *)val)->uni.str = str;
+}
+
+yyjson_api_inline void unsafe_yyjson_set_strn(void *val, const char *str,
+                                              size_t len) {
+    unsafe_yyjson_set_type(val, YYJSON_TYPE_STR, YYJSON_SUBTYPE_NONE);
+    unsafe_yyjson_set_len(val, len);
+    ((yyjson_val *)val)->uni.str = str;
+}
+
+yyjson_api_inline void unsafe_yyjson_set_arr(void *val, size_t size) {
+    unsafe_yyjson_set_type(val, YYJSON_TYPE_ARR, YYJSON_SUBTYPE_NONE);
+    unsafe_yyjson_set_len(val, size);
+}
+
+yyjson_api_inline void unsafe_yyjson_set_obj(void *val, size_t size) {
+    unsafe_yyjson_set_type(val, YYJSON_TYPE_OBJ, YYJSON_SUBTYPE_NONE);
+    unsafe_yyjson_set_len(val, size);
+}
+
+
+
+/*==============================================================================
+ * JSON Document API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline yyjson_val *yyjson_doc_get_root(yyjson_doc *doc) {
+    return doc ? doc->root : NULL;
+}
+
+yyjson_api_inline size_t yyjson_doc_get_read_size(yyjson_doc *doc) {
+    return doc ? doc->dat_read : 0;
+}
+
+yyjson_api_inline size_t yyjson_doc_get_val_count(yyjson_doc *doc) {
+    return doc ? doc->val_read : 0;
+}
+
+yyjson_api_inline void yyjson_doc_free(yyjson_doc *doc) {
+    if (doc) {
+        yyjson_alc alc = doc->alc;
+        if (doc->str_pool) alc.free(alc.ctx, doc->str_pool);
+        alc.free(alc.ctx, doc);
+    }
+}
+
+
+
+/*==============================================================================
+ * JSON Value Type API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline bool yyjson_is_raw(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_raw(val) : false;
+}
+
+yyjson_api_inline bool yyjson_is_null(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_null(val) : false;
+}
+
+yyjson_api_inline bool yyjson_is_true(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_true(val) : false;
+}
+
+yyjson_api_inline bool yyjson_is_false(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_false(val) : false;
+}
+
+yyjson_api_inline bool yyjson_is_bool(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_bool(val) : false;
+}
+
+yyjson_api_inline bool yyjson_is_uint(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_uint(val) : false;
+}
+
+yyjson_api_inline bool yyjson_is_sint(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_sint(val) : false;
+}
+
+yyjson_api_inline bool yyjson_is_int(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_int(val) : false;
+}
+
+yyjson_api_inline bool yyjson_is_real(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_real(val) : false;
+}
+
+yyjson_api_inline bool yyjson_is_num(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_num(val) : false;
+}
+
+yyjson_api_inline bool yyjson_is_str(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_str(val) : false;
+}
+
+yyjson_api_inline bool yyjson_is_arr(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_arr(val) : false;
+}
+
+yyjson_api_inline bool yyjson_is_obj(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_obj(val) : false;
+}
+
+yyjson_api_inline bool yyjson_is_ctn(yyjson_val *val) {
+    return val ? unsafe_yyjson_is_ctn(val) : false;
+}
+
+
+
+/*==============================================================================
+ * JSON Value Content API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline yyjson_type yyjson_get_type(yyjson_val *val) {
+    return val ? unsafe_yyjson_get_type(val) : YYJSON_TYPE_NONE;
+}
+
+yyjson_api_inline yyjson_subtype yyjson_get_subtype(yyjson_val *val) {
+    return val ? unsafe_yyjson_get_subtype(val) : YYJSON_SUBTYPE_NONE;
+}
+
+yyjson_api_inline uint8_t yyjson_get_tag(yyjson_val *val) {
+    return val ? unsafe_yyjson_get_tag(val) : 0;
+}
+
+yyjson_api_inline const char *yyjson_get_type_desc(yyjson_val *val) {
+    switch (yyjson_get_tag(val)) {
+        case YYJSON_TYPE_RAW  | YYJSON_SUBTYPE_NONE:  return "raw";
+        case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:  return "null";
+        case YYJSON_TYPE_STR  | YYJSON_SUBTYPE_NONE:  return "string";
+        case YYJSON_TYPE_ARR  | YYJSON_SUBTYPE_NONE:  return "array";
+        case YYJSON_TYPE_OBJ  | YYJSON_SUBTYPE_NONE:  return "object";
+        case YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE:  return "true";
+        case YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE: return "false";
+        case YYJSON_TYPE_NUM  | YYJSON_SUBTYPE_UINT:  return "uint";
+        case YYJSON_TYPE_NUM  | YYJSON_SUBTYPE_SINT:  return "sint";
+        case YYJSON_TYPE_NUM  | YYJSON_SUBTYPE_REAL:  return "real";
+        default:                                      return "unknown";
+    }
+}
+
+yyjson_api_inline const char *yyjson_get_raw(yyjson_val *val) {
+    return yyjson_is_raw(val) ? unsafe_yyjson_get_raw(val) : NULL;
+}
+
+yyjson_api_inline bool yyjson_get_bool(yyjson_val *val) {
+    return yyjson_is_bool(val) ? unsafe_yyjson_get_bool(val) : false;
+}
+
+yyjson_api_inline uint64_t yyjson_get_uint(yyjson_val *val) {
+    return yyjson_is_int(val) ? unsafe_yyjson_get_uint(val) : 0;
+}
+
+yyjson_api_inline int64_t yyjson_get_sint(yyjson_val *val) {
+    return yyjson_is_int(val) ? unsafe_yyjson_get_sint(val) : 0;
+}
+
+yyjson_api_inline int yyjson_get_int(yyjson_val *val) {
+    return yyjson_is_int(val) ? unsafe_yyjson_get_int(val) : 0;
+}
+
+yyjson_api_inline double yyjson_get_real(yyjson_val *val) {
+    return yyjson_is_real(val) ? unsafe_yyjson_get_real(val) : 0.0;
+}
+
+yyjson_api_inline double yyjson_get_num(yyjson_val *val) {
+    return val ? unsafe_yyjson_get_num(val) : 0.0;
+}
+
+yyjson_api_inline const char *yyjson_get_str(yyjson_val *val) {
+    return yyjson_is_str(val) ? unsafe_yyjson_get_str(val) : NULL;
+}
+
+yyjson_api_inline size_t yyjson_get_len(yyjson_val *val) {
+    return val ? unsafe_yyjson_get_len(val) : 0;
+}
+
+yyjson_api_inline bool yyjson_equals_str(yyjson_val *val, const char *str) {
+    if (yyjson_likely(val && str)) {
+        return unsafe_yyjson_equals_str(val, str);
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_equals_strn(yyjson_val *val, const char *str,
+                                          size_t len) {
+    if (yyjson_likely(val && str)) {
+        return unsafe_yyjson_equals_strn(val, str, len);
+    }
+    return false;
+}
+
+yyjson_api bool unsafe_yyjson_equals(yyjson_val *lhs, yyjson_val *rhs);
+
+yyjson_api_inline bool yyjson_equals(yyjson_val *lhs, yyjson_val *rhs) {
+    if (yyjson_unlikely(!lhs || !rhs)) return false;
+    return unsafe_yyjson_equals(lhs, rhs);
+}
+
+yyjson_api_inline bool yyjson_set_raw(yyjson_val *val,
+                                      const char *raw, size_t len) {
+    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
+    unsafe_yyjson_set_raw(val, raw, len);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_set_null(yyjson_val *val) {
+    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
+    unsafe_yyjson_set_null(val);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_set_bool(yyjson_val *val, bool num) {
+    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
+    unsafe_yyjson_set_bool(val, num);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_set_uint(yyjson_val *val, uint64_t num) {
+    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
+    unsafe_yyjson_set_uint(val, num);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_set_sint(yyjson_val *val, int64_t num) {
+    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
+    unsafe_yyjson_set_sint(val, num);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_set_int(yyjson_val *val, int num) {
+    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
+    unsafe_yyjson_set_sint(val, (int64_t)num);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_set_real(yyjson_val *val, double num) {
+    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
+    unsafe_yyjson_set_real(val, num);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_set_str(yyjson_val *val, const char *str) {
+    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
+    if (yyjson_unlikely(!str)) return false;
+    unsafe_yyjson_set_str(val, str);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_set_strn(yyjson_val *val,
+                                       const char *str, size_t len) {
+    if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
+    if (yyjson_unlikely(!str)) return false;
+    unsafe_yyjson_set_strn(val, str, len);
+    return true;
+}
+
+
+
+/*==============================================================================
+ * JSON Array API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline size_t yyjson_arr_size(yyjson_val *arr) {
+    return yyjson_is_arr(arr) ? unsafe_yyjson_get_len(arr) : 0;
+}
+
+yyjson_api_inline yyjson_val *yyjson_arr_get(yyjson_val *arr, size_t idx) {
+    if (yyjson_likely(yyjson_is_arr(arr))) {
+        if (yyjson_likely(unsafe_yyjson_get_len(arr) > idx)) {
+            yyjson_val *val = unsafe_yyjson_get_first(arr);
+            if (unsafe_yyjson_arr_is_flat(arr)) {
+                return val + idx;
+            } else {
+                while (idx-- > 0) val = unsafe_yyjson_get_next(val);
+                return val;
+            }
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_val *yyjson_arr_get_first(yyjson_val *arr) {
+    if (yyjson_likely(yyjson_is_arr(arr))) {
+        if (yyjson_likely(unsafe_yyjson_get_len(arr) > 0)) {
+            return unsafe_yyjson_get_first(arr);
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_val *yyjson_arr_get_last(yyjson_val *arr) {
+    if (yyjson_likely(yyjson_is_arr(arr))) {
+        size_t len = unsafe_yyjson_get_len(arr);
+        if (yyjson_likely(len > 0)) {
+            yyjson_val *val = unsafe_yyjson_get_first(arr);
+            if (unsafe_yyjson_arr_is_flat(arr)) {
+                return val + (len - 1);
+            } else {
+                while (len-- > 1) val = unsafe_yyjson_get_next(val);
+                return val;
+            }
+        }
+    }
+    return NULL;
+}
+
+
+
+/*==============================================================================
+ * JSON Array Iterator API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline bool yyjson_arr_iter_init(yyjson_val *arr,
+                                            yyjson_arr_iter *iter) {
+    if (yyjson_likely(yyjson_is_arr(arr) && iter)) {
+        iter->idx = 0;
+        iter->max = unsafe_yyjson_get_len(arr);
+        iter->cur = unsafe_yyjson_get_first(arr);
+        return true;
+    }
+    if (iter) memset(iter, 0, sizeof(yyjson_arr_iter));
+    return false;
+}
+
+yyjson_api_inline yyjson_arr_iter yyjson_arr_iter_with(yyjson_val *arr) {
+    yyjson_arr_iter iter;
+    yyjson_arr_iter_init(arr, &iter);
+    return iter;
+}
+
+yyjson_api_inline bool yyjson_arr_iter_has_next(yyjson_arr_iter *iter) {
+    return iter ? iter->idx < iter->max : false;
+}
+
+yyjson_api_inline yyjson_val *yyjson_arr_iter_next(yyjson_arr_iter *iter) {
+    yyjson_val *val;
+    if (iter && iter->idx < iter->max) {
+        val = iter->cur;
+        iter->cur = unsafe_yyjson_get_next(val);
+        iter->idx++;
+        return val;
+    }
+    return NULL;
+}
+
+
+
+/*==============================================================================
+ * JSON Object API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline size_t yyjson_obj_size(yyjson_val *obj) {
+    return yyjson_is_obj(obj) ? unsafe_yyjson_get_len(obj) : 0;
+}
+
+yyjson_api_inline yyjson_val *yyjson_obj_get(yyjson_val *obj,
+                                             const char *key) {
+    return yyjson_obj_getn(obj, key, key ? strlen(key) : 0);
+}
+
+yyjson_api_inline yyjson_val *yyjson_obj_getn(yyjson_val *obj,
+                                              const char *_key,
+                                              size_t key_len) {
+    uint64_t tag = (((uint64_t)key_len) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+    if (yyjson_likely(yyjson_is_obj(obj) && _key)) {
+        size_t len = unsafe_yyjson_get_len(obj);
+        yyjson_val *key = unsafe_yyjson_get_first(obj);
+        while (len-- > 0) {
+            if (key->tag == tag &&
+                memcmp(key->uni.ptr, _key, key_len) == 0) {
+                return key + 1;
+            }
+            key = unsafe_yyjson_get_next(key + 1);
+        }
+    }
+    return NULL;
+}
+
+
+
+/*==============================================================================
+ * JSON Object Iterator API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline bool yyjson_obj_iter_init(yyjson_val *obj,
+                                            yyjson_obj_iter *iter) {
+    if (yyjson_likely(yyjson_is_obj(obj) && iter)) {
+        iter->idx = 0;
+        iter->max = unsafe_yyjson_get_len(obj);
+        iter->cur = unsafe_yyjson_get_first(obj);
+        iter->obj = obj;
+        return true;
+    }
+    if (iter) memset(iter, 0, sizeof(yyjson_obj_iter));
+    return false;
+}
+
+yyjson_api_inline yyjson_obj_iter yyjson_obj_iter_with(yyjson_val *obj) {
+    yyjson_obj_iter iter;
+    yyjson_obj_iter_init(obj, &iter);
+    return iter;
+}
+
+yyjson_api_inline bool yyjson_obj_iter_has_next(yyjson_obj_iter *iter) {
+    return iter ? iter->idx < iter->max : false;
+}
+
+yyjson_api_inline yyjson_val *yyjson_obj_iter_next(yyjson_obj_iter *iter) {
+    if (iter && iter->idx < iter->max) {
+        yyjson_val *key = iter->cur;
+        iter->idx++;
+        iter->cur = unsafe_yyjson_get_next(key + 1);
+        return key;
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_val *yyjson_obj_iter_get_val(yyjson_val *key) {
+    return key ? key + 1 : NULL;
+}
+
+yyjson_api_inline yyjson_val *yyjson_obj_iter_get(yyjson_obj_iter *iter,
+                                                  const char *key) {
+    return yyjson_obj_iter_getn(iter, key, key ? strlen(key) : 0);
+}
+
+yyjson_api_inline yyjson_val *yyjson_obj_iter_getn(yyjson_obj_iter *iter,
+                                                   const char *key,
+                                                   size_t key_len) {
+    if (iter && key) {
+        size_t idx = iter->idx;
+        size_t max = iter->max;
+        yyjson_val *cur = iter->cur;
+        if (yyjson_unlikely(idx == max)) {
+            idx = 0;
+            cur = unsafe_yyjson_get_first(iter->obj);
+        }
+        while (idx++ < max) {
+            yyjson_val *next = unsafe_yyjson_get_next(cur + 1);
+            if (unsafe_yyjson_get_len(cur) == key_len &&
+                memcmp(cur->uni.str, key, key_len) == 0) {
+                iter->idx = idx;
+                iter->cur = next;
+                return cur + 1;
+            }
+            cur = next;
+            if (idx == iter->max && iter->idx < iter->max) {
+                idx = 0;
+                max = iter->idx;
+                cur = unsafe_yyjson_get_first(iter->obj);
+            }
+        }
+    }
+    return NULL;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Structure (Implementation)
+ *============================================================================*/
+
+/**
+ Mutable JSON value, 24 bytes.
+ The 'tag' and 'uni' field is same as immutable value.
+ The 'next' field links all elements inside the container to be a cycle.
+ */
+struct yyjson_mut_val {
+    uint64_t tag; /**< type, subtype and length */
+    yyjson_val_uni uni; /**< payload */
+    yyjson_mut_val *next; /**< the next value in circular linked list */
+};
+
+/**
+ A memory chunk in string memory pool.
+ */
+typedef struct yyjson_str_chunk {
+    struct yyjson_str_chunk *next; /* next chunk linked list */
+    size_t chunk_size; /* chunk size in bytes */
+    /* char str[]; flexible array member */
+} yyjson_str_chunk;
+
+/**
+ A memory pool to hold all strings in a mutable document.
+ */
+typedef struct yyjson_str_pool {
+    char *cur; /* cursor inside current chunk */
+    char *end; /* the end of current chunk */
+    size_t chunk_size; /* chunk size in bytes while creating new chunk */
+    size_t chunk_size_max; /* maximum chunk size in bytes */
+    yyjson_str_chunk *chunks; /* a linked list of chunks, nullable */
+} yyjson_str_pool;
+
+/**
+ A memory chunk in value memory pool.
+ `sizeof(yyjson_val_chunk)` should not larger than `sizeof(yyjson_mut_val)`.
+ */
+typedef struct yyjson_val_chunk {
+    struct yyjson_val_chunk *next; /* next chunk linked list */
+    size_t chunk_size; /* chunk size in bytes */
+    /* char pad[sizeof(yyjson_mut_val) - sizeof(yyjson_val_chunk)]; padding */
+    /* yyjson_mut_val vals[]; flexible array member */
+} yyjson_val_chunk;
+
+/**
+ A memory pool to hold all values in a mutable document.
+ */
+typedef struct yyjson_val_pool {
+    yyjson_mut_val *cur; /* cursor inside current chunk */
+    yyjson_mut_val *end; /* the end of current chunk */
+    size_t chunk_size; /* chunk size in bytes while creating new chunk */
+    size_t chunk_size_max; /* maximum chunk size in bytes */
+    yyjson_val_chunk *chunks; /* a linked list of chunks, nullable */
+} yyjson_val_pool;
+
+struct yyjson_mut_doc {
+    yyjson_mut_val *root; /**< root value of the JSON document, nullable */
+    yyjson_alc alc; /**< a valid allocator, nonnull */
+    yyjson_str_pool str_pool; /**< string memory pool */
+    yyjson_val_pool val_pool; /**< value memory pool */
+};
+
+/* Ensures the capacity to at least equal to the specified byte length. */
+yyjson_api bool unsafe_yyjson_str_pool_grow(yyjson_str_pool *pool,
+                                            const yyjson_alc *alc,
+                                            size_t len);
+
+/* Ensures the capacity to at least equal to the specified value count. */
+yyjson_api bool unsafe_yyjson_val_pool_grow(yyjson_val_pool *pool,
+                                            const yyjson_alc *alc,
+                                            size_t count);
+
+/* Allocate memory for string. */
+yyjson_api_inline char *unsafe_yyjson_mut_str_alc(yyjson_mut_doc *doc,
+                                                  size_t len) {
+    char *mem;
+    const yyjson_alc *alc = &doc->alc;
+    yyjson_str_pool *pool = &doc->str_pool;
+    if (yyjson_unlikely((size_t)(pool->end - pool->cur) <= len)) {
+        if (yyjson_unlikely(!unsafe_yyjson_str_pool_grow(pool, alc, len + 1))) {
+            return NULL;
+        }
+    }
+    mem = pool->cur;
+    pool->cur = mem + len + 1;
+    return mem;
+}
+
+yyjson_api_inline char *unsafe_yyjson_mut_strncpy(yyjson_mut_doc *doc,
+                                                  const char *str, size_t len) {
+    char *mem = unsafe_yyjson_mut_str_alc(doc, len);
+    if (yyjson_unlikely(!mem)) return NULL;
+    memcpy((void *)mem, (const void *)str, len);
+    mem[len] = '\0';
+    return mem;
+}
+
+yyjson_api_inline yyjson_mut_val *unsafe_yyjson_mut_val(yyjson_mut_doc *doc,
+                                                        size_t count) {
+    yyjson_mut_val *val;
+    yyjson_alc *alc = &doc->alc;
+    yyjson_val_pool *pool = &doc->val_pool;
+    if (yyjson_unlikely((size_t)(pool->end - pool->cur) < count)) {
+        if (yyjson_unlikely(!unsafe_yyjson_val_pool_grow(pool, alc, count))) {
+            return NULL;
+        }
+    }
+    val = pool->cur;
+    pool->cur += count;
+    return val;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Document API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_root(yyjson_mut_doc *doc) {
+    return doc ? doc->root : NULL;
+}
+
+yyjson_api_inline void yyjson_mut_doc_set_root(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *root) {
+    if (doc) doc->root = root;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Value Type API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline bool yyjson_mut_is_raw(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_raw(val) : false;
+}
+
+yyjson_api_inline bool yyjson_mut_is_null(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_null(val) : false;
+}
+
+yyjson_api_inline bool yyjson_mut_is_true(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_true(val) : false;
+}
+
+yyjson_api_inline bool yyjson_mut_is_false(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_false(val) : false;
+}
+
+yyjson_api_inline bool yyjson_mut_is_bool(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_bool(val) : false;
+}
+
+yyjson_api_inline bool yyjson_mut_is_uint(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_uint(val) : false;
+}
+
+yyjson_api_inline bool yyjson_mut_is_sint(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_sint(val) : false;
+}
+
+yyjson_api_inline bool yyjson_mut_is_int(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_int(val) : false;
+}
+
+yyjson_api_inline bool yyjson_mut_is_real(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_real(val) : false;
+}
+
+yyjson_api_inline bool yyjson_mut_is_num(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_num(val) : false;
+}
+
+yyjson_api_inline bool yyjson_mut_is_str(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_str(val) : false;
+}
+
+yyjson_api_inline bool yyjson_mut_is_arr(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_arr(val) : false;
+}
+
+yyjson_api_inline bool yyjson_mut_is_obj(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_obj(val) : false;
+}
+
+yyjson_api_inline bool yyjson_mut_is_ctn(yyjson_mut_val *val) {
+    return val ? unsafe_yyjson_is_ctn(val) : false;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Value Content API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline yyjson_type yyjson_mut_get_type(yyjson_mut_val *val) {
+    return yyjson_get_type((yyjson_val *)val);
+}
+
+yyjson_api_inline yyjson_subtype yyjson_mut_get_subtype(yyjson_mut_val *val) {
+    return yyjson_get_subtype((yyjson_val *)val);
+}
+
+yyjson_api_inline uint8_t yyjson_mut_get_tag(yyjson_mut_val *val) {
+    return yyjson_get_tag((yyjson_val *)val);
+}
+
+yyjson_api_inline const char *yyjson_mut_get_type_desc(yyjson_mut_val *val) {
+    return yyjson_get_type_desc((yyjson_val *)val);
+}
+
+yyjson_api_inline const char *yyjson_mut_get_raw(yyjson_mut_val *val) {
+    return yyjson_get_raw((yyjson_val *)val);
+}
+
+yyjson_api_inline bool yyjson_mut_get_bool(yyjson_mut_val *val) {
+    return yyjson_get_bool((yyjson_val *)val);
+}
+
+yyjson_api_inline uint64_t yyjson_mut_get_uint(yyjson_mut_val *val) {
+    return yyjson_get_uint((yyjson_val *)val);
+}
+
+yyjson_api_inline int64_t yyjson_mut_get_sint(yyjson_mut_val *val) {
+    return yyjson_get_sint((yyjson_val *)val);
+}
+
+yyjson_api_inline int yyjson_mut_get_int(yyjson_mut_val *val) {
+    return yyjson_get_int((yyjson_val *)val);
+}
+
+yyjson_api_inline double yyjson_mut_get_real(yyjson_mut_val *val) {
+    return yyjson_get_real((yyjson_val *)val);
+}
+
+yyjson_api_inline double yyjson_mut_get_num(yyjson_mut_val *val) {
+    return yyjson_get_num((yyjson_val *)val);
+}
+
+yyjson_api_inline const char *yyjson_mut_get_str(yyjson_mut_val *val) {
+    return yyjson_get_str((yyjson_val *)val);
+}
+
+yyjson_api_inline size_t yyjson_mut_get_len(yyjson_mut_val *val) {
+    return yyjson_get_len((yyjson_val *)val);
+}
+
+yyjson_api_inline bool yyjson_mut_equals_str(yyjson_mut_val *val,
+                                             const char *str) {
+    return yyjson_equals_str((yyjson_val *)val, str);
+}
+
+yyjson_api_inline bool yyjson_mut_equals_strn(yyjson_mut_val *val,
+                                              const char *str, size_t len) {
+    return yyjson_equals_strn((yyjson_val *)val, str, len);
+}
+
+yyjson_api bool unsafe_yyjson_mut_equals(yyjson_mut_val *lhs,
+                                         yyjson_mut_val *rhs);
+
+yyjson_api_inline bool yyjson_mut_equals(yyjson_mut_val *lhs,
+                                         yyjson_mut_val *rhs) {
+    if (yyjson_unlikely(!lhs || !rhs)) return false;
+    return unsafe_yyjson_mut_equals(lhs, rhs);
+}
+
+yyjson_api_inline bool yyjson_mut_set_raw(yyjson_mut_val *val,
+                                          const char *raw, size_t len) {
+    if (yyjson_unlikely(!val || !raw)) return false;
+    unsafe_yyjson_set_raw(val, raw, len);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_mut_set_null(yyjson_mut_val *val) {
+    if (yyjson_unlikely(!val)) return false;
+    unsafe_yyjson_set_null(val);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_mut_set_bool(yyjson_mut_val *val, bool num) {
+    if (yyjson_unlikely(!val)) return false;
+    unsafe_yyjson_set_bool(val, num);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_mut_set_uint(yyjson_mut_val *val, uint64_t num) {
+    if (yyjson_unlikely(!val)) return false;
+    unsafe_yyjson_set_uint(val, num);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_mut_set_sint(yyjson_mut_val *val, int64_t num) {
+    if (yyjson_unlikely(!val)) return false;
+    unsafe_yyjson_set_sint(val, num);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_mut_set_int(yyjson_mut_val *val, int num) {
+    if (yyjson_unlikely(!val)) return false;
+    unsafe_yyjson_set_sint(val, (int64_t)num);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_mut_set_real(yyjson_mut_val *val, double num) {
+    if (yyjson_unlikely(!val)) return false;
+    unsafe_yyjson_set_real(val, num);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_mut_set_str(yyjson_mut_val *val,
+                                          const char *str) {
+    if (yyjson_unlikely(!val || !str)) return false;
+    unsafe_yyjson_set_str(val, str);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_mut_set_strn(yyjson_mut_val *val,
+                                           const char *str, size_t len) {
+    if (yyjson_unlikely(!val || !str)) return false;
+    unsafe_yyjson_set_strn(val, str, len);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_mut_set_arr(yyjson_mut_val *val) {
+    if (yyjson_unlikely(!val)) return false;
+    unsafe_yyjson_set_arr(val, 0);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_mut_set_obj(yyjson_mut_val *val) {
+    if (yyjson_unlikely(!val)) return false;
+    unsafe_yyjson_set_obj(val, 0);
+    return true;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Value Creation API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_raw(yyjson_mut_doc *doc,
+                                                 const char *str) {
+    if (yyjson_likely(str)) return yyjson_mut_rawn(doc, str, strlen(str));
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_rawn(yyjson_mut_doc *doc,
+                                                  const char *str,
+                                                  size_t len) {
+    if (yyjson_likely(doc && str)) {
+        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
+        if (yyjson_likely(val)) {
+            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW;
+            val->uni.str = str;
+            return val;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_rawcpy(yyjson_mut_doc *doc,
+                                                    const char *str) {
+    if (yyjson_likely(str)) return yyjson_mut_rawncpy(doc, str, strlen(str));
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_rawncpy(yyjson_mut_doc *doc,
+                                                     const char *str,
+                                                     size_t len) {
+    if (yyjson_likely(doc && str)) {
+        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
+        char *new_str = unsafe_yyjson_mut_strncpy(doc, str, len);
+        if (yyjson_likely(val && new_str)) {
+            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW;
+            val->uni.str = new_str;
+            return val;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_null(yyjson_mut_doc *doc) {
+    if (yyjson_likely(doc)) {
+        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
+        if (yyjson_likely(val)) {
+            val->tag = YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE;
+            return val;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_true(yyjson_mut_doc *doc) {
+    if (yyjson_likely(doc)) {
+        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
+        if (yyjson_likely(val)) {
+            val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE;
+            return val;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_false(yyjson_mut_doc *doc) {
+    if (yyjson_likely(doc)) {
+        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
+        if (yyjson_likely(val)) {
+            val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE;
+            return val;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_bool(yyjson_mut_doc *doc,
+                                                  bool _val) {
+    if (yyjson_likely(doc)) {
+        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
+        if (yyjson_likely(val)) {
+            val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)_val << 3);
+            return val;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_uint(yyjson_mut_doc *doc,
+                                                  uint64_t num) {
+    if (yyjson_likely(doc)) {
+        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
+        if (yyjson_likely(val)) {
+            val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
+            val->uni.u64 = num;
+            return val;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_sint(yyjson_mut_doc *doc,
+                                                  int64_t num) {
+    if (yyjson_likely(doc)) {
+        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
+        if (yyjson_likely(val)) {
+            val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
+            val->uni.i64 = num;
+            return val;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_int(yyjson_mut_doc *doc,
+                                                 int64_t num) {
+    return yyjson_mut_sint(doc, num);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_real(yyjson_mut_doc *doc,
+                                                  double num) {
+    if (yyjson_likely(doc)) {
+        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
+        if (yyjson_likely(val)) {
+            val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
+            val->uni.f64 = num;
+            return val;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_str(yyjson_mut_doc *doc,
+                                                 const char *str) {
+    if (yyjson_likely(str)) return yyjson_mut_strn(doc, str, strlen(str));
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_strn(yyjson_mut_doc *doc,
+                                                  const char *str,
+                                                  size_t len) {
+    if (yyjson_likely(doc && str)) {
+        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
+        if (yyjson_likely(val)) {
+            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+            val->uni.str = str;
+            return val;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_strcpy(yyjson_mut_doc *doc,
+                                                    const char *str) {
+    if (yyjson_likely(str)) return yyjson_mut_strncpy(doc, str, strlen(str));
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_strncpy(yyjson_mut_doc *doc,
+                                                     const char *str,
+                                                     size_t len) {
+    if (yyjson_likely(doc && str)) {
+        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
+        char *new_str = unsafe_yyjson_mut_strncpy(doc, str, len);
+        if (yyjson_likely(val && new_str)) {
+            val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+            val->uni.str = new_str;
+            return val;
+        }
+    }
+    return NULL;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Array API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline size_t yyjson_mut_arr_size(yyjson_mut_val *arr) {
+    return yyjson_mut_is_arr(arr) ? unsafe_yyjson_get_len(arr) : 0;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get(yyjson_mut_val *arr,
+                                                     size_t idx) {
+    if (yyjson_likely(idx < yyjson_mut_arr_size(arr))) {
+        yyjson_mut_val *val = (yyjson_mut_val *)arr->uni.ptr;
+        while (idx-- > 0) val = val->next;
+        return val->next;
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_first(
+    yyjson_mut_val *arr) {
+    if (yyjson_likely(yyjson_mut_arr_size(arr) > 0)) {
+        return ((yyjson_mut_val *)arr->uni.ptr)->next;
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_last(
+    yyjson_mut_val *arr) {
+    if (yyjson_likely(yyjson_mut_arr_size(arr) > 0)) {
+        return ((yyjson_mut_val *)arr->uni.ptr);
+    }
+    return NULL;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Array Iterator API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline bool yyjson_mut_arr_iter_init(yyjson_mut_val *arr,
+                                                yyjson_mut_arr_iter *iter) {
+    if (yyjson_likely(yyjson_mut_is_arr(arr) && iter)) {
+        iter->idx = 0;
+        iter->max = unsafe_yyjson_get_len(arr);
+        iter->cur = iter->max ? (yyjson_mut_val *)arr->uni.ptr : NULL;
+        iter->pre = NULL;
+        iter->arr = arr;
+        return true;
+    }
+    if (iter) memset(iter, 0, sizeof(yyjson_mut_arr_iter));
+    return false;
+}
+
+yyjson_api_inline yyjson_mut_arr_iter yyjson_mut_arr_iter_with(
+    yyjson_mut_val *arr) {
+    yyjson_mut_arr_iter iter;
+    yyjson_mut_arr_iter_init(arr, &iter);
+    return iter;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_iter_has_next(yyjson_mut_arr_iter *iter) {
+    return iter ? iter->idx < iter->max : false;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_next(
+    yyjson_mut_arr_iter *iter) {
+    if (iter && iter->idx < iter->max) {
+        yyjson_mut_val *val = iter->cur;
+        iter->pre = val;
+        iter->cur = val->next;
+        iter->idx++;
+        return iter->cur;
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_remove(
+    yyjson_mut_arr_iter *iter) {
+    if (yyjson_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) {
+        yyjson_mut_val *prev = iter->pre;
+        yyjson_mut_val *cur = iter->cur;
+        yyjson_mut_val *next = cur->next;
+        if (yyjson_unlikely(iter->idx == iter->max)) iter->arr->uni.ptr = prev;
+        iter->idx--;
+        iter->max--;
+        unsafe_yyjson_set_len(iter->arr, iter->max);
+        prev->next = next;
+        iter->cur = next;
+        return cur;
+    }
+    return NULL;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Array Creation API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr(yyjson_mut_doc *doc) {
+    if (yyjson_likely(doc)) {
+        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
+        if (yyjson_likely(val)) {
+            val->tag = YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE;
+            return val;
+        }
+    }
+    return NULL;
+}
+
+#define yyjson_mut_arr_with_func(func) \
+    if (yyjson_likely(doc && ((0 < count && count < \
+        (~(size_t)0) / sizeof(yyjson_mut_val) && vals) || count == 0))) { \
+        yyjson_mut_val *arr = unsafe_yyjson_mut_val(doc, 1 + count); \
+        if (yyjson_likely(arr)) { \
+            arr->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_ARR; \
+            if (count > 0) { \
+                size_t i; \
+                for (i = 0; i < count; i++) { \
+                    yyjson_mut_val *val = arr + i + 1; \
+                    func \
+                    val->next = val + 1; \
+                } \
+                arr[count].next = arr + 1; \
+                arr->uni.ptr = arr + count; \
+            } \
+            return arr; \
+        } \
+    } \
+    return NULL
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_bool(
+    yyjson_mut_doc *doc, const bool *vals, size_t count) {
+    yyjson_mut_arr_with_func({
+        val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)vals[i] << 3);
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint(
+    yyjson_mut_doc *doc, const int64_t *vals, size_t count) {
+    return yyjson_mut_arr_with_sint64(doc, vals, count);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint(
+    yyjson_mut_doc *doc, const uint64_t *vals, size_t count) {
+    return yyjson_mut_arr_with_uint64(doc, vals, count);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_real(
+    yyjson_mut_doc *doc, const double *vals, size_t count) {
+    return yyjson_mut_arr_with_double(doc, vals, count);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint8(
+    yyjson_mut_doc *doc, const int8_t *vals, size_t count) {
+    yyjson_mut_arr_with_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
+        val->uni.i64 = (int64_t)vals[i];
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint16(
+    yyjson_mut_doc *doc, const int16_t *vals, size_t count) {
+    yyjson_mut_arr_with_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
+        val->uni.i64 = vals[i];
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint32(
+    yyjson_mut_doc *doc, const int32_t *vals, size_t count) {
+    yyjson_mut_arr_with_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
+        val->uni.i64 = vals[i];
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint64(
+    yyjson_mut_doc *doc, const int64_t *vals, size_t count) {
+    yyjson_mut_arr_with_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
+        val->uni.i64 = vals[i];
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint8(
+    yyjson_mut_doc *doc, const uint8_t *vals, size_t count) {
+    yyjson_mut_arr_with_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
+        val->uni.u64 = vals[i];
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint16(
+    yyjson_mut_doc *doc, const uint16_t *vals, size_t count) {
+    yyjson_mut_arr_with_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
+        val->uni.u64 = vals[i];
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint32(
+    yyjson_mut_doc *doc, const uint32_t *vals, size_t count) {
+    yyjson_mut_arr_with_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
+        val->uni.u64 = vals[i];
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint64(
+    yyjson_mut_doc *doc, const uint64_t *vals, size_t count) {
+    yyjson_mut_arr_with_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
+        val->uni.u64 = vals[i];
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_float(
+    yyjson_mut_doc *doc, const float *vals, size_t count) {
+    yyjson_mut_arr_with_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
+        val->uni.f64 = (double)vals[i];
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_double(
+    yyjson_mut_doc *doc, const double *vals, size_t count) {
+    yyjson_mut_arr_with_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
+        val->uni.f64 = vals[i];
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_str(
+    yyjson_mut_doc *doc, const char **vals, size_t count) {
+    yyjson_mut_arr_with_func({
+        uint64_t len = (uint64_t)strlen(vals[i]);
+        val->tag = (len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+        val->uni.str = vals[i];
+        if (yyjson_unlikely(!val->uni.str)) return NULL;
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strn(
+    yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count) {
+    if (yyjson_unlikely(count > 0 && !lens)) return NULL;
+    yyjson_mut_arr_with_func({
+        val->tag = ((uint64_t)lens[i] << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+        val->uni.str = vals[i];
+        if (yyjson_unlikely(!val->uni.str)) return NULL;
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strcpy(
+    yyjson_mut_doc *doc, const char **vals, size_t count) {
+    size_t len;
+    const char *str;
+    yyjson_mut_arr_with_func({
+        str = vals[i];
+        if (!str) return NULL;
+        len = strlen(str);
+        val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+        val->uni.str = unsafe_yyjson_mut_strncpy(doc, str, len);
+        if (yyjson_unlikely(!val->uni.str)) return NULL;
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strncpy(
+    yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count) {
+    size_t len;
+    const char *str;
+    if (yyjson_unlikely(count > 0 && !lens)) return NULL;
+    yyjson_mut_arr_with_func({
+        str = vals[i];
+        len = lens[i];
+        val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+        val->uni.str = unsafe_yyjson_mut_strncpy(doc, str, len);
+        if (yyjson_unlikely(!val->uni.str)) return NULL;
+    });
+}
+
+#undef yyjson_mut_arr_with_func
+
+
+
+/*==============================================================================
+ * Mutable JSON Array Modification API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline bool yyjson_mut_arr_insert(yyjson_mut_val *arr,
+                                             yyjson_mut_val *val, size_t idx) {
+    if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
+        size_t len = unsafe_yyjson_get_len(arr);
+        if (yyjson_likely(idx <= len)) {
+            unsafe_yyjson_set_len(arr, len + 1);
+            if (len == 0) {
+                val->next = val;
+                arr->uni.ptr = val;
+            } else {
+                yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
+                yyjson_mut_val *next = prev->next;
+                if (idx == len) {
+                    prev->next = val;
+                    val->next = next;
+                    arr->uni.ptr = val;
+                } else {
+                    while (idx-- > 0) {
+                        prev = next;
+                        next = next->next;
+                    }
+                    prev->next = val;
+                    val->next = next;
+                }
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_append(yyjson_mut_val *arr,
+                                             yyjson_mut_val *val) {
+    if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
+        size_t len = unsafe_yyjson_get_len(arr);
+        unsafe_yyjson_set_len(arr, len + 1);
+        if (len == 0) {
+            val->next = val;
+        } else {
+            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
+            yyjson_mut_val *next = prev->next;
+            prev->next = val;
+            val->next = next;
+        }
+        arr->uni.ptr = val;
+        return true;
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_prepend(yyjson_mut_val *arr,
+                                              yyjson_mut_val *val) {
+    if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
+        size_t len = unsafe_yyjson_get_len(arr);
+        unsafe_yyjson_set_len(arr, len + 1);
+        if (len == 0) {
+            val->next = val;
+            arr->uni.ptr = val;
+        } else {
+            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
+            yyjson_mut_val *next = prev->next;
+            prev->next = val;
+            val->next = next;
+        }
+        return true;
+    }
+    return false;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_replace(yyjson_mut_val *arr,
+                                                         size_t idx,
+                                                         yyjson_mut_val *val) {
+    if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) {
+        size_t len = unsafe_yyjson_get_len(arr);
+        if (yyjson_likely(idx < len)) {
+            if (yyjson_likely(len > 1)) {
+                yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
+                yyjson_mut_val *next = prev->next;
+                while (idx-- > 0) {
+                    prev = next;
+                    next = next->next;
+                }
+                prev->next = val;
+                val->next = next->next;
+                if ((void *)next == arr->uni.ptr) arr->uni.ptr = val;
+                return next;
+            } else {
+                yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
+                val->next = val;
+                arr->uni.ptr = val;
+                return prev;
+            }
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove(yyjson_mut_val *arr,
+                                                        size_t idx) {
+    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
+        size_t len = unsafe_yyjson_get_len(arr);
+        if (yyjson_likely(idx < len)) {
+            unsafe_yyjson_set_len(arr, len - 1);
+            if (yyjson_likely(len > 1)) {
+                yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
+                yyjson_mut_val *next = prev->next;
+                while (idx-- > 0) {
+                    prev = next;
+                    next = next->next;
+                }
+                prev->next = next->next;
+                if ((void *)next == arr->uni.ptr) arr->uni.ptr = prev;
+                return next;
+            } else {
+                return ((yyjson_mut_val *)arr->uni.ptr);
+            }
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_first(
+    yyjson_mut_val *arr) {
+    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
+        size_t len = unsafe_yyjson_get_len(arr);
+        if (len > 1) {
+            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
+            yyjson_mut_val *next = prev->next;
+            prev->next = next->next;
+            unsafe_yyjson_set_len(arr, len - 1);
+            return next;
+        } else if (len == 1) {
+            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
+            unsafe_yyjson_set_len(arr, 0);
+            return prev;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_last(
+    yyjson_mut_val *arr) {
+    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
+        size_t len = unsafe_yyjson_get_len(arr);
+        if (yyjson_likely(len > 1)) {
+            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
+            yyjson_mut_val *next = prev->next;
+            unsafe_yyjson_set_len(arr, len - 1);
+            while (--len > 0) prev = prev->next;
+            prev->next = next;
+            next = (yyjson_mut_val *)arr->uni.ptr;
+            arr->uni.ptr = prev;
+            return next;
+        } else if (len == 1) {
+            yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr);
+            unsafe_yyjson_set_len(arr, 0);
+            return prev;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_remove_range(yyjson_mut_val *arr,
+                                                   size_t _idx, size_t _len) {
+    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *prev, *next;
+        bool tail_removed;
+        size_t len = unsafe_yyjson_get_len(arr);
+        if (yyjson_unlikely(_idx + _len > len)) return false;
+        if (yyjson_unlikely(_len == 0)) return true;
+        unsafe_yyjson_set_len(arr, len - _len);
+        if (yyjson_unlikely(len == _len)) return true;
+        tail_removed = (_idx + _len == len);
+        prev = ((yyjson_mut_val *)arr->uni.ptr);
+        while (_idx-- > 0) prev = prev->next;
+        next = prev->next;
+        while (_len-- > 0) next = next->next;
+        prev->next = next;
+        if (yyjson_unlikely(tail_removed)) arr->uni.ptr = prev;
+        return true;
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_clear(yyjson_mut_val *arr) {
+    if (yyjson_likely(yyjson_mut_is_arr(arr))) {
+        unsafe_yyjson_set_len(arr, 0);
+        return true;
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_rotate(yyjson_mut_val *arr,
+                                             size_t idx) {
+    if (yyjson_likely(yyjson_mut_is_arr(arr) &&
+                      unsafe_yyjson_get_len(arr) > idx)) {
+        yyjson_mut_val *val = (yyjson_mut_val *)arr->uni.ptr;
+        while (idx-- > 0) val = val->next;
+        arr->uni.ptr = (void *)val;
+        return true;
+    }
+    return false;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Array Modification Convenience API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline bool yyjson_mut_arr_add_val(yyjson_mut_val *arr,
+                                              yyjson_mut_val *val) {
+    return yyjson_mut_arr_append(arr, val);
+}
+
+yyjson_api_inline bool yyjson_mut_arr_add_null(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_null(doc);
+        return yyjson_mut_arr_append(arr, val);
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_add_true(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_true(doc);
+        return yyjson_mut_arr_append(arr, val);
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_add_false(yyjson_mut_doc *doc,
+                                                yyjson_mut_val *arr) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_false(doc);
+        return yyjson_mut_arr_append(arr, val);
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_add_bool(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr,
+                                               bool _val) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_bool(doc, _val);
+        return yyjson_mut_arr_append(arr, val);
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_add_uint(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr,
+                                               uint64_t num) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_uint(doc, num);
+        return yyjson_mut_arr_append(arr, val);
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_add_sint(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr,
+                                               int64_t num) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_sint(doc, num);
+        return yyjson_mut_arr_append(arr, val);
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_add_int(yyjson_mut_doc *doc,
+                                              yyjson_mut_val *arr,
+                                              int64_t num) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_sint(doc, num);
+        return yyjson_mut_arr_append(arr, val);
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_add_real(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr,
+                                               double num) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_real(doc, num);
+        return yyjson_mut_arr_append(arr, val);
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_add_str(yyjson_mut_doc *doc,
+                                              yyjson_mut_val *arr,
+                                              const char *str) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_str(doc, str);
+        return yyjson_mut_arr_append(arr, val);
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_add_strn(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *arr,
+                                               const char *str, size_t len) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_strn(doc, str, len);
+        return yyjson_mut_arr_append(arr, val);
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_add_strcpy(yyjson_mut_doc *doc,
+                                                 yyjson_mut_val *arr,
+                                                 const char *str) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_strcpy(doc, str);
+        return yyjson_mut_arr_append(arr, val);
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_arr_add_strncpy(yyjson_mut_doc *doc,
+                                                  yyjson_mut_val *arr,
+                                                  const char *str, size_t len) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_strncpy(doc, str, len);
+        return yyjson_mut_arr_append(arr, val);
+    }
+    return false;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_arr(yyjson_mut_doc *doc,
+                                                         yyjson_mut_val *arr) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_arr(doc);
+        return yyjson_mut_arr_append(arr, val) ? val : NULL;
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_obj(yyjson_mut_doc *doc,
+                                                         yyjson_mut_val *arr) {
+    if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) {
+        yyjson_mut_val *val = yyjson_mut_obj(doc);
+        return yyjson_mut_arr_append(arr, val) ? val : NULL;
+    }
+    return NULL;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Object API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline size_t yyjson_mut_obj_size(yyjson_mut_val *obj) {
+    return yyjson_mut_is_obj(obj) ? unsafe_yyjson_get_len(obj) : 0;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_get(yyjson_mut_val *obj,
+                                                     const char *key) {
+    return yyjson_mut_obj_getn(obj, key, key ? strlen(key) : 0);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_getn(yyjson_mut_val *obj,
+                                                      const char *_key,
+                                                      size_t key_len) {
+    uint64_t tag = (((uint64_t)key_len) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+    size_t len = yyjson_mut_obj_size(obj);
+    if (yyjson_likely(len && _key)) {
+        yyjson_mut_val *key = ((yyjson_mut_val *)obj->uni.ptr)->next->next;
+        while (len-- > 0) {
+            if (key->tag == tag &&
+                memcmp(key->uni.ptr, _key, key_len) == 0) {
+                return key->next;
+            }
+            key = key->next->next;
+        }
+    }
+    return NULL;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Object Iterator API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline bool yyjson_mut_obj_iter_init(yyjson_mut_val *obj,
+                                                yyjson_mut_obj_iter *iter) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj) && iter)) {
+        iter->idx = 0;
+        iter->max = unsafe_yyjson_get_len(obj);
+        iter->cur = iter->max ? (yyjson_mut_val *)obj->uni.ptr : NULL;
+        iter->pre = NULL;
+        iter->obj = obj;
+        return true;
+    }
+    if (iter) memset(iter, 0, sizeof(yyjson_mut_obj_iter));
+    return false;
+}
+
+yyjson_api_inline yyjson_mut_obj_iter yyjson_mut_obj_iter_with(
+    yyjson_mut_val *obj) {
+    yyjson_mut_obj_iter iter;
+    yyjson_mut_obj_iter_init(obj, &iter);
+    return iter;
+}
+
+yyjson_api_inline bool yyjson_mut_obj_iter_has_next(yyjson_mut_obj_iter *iter) {
+    return iter ? iter->idx < iter->max : false;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_next(
+    yyjson_mut_obj_iter *iter) {
+    if (iter && iter->idx < iter->max) {
+        yyjson_mut_val *key = iter->cur;
+        iter->pre = key;
+        iter->cur = key->next->next;
+        iter->idx++;
+        return iter->cur;
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get_val(
+    yyjson_mut_val *key) {
+    return key ? key->next : NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_remove(
+    yyjson_mut_obj_iter *iter) {
+    if (yyjson_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) {
+        yyjson_mut_val *prev = iter->pre;
+        yyjson_mut_val *cur = iter->cur;
+        yyjson_mut_val *next = cur->next->next;
+        if (yyjson_unlikely(iter->idx == iter->max)) iter->obj->uni.ptr = prev;
+        iter->idx--;
+        iter->max--;
+        unsafe_yyjson_set_len(iter->obj, iter->max);
+        prev->next->next = next;
+        iter->cur = prev;
+        return cur->next;
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get(
+    yyjson_mut_obj_iter *iter, const char *key) {
+    return yyjson_mut_obj_iter_getn(iter, key, key ? strlen(key) : 0);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_getn(
+    yyjson_mut_obj_iter *iter, const char *key, size_t key_len) {
+    if (iter && key) {
+        size_t idx = 0;
+        size_t max = iter->max;
+        yyjson_mut_val *pre, *cur = iter->cur;
+        while (idx++ < max) {
+            pre = cur;
+            cur = cur->next->next;
+            if (unsafe_yyjson_get_len(cur) == key_len &&
+                memcmp(cur->uni.str, key, key_len) == 0) {
+                iter->idx += idx;
+                if (iter->idx > max) iter->idx -= max + 1;
+                iter->pre = pre;
+                iter->cur = cur;
+                return cur->next;
+            }
+        }
+    }
+    return NULL;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Object Creation API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj(yyjson_mut_doc *doc) {
+    if (yyjson_likely(doc)) {
+        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
+        if (yyjson_likely(val)) {
+            val->tag = YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE;
+            return val;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_str(yyjson_mut_doc *doc,
+                                                          const char **keys,
+                                                          const char **vals,
+                                                          size_t count) {
+    if (yyjson_likely(doc && ((count > 0 && keys && vals) || (count == 0)))) {
+        yyjson_mut_val *obj = unsafe_yyjson_mut_val(doc, 1 + count * 2);
+        if (yyjson_likely(obj)) {
+            obj->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_OBJ;
+            if (count > 0) {
+                size_t i;
+                for (i = 0; i < count; i++) {
+                    yyjson_mut_val *key = obj + (i * 2 + 1);
+                    yyjson_mut_val *val = obj + (i * 2 + 2);
+                    uint64_t key_len = (uint64_t)strlen(keys[i]);
+                    uint64_t val_len = (uint64_t)strlen(vals[i]);
+                    key->tag = (key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+                    val->tag = (val_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+                    key->uni.str = keys[i];
+                    val->uni.str = vals[i];
+                    key->next = val;
+                    val->next = val + 1;
+                }
+                obj[count * 2].next = obj + 1;
+                obj->uni.ptr = obj + (count * 2 - 1);
+            }
+            return obj;
+        }
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_kv(yyjson_mut_doc *doc,
+                                                         const char **pairs,
+                                                         size_t count) {
+    if (yyjson_likely(doc && ((count > 0 && pairs) || (count == 0)))) {
+        yyjson_mut_val *obj = unsafe_yyjson_mut_val(doc, 1 + count * 2);
+        if (yyjson_likely(obj)) {
+            obj->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_OBJ;
+            if (count > 0) {
+                size_t i;
+                for (i = 0; i < count; i++) {
+                    yyjson_mut_val *key = obj + (i * 2 + 1);
+                    yyjson_mut_val *val = obj + (i * 2 + 2);
+                    const char *key_str = pairs[i * 2 + 0];
+                    const char *val_str = pairs[i * 2 + 1];
+                    uint64_t key_len = (uint64_t)strlen(key_str);
+                    uint64_t val_len = (uint64_t)strlen(val_str);
+                    key->tag = (key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+                    val->tag = (val_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+                    key->uni.str = key_str;
+                    val->uni.str = val_str;
+                    key->next = val;
+                    val->next = val + 1;
+                }
+                obj[count * 2].next = obj + 1;
+                obj->uni.ptr = obj + (count * 2 - 1);
+            }
+            return obj;
+        }
+    }
+    return NULL;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Object Modification API (Implementation)
+ *============================================================================*/
+
+yyjson_api_inline void unsafe_yyjson_mut_obj_add(yyjson_mut_val *obj,
+                                                 yyjson_mut_val *key,
+                                                 yyjson_mut_val *val,
+                                                 size_t len) {
+    if (yyjson_likely(len)) {
+        yyjson_mut_val *prev_val = ((yyjson_mut_val *)obj->uni.ptr)->next;
+        yyjson_mut_val *next_key = prev_val->next;
+        prev_val->next = key;
+        val->next = next_key;
+    } else {
+        val->next = key;
+    }
+    key->next = val;
+    obj->uni.ptr = (void *)key;
+    unsafe_yyjson_set_len(obj, len + 1);
+}
+
+yyjson_api_inline yyjson_mut_val *unsafe_yyjson_mut_obj_remove(
+    yyjson_mut_val *obj, const char *key, size_t key_len, uint64_t key_tag) {
+    size_t obj_len = unsafe_yyjson_get_len(obj);
+    if (obj_len) {
+        yyjson_mut_val *pre_key = (yyjson_mut_val *)obj->uni.ptr;
+        yyjson_mut_val *cur_key = pre_key->next->next;
+        yyjson_mut_val *removed_item = NULL;
+        size_t i;
+        for (i = 0; i < obj_len; i++) {
+            if (key_tag == cur_key->tag &&
+                memcmp(key, cur_key->uni.ptr, key_len) == 0) {
+                if (!removed_item) removed_item = cur_key->next;
+                cur_key = cur_key->next->next;
+                pre_key->next->next = cur_key;
+                if (i + 1 == obj_len) obj->uni.ptr = pre_key;
+                i--;
+                obj_len--;
+            } else {
+                pre_key = cur_key;
+                cur_key = cur_key->next->next;
+            }
+        }
+        unsafe_yyjson_set_len(obj, obj_len);
+        return removed_item;
+    } else {
+        return NULL;
+    }
+}
+
+yyjson_api_inline bool unsafe_yyjson_mut_obj_replace(yyjson_mut_val *obj,
+                                                     yyjson_mut_val *key,
+                                                     yyjson_mut_val *val) {
+    size_t key_len = unsafe_yyjson_get_len(key);
+    size_t obj_len = unsafe_yyjson_get_len(obj);
+    if (obj_len) {
+        yyjson_mut_val *pre_key = (yyjson_mut_val *)obj->uni.ptr;
+        yyjson_mut_val *cur_key = pre_key->next->next;
+        size_t i;
+        for (i = 0; i < obj_len; i++) {
+            if (key->tag == cur_key->tag &&
+                memcmp(key->uni.str, cur_key->uni.ptr, key_len) == 0) {
+                cur_key->next->tag = val->tag;
+                cur_key->next->uni.u64 = val->uni.u64;
+                return true;
+            } else {
+                cur_key = cur_key->next->next;
+            }
+        }
+    }
+    return false;
+}
+
+yyjson_api_inline void unsafe_yyjson_mut_obj_rotate(yyjson_mut_val *obj,
+                                                    size_t idx) {
+    yyjson_mut_val *key = (yyjson_mut_val *)obj->uni.ptr;
+    while (idx-- > 0) key = key->next->next;
+    obj->uni.ptr = (void *)key;
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add(yyjson_mut_val *obj,
+                                          yyjson_mut_val *key,
+                                          yyjson_mut_val *val) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj) &&
+                      yyjson_mut_is_str(key) && val)) {
+        unsafe_yyjson_mut_obj_add(obj, key, val, unsafe_yyjson_get_len(obj));
+        return true;
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_obj_put(yyjson_mut_val *obj,
+                                          yyjson_mut_val *key,
+                                          yyjson_mut_val *val) {
+    bool replaced = false;
+    size_t key_len;
+    yyjson_mut_obj_iter iter;
+    yyjson_mut_val *cur_key;
+    if (yyjson_unlikely(!yyjson_mut_is_obj(obj) ||
+                        !yyjson_mut_is_str(key))) return false;
+    key_len = unsafe_yyjson_get_len(key);
+    yyjson_mut_obj_iter_init(obj, &iter);
+    while ((cur_key = yyjson_mut_obj_iter_next(&iter))) {
+        if (key->tag == cur_key->tag &&
+            memcmp(key->uni.str, cur_key->uni.ptr, key_len) == 0) {
+            if (!replaced && val) {
+                replaced = true;
+                val->next = cur_key->next->next;
+                cur_key->next = val;
+            } else {
+                yyjson_mut_obj_iter_remove(&iter);
+            }
+        }
+    }
+    if (!replaced && val) unsafe_yyjson_mut_obj_add(obj, key, val, iter.max);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_mut_obj_insert(yyjson_mut_val *obj,
+                                             yyjson_mut_val *key,
+                                             yyjson_mut_val *val,
+                                             size_t idx) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj) &&
+                      yyjson_mut_is_str(key) && val)) {
+        size_t len = unsafe_yyjson_get_len(obj);
+        if (yyjson_likely(len >= idx)) {
+            if (len > idx) {
+                void *ptr = obj->uni.ptr;
+                unsafe_yyjson_mut_obj_rotate(obj, idx);
+                unsafe_yyjson_mut_obj_add(obj, key, val, len);
+                obj->uni.ptr = ptr;
+            } else {
+                unsafe_yyjson_mut_obj_add(obj, key, val, len);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove(yyjson_mut_val *obj,
+    yyjson_mut_val *key) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj) && yyjson_mut_is_str(key))) {
+        return unsafe_yyjson_mut_obj_remove(obj, key->uni.str,
+                                            unsafe_yyjson_get_len(key),
+                                            key->tag);
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_key(
+    yyjson_mut_val *obj, const char *key) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj) && key)) {
+        size_t key_len = strlen(key);
+        uint64_t tag = ((uint64_t)key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+        return unsafe_yyjson_mut_obj_remove(obj, key, key_len, tag);
+    }
+    return NULL;
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_keyn(
+    yyjson_mut_val *obj, const char *key, size_t key_len) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj) && key)) {
+        uint64_t tag = ((uint64_t)key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+        return unsafe_yyjson_mut_obj_remove(obj, key, key_len, tag);
+    }
+    return NULL;
+}
+
+yyjson_api_inline bool yyjson_mut_obj_clear(yyjson_mut_val *obj) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj))) {
+        unsafe_yyjson_set_len(obj, 0);
+        return true;
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_obj_replace(yyjson_mut_val *obj,
+                                              yyjson_mut_val *key,
+                                              yyjson_mut_val *val) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj) &&
+                      yyjson_mut_is_str(key) && val)) {
+        return unsafe_yyjson_mut_obj_replace(obj, key, val);
+    }
+    return false;
+}
+
+yyjson_api_inline bool yyjson_mut_obj_rotate(yyjson_mut_val *obj,
+                                             size_t idx) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj) &&
+                      unsafe_yyjson_get_len(obj) > idx)) {
+        unsafe_yyjson_mut_obj_rotate(obj, idx);
+        return true;
+    }
+    return false;
+}
+
+
+
+/*==============================================================================
+ * Mutable JSON Object Modification Convenience API (Implementation)
+ *============================================================================*/
+
+#define yyjson_mut_obj_add_func(func) \
+    if (yyjson_likely(doc && yyjson_mut_is_obj(obj) && _key)) { \
+        yyjson_mut_val *key = unsafe_yyjson_mut_val(doc, 2); \
+        if (yyjson_likely(key)) { \
+            size_t len = unsafe_yyjson_get_len(obj); \
+            yyjson_mut_val *val = key + 1; \
+            key->tag = YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE; \
+            key->tag |= (uint64_t)strlen(_key) << YYJSON_TAG_BIT; \
+            key->uni.str = _key; \
+            func \
+            unsafe_yyjson_mut_obj_add(obj, key, val, len); \
+            return true; \
+        } \
+    } \
+    return false
+
+yyjson_api_inline bool yyjson_mut_obj_add_null(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *_key) {
+    yyjson_mut_obj_add_func({
+        val->tag = YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE;
+    });
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add_true(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *_key) {
+    yyjson_mut_obj_add_func({
+        val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE;
+    });
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add_false(yyjson_mut_doc *doc,
+                                                yyjson_mut_val *obj,
+                                                const char *_key) {
+    yyjson_mut_obj_add_func({
+        val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE;
+    });
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add_bool(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *_key,
+                                               bool _val) {
+    yyjson_mut_obj_add_func({
+        val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)(_val) << 3);
+    });
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add_uint(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *_key,
+                                               uint64_t _val) {
+    yyjson_mut_obj_add_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT;
+        val->uni.u64 = _val;
+    });
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add_sint(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *_key,
+                                               int64_t _val) {
+    yyjson_mut_obj_add_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
+        val->uni.i64 = _val;
+    });
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add_int(yyjson_mut_doc *doc,
+                                              yyjson_mut_val *obj,
+                                              const char *_key,
+                                              int64_t _val) {
+    yyjson_mut_obj_add_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT;
+        val->uni.i64 = _val;
+    });
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add_real(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *_key,
+                                               double _val) {
+    yyjson_mut_obj_add_func({
+        val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
+        val->uni.f64 = _val;
+    });
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add_str(yyjson_mut_doc *doc,
+                                              yyjson_mut_val *obj,
+                                              const char *_key,
+                                              const char *_val) {
+    if (yyjson_unlikely(!_val)) return false;
+    yyjson_mut_obj_add_func({
+        val->tag = ((uint64_t)strlen(_val) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+        val->uni.str = _val;
+    });
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add_strn(yyjson_mut_doc *doc,
+                                               yyjson_mut_val *obj,
+                                               const char *_key,
+                                               const char *_val,
+                                               size_t _len) {
+    if (yyjson_unlikely(!_val)) return false;
+    yyjson_mut_obj_add_func({
+        val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+        val->uni.str = _val;
+    });
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add_strcpy(yyjson_mut_doc *doc,
+                                                 yyjson_mut_val *obj,
+                                                 const char *_key,
+                                                 const char *_val) {
+    if (yyjson_unlikely(!_val)) return false;
+    yyjson_mut_obj_add_func({
+        size_t _len = strlen(_val);
+        val->uni.str = unsafe_yyjson_mut_strncpy(doc, _val, _len);
+        if (yyjson_unlikely(!val->uni.str)) return false;
+        val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+    });
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add_strncpy(yyjson_mut_doc *doc,
+                                                  yyjson_mut_val *obj,
+                                                  const char *_key,
+                                                  const char *_val,
+                                                  size_t _len) {
+    if (yyjson_unlikely(!_val)) return false;
+    yyjson_mut_obj_add_func({
+        val->uni.str = unsafe_yyjson_mut_strncpy(doc, _val, _len);
+        if (yyjson_unlikely(!val->uni.str)) return false;
+        val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
+    });
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add_val(yyjson_mut_doc *doc,
+                                              yyjson_mut_val *obj,
+                                              const char *_key,
+                                              yyjson_mut_val *_val) {
+    if (yyjson_unlikely(!_val)) return false;
+    yyjson_mut_obj_add_func({
+        val = _val;
+    });
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_str(yyjson_mut_val *obj,
+                                                            const char *key) {
+    return yyjson_mut_obj_remove_strn(obj, key, key ? strlen(key) : 0);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_strn(
+    yyjson_mut_val *obj, const char *_key, size_t _len) {
+    if (yyjson_likely(yyjson_mut_is_obj(obj) && _key)) {
+        yyjson_mut_val *key;
+        yyjson_mut_obj_iter iter;
+        yyjson_mut_val *val_removed = NULL;
+        yyjson_mut_obj_iter_init(obj, &iter);
+        while ((key = yyjson_mut_obj_iter_next(&iter)) != NULL) {
+            if (unsafe_yyjson_get_len(key) == _len &&
+                memcmp(key->uni.str, _key, _len) == 0) {
+                if (!val_removed) val_removed = key->next;
+                yyjson_mut_obj_iter_remove(&iter);
+            }
+        }
+        return val_removed;
+    }
+    return NULL;
+}
+
+yyjson_api_inline bool yyjson_mut_obj_rename_key(yyjson_mut_doc *doc,
+                                                 yyjson_mut_val *obj,
+                                                 const char *key,
+                                                 const char *new_key) {
+    if (!key || !new_key) return false;
+    return yyjson_mut_obj_rename_keyn(doc, obj, key, strlen(key),
+                                      new_key, strlen(new_key));
+}
+
+yyjson_api_inline bool yyjson_mut_obj_rename_keyn(yyjson_mut_doc *doc,
+                                                  yyjson_mut_val *obj,
+                                                  const char *key,
+                                                  size_t len,
+                                                  const char *new_key,
+                                                  size_t new_len) {
+    char *cpy_key = NULL;
+    yyjson_mut_val *old_key;
+    yyjson_mut_obj_iter iter;
+    if (!doc || !obj || !key || !new_key) return false;
+    yyjson_mut_obj_iter_init(obj, &iter);
+    while ((old_key = yyjson_mut_obj_iter_next(&iter))) {
+        if (unsafe_yyjson_equals_strn((void *)old_key, key, len)) {
+            if (!cpy_key) {
+                cpy_key = unsafe_yyjson_mut_strncpy(doc, new_key, new_len);
+                if (!cpy_key) return false;
+            }
+            yyjson_mut_set_strn(old_key, cpy_key, new_len);
+        }
+    }
+    return cpy_key != NULL;
+}
+
+
+
+/*==============================================================================
+ * JSON Pointer API (Implementation)
+ *============================================================================*/
+
+#define yyjson_ptr_set_err(_code, _msg) do { \
+    if (err) { \
+        err->code = YYJSON_PTR_ERR_##_code; \
+        err->msg = _msg; \
+        err->pos = 0; \
+    } \
+} while(false)
+
+/* require: val != NULL, *ptr == '/', len > 0 */
+yyjson_api yyjson_val *unsafe_yyjson_ptr_getx(yyjson_val *val,
+                                              const char *ptr, size_t len,
+                                              yyjson_ptr_err *err);
+
+/* require: val != NULL, *ptr == '/', len > 0 */
+yyjson_api yyjson_mut_val *unsafe_yyjson_mut_ptr_getx(yyjson_mut_val *val,
+                                                      const char *ptr,
+                                                      size_t len,
+                                                      yyjson_ptr_ctx *ctx,
+                                                      yyjson_ptr_err *err);
+
+/* require: val/new_val/doc != NULL, *ptr == '/', len > 0 */
+yyjson_api bool unsafe_yyjson_mut_ptr_putx(yyjson_mut_val *val,
+                                           const char *ptr, size_t len,
+                                           yyjson_mut_val *new_val,
+                                           yyjson_mut_doc *doc,
+                                           bool create_parent, bool insert_new,
+                                           yyjson_ptr_ctx *ctx,
+                                           yyjson_ptr_err *err);
+
+/* require: val/err != NULL, *ptr == '/', len > 0 */
+yyjson_api yyjson_mut_val *unsafe_yyjson_mut_ptr_replacex(
+    yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val,
+    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err);
+
+/* require: val/err != NULL, *ptr == '/', len > 0 */
+yyjson_api yyjson_mut_val *unsafe_yyjson_mut_ptr_removex(yyjson_mut_val *val,
+                                                         const char *ptr,
+                                                         size_t len,
+                                                         yyjson_ptr_ctx *ctx,
+                                                         yyjson_ptr_err *err);
+
+yyjson_api_inline yyjson_val *yyjson_doc_ptr_get(yyjson_doc *doc,
+                                                 const char *ptr) {
+    if (yyjson_unlikely(!ptr)) return NULL;
+    return yyjson_doc_ptr_getn(doc, ptr, strlen(ptr));
+}
+
+yyjson_api_inline yyjson_val *yyjson_doc_ptr_getn(yyjson_doc *doc,
+                                                  const char *ptr, size_t len) {
+    return yyjson_doc_ptr_getx(doc, ptr, len, NULL);
+}
+
+yyjson_api_inline yyjson_val *yyjson_doc_ptr_getx(yyjson_doc *doc,
+                                                  const char *ptr, size_t len,
+                                                  yyjson_ptr_err *err) {
+    yyjson_ptr_set_err(NONE, NULL);
+    if (yyjson_unlikely(!doc || !ptr)) {
+        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
+        return NULL;
+    }
+    if (yyjson_unlikely(!doc->root)) {
+        yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
+        return NULL;
+    }
+    if (yyjson_unlikely(len == 0)) {
+        return doc->root;
+    }
+    if (yyjson_unlikely(*ptr != '/')) {
+        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
+        return NULL;
+    }
+    return unsafe_yyjson_ptr_getx(doc->root, ptr, len, err);
+}
+
+yyjson_api_inline yyjson_val *yyjson_ptr_get(yyjson_val *val,
+                                             const char *ptr) {
+    if (yyjson_unlikely(!ptr)) return NULL;
+    return yyjson_ptr_getn(val, ptr, strlen(ptr));
+}
+
+yyjson_api_inline yyjson_val *yyjson_ptr_getn(yyjson_val *val,
+                                              const char *ptr, size_t len) {
+    return yyjson_ptr_getx(val, ptr, len, NULL);
+}
+
+yyjson_api_inline yyjson_val *yyjson_ptr_getx(yyjson_val *val,
+                                              const char *ptr, size_t len,
+                                              yyjson_ptr_err *err) {
+    yyjson_ptr_set_err(NONE, NULL);
+    if (yyjson_unlikely(!val || !ptr)) {
+        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
+        return NULL;
+    }
+    if (yyjson_unlikely(len == 0)) {
+        return val;
+    }
+    if (yyjson_unlikely(*ptr != '/')) {
+        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
+        return NULL;
+    }
+    return unsafe_yyjson_ptr_getx(val, ptr, len, err);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_get(yyjson_mut_doc *doc,
+                                                         const char *ptr) {
+    if (!ptr) return NULL;
+    return yyjson_mut_doc_ptr_getn(doc, ptr, strlen(ptr));
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_getn(yyjson_mut_doc *doc,
+                                                          const char *ptr,
+                                                          size_t len) {
+    return yyjson_mut_doc_ptr_getx(doc, ptr, len, NULL, NULL);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_getx(yyjson_mut_doc *doc,
+                                                          const char *ptr,
+                                                          size_t len,
+                                                          yyjson_ptr_ctx *ctx,
+                                                          yyjson_ptr_err *err) {
+    yyjson_ptr_set_err(NONE, NULL);
+    if (ctx) memset(ctx, 0, sizeof(*ctx));
+    
+    if (yyjson_unlikely(!doc || !ptr)) {
+        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
+        return NULL;
+    }
+    if (yyjson_unlikely(!doc->root)) {
+        yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
+        return NULL;
+    }
+    if (yyjson_unlikely(len == 0)) {
+        return doc->root;
+    }
+    if (yyjson_unlikely(*ptr != '/')) {
+        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
+        return NULL;
+    }
+    return unsafe_yyjson_mut_ptr_getx(doc->root, ptr, len, ctx, err);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_get(yyjson_mut_val *val,
+                                                     const char *ptr) {
+    if (!ptr) return NULL;
+    return yyjson_mut_ptr_getn(val, ptr, strlen(ptr));
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_getn(yyjson_mut_val *val,
+                                                      const char *ptr,
+                                                      size_t len) {
+    return yyjson_mut_ptr_getx(val, ptr, len, NULL, NULL);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_getx(yyjson_mut_val *val,
+                                                      const char *ptr,
+                                                      size_t len,
+                                                      yyjson_ptr_ctx *ctx,
+                                                      yyjson_ptr_err *err) {
+    yyjson_ptr_set_err(NONE, NULL);
+    if (ctx) memset(ctx, 0, sizeof(*ctx));
+    
+    if (yyjson_unlikely(!val || !ptr)) {
+        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
+        return NULL;
+    }
+    if (yyjson_unlikely(len == 0)) {
+        return val;
+    }
+    if (yyjson_unlikely(*ptr != '/')) {
+        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
+        return NULL;
+    }
+    return unsafe_yyjson_mut_ptr_getx(val, ptr, len, ctx, err);
+}
+
+yyjson_api_inline bool yyjson_mut_doc_ptr_add(yyjson_mut_doc *doc,
+                                              const char *ptr,
+                                              yyjson_mut_val *new_val) {
+    if (yyjson_unlikely(!ptr)) return false;
+    return yyjson_mut_doc_ptr_addn(doc, ptr, strlen(ptr), new_val);
+}
+
+yyjson_api_inline bool yyjson_mut_doc_ptr_addn(yyjson_mut_doc *doc,
+                                               const char *ptr,
+                                               size_t len,
+                                               yyjson_mut_val *new_val) {
+    return yyjson_mut_doc_ptr_addx(doc, ptr, len, new_val, true, NULL, NULL);
+}
+
+yyjson_api_inline bool yyjson_mut_doc_ptr_addx(yyjson_mut_doc *doc,
+                                               const char *ptr, size_t len,
+                                               yyjson_mut_val *new_val,
+                                               bool create_parent,
+                                               yyjson_ptr_ctx *ctx,
+                                               yyjson_ptr_err *err) {
+    yyjson_ptr_set_err(NONE, NULL);
+    if (ctx) memset(ctx, 0, sizeof(*ctx));
+    
+    if (yyjson_unlikely(!doc || !ptr || !new_val)) {
+        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
+        return false;
+    }
+    if (yyjson_unlikely(len == 0)) {
+        if (doc->root) {
+            yyjson_ptr_set_err(SET_ROOT, "cannot set document's root");
+            return false;
+        } else {
+            doc->root = new_val;
+            return true;
+        }
+    }
+    if (yyjson_unlikely(*ptr != '/')) {
+        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
+        return false;
+    }
+    if (yyjson_unlikely(!doc->root && !create_parent)) {
+        yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
+        return false;
+    }
+    if (yyjson_unlikely(!doc->root)) {
+        yyjson_mut_val *root = yyjson_mut_obj(doc);
+        if (yyjson_unlikely(!root)) {
+            yyjson_ptr_set_err(MEMORY_ALLOCATION, "failed to create value");
+            return false;
+        }
+        if (unsafe_yyjson_mut_ptr_putx(root, ptr, len, new_val, doc,
+                                       create_parent, true, ctx, err)) {
+            doc->root = root;
+            return true;
+        }
+        return false;
+    }
+    return unsafe_yyjson_mut_ptr_putx(doc->root, ptr, len, new_val, doc,
+                                      create_parent, true, ctx, err);
+}
+
+yyjson_api_inline bool yyjson_mut_ptr_add(yyjson_mut_val *val,
+                                          const char *ptr,
+                                          yyjson_mut_val *new_val,
+                                          yyjson_mut_doc *doc) {
+    if (yyjson_unlikely(!ptr)) return false;
+    return yyjson_mut_ptr_addn(val, ptr, strlen(ptr), new_val, doc);
+}
+
+yyjson_api_inline bool yyjson_mut_ptr_addn(yyjson_mut_val *val,
+                                           const char *ptr, size_t len,
+                                           yyjson_mut_val *new_val,
+                                           yyjson_mut_doc *doc) {
+    return yyjson_mut_ptr_addx(val, ptr, len, new_val, doc, true, NULL, NULL);
+}
+
+yyjson_api_inline bool yyjson_mut_ptr_addx(yyjson_mut_val *val,
+                                           const char *ptr, size_t len,
+                                           yyjson_mut_val *new_val,
+                                           yyjson_mut_doc *doc,
+                                           bool create_parent,
+                                           yyjson_ptr_ctx *ctx,
+                                           yyjson_ptr_err *err) {
+    yyjson_ptr_set_err(NONE, NULL);
+    if (ctx) memset(ctx, 0, sizeof(*ctx));
+    
+    if (yyjson_unlikely(!val || !ptr || !new_val || !doc)) {
+        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
+        return false;
+    }
+    if (yyjson_unlikely(len == 0)) {
+        yyjson_ptr_set_err(SET_ROOT, "cannot set root");
+        return false;
+    }
+    if (yyjson_unlikely(*ptr != '/')) {
+        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
+        return false;
+    }
+    return unsafe_yyjson_mut_ptr_putx(val, ptr, len, new_val,
+                                       doc, create_parent, true, ctx, err);
+}
+
+yyjson_api_inline bool yyjson_mut_doc_ptr_set(yyjson_mut_doc *doc,
+                                              const char *ptr,
+                                              yyjson_mut_val *new_val) {
+    if (yyjson_unlikely(!ptr)) return false;
+    return yyjson_mut_doc_ptr_setn(doc, ptr, strlen(ptr), new_val);
+}
+
+yyjson_api_inline bool yyjson_mut_doc_ptr_setn(yyjson_mut_doc *doc,
+                                               const char *ptr, size_t len,
+                                               yyjson_mut_val *new_val) {
+    return yyjson_mut_doc_ptr_setx(doc, ptr, len, new_val, true, NULL, NULL);
+}
+
+yyjson_api_inline bool yyjson_mut_doc_ptr_setx(yyjson_mut_doc *doc,
+                                               const char *ptr, size_t len,
+                                               yyjson_mut_val *new_val,
+                                               bool create_parent,
+                                               yyjson_ptr_ctx *ctx,
+                                               yyjson_ptr_err *err) {
+    yyjson_ptr_set_err(NONE, NULL);
+    if (ctx) memset(ctx, 0, sizeof(*ctx));
+    
+    if (yyjson_unlikely(!doc || !ptr)) {
+        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
+        return false;
+    }
+    if (yyjson_unlikely(len == 0)) {
+        if (ctx) ctx->old = doc->root;
+        doc->root = new_val;
+        return true;
+    }
+    if (yyjson_unlikely(*ptr != '/')) {
+        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
+        return false;
+    }
+    if (!new_val) {
+        if (!doc->root) {
+            yyjson_ptr_set_err(RESOLVE, "JSON pointer cannot be resolved");
+            return false;
+        }
+        return !!unsafe_yyjson_mut_ptr_removex(doc->root, ptr, len, ctx, err);
+    }
+    if (yyjson_unlikely(!doc->root && !create_parent)) {
+        yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
+        return false;
+    }
+    if (yyjson_unlikely(!doc->root)) {
+        yyjson_mut_val *root = yyjson_mut_obj(doc);
+        if (yyjson_unlikely(!root)) {
+            yyjson_ptr_set_err(MEMORY_ALLOCATION, "failed to create value");
+            return false;
+        }
+        if (unsafe_yyjson_mut_ptr_putx(root, ptr, len, new_val, doc,
+                                       create_parent, false, ctx, err)) {
+            doc->root = root;
+            return true;
+        }
+        return false;
+    }
+    return unsafe_yyjson_mut_ptr_putx(doc->root, ptr, len, new_val, doc,
+                                      create_parent, false, ctx, err);
+}
+
+yyjson_api_inline bool yyjson_mut_ptr_set(yyjson_mut_val *val,
+                                          const char *ptr,
+                                          yyjson_mut_val *new_val,
+                                          yyjson_mut_doc *doc) {
+    if (yyjson_unlikely(!ptr)) return false;
+    return yyjson_mut_ptr_setn(val, ptr, strlen(ptr), new_val, doc);
+}
+
+yyjson_api_inline bool yyjson_mut_ptr_setn(yyjson_mut_val *val,
+                                           const char *ptr, size_t len,
+                                           yyjson_mut_val *new_val,
+                                           yyjson_mut_doc *doc) {
+    return yyjson_mut_ptr_setx(val, ptr, len, new_val, doc, true, NULL, NULL);
+}
+
+yyjson_api_inline bool yyjson_mut_ptr_setx(yyjson_mut_val *val,
+                                           const char *ptr, size_t len,
+                                           yyjson_mut_val *new_val,
+                                           yyjson_mut_doc *doc,
+                                           bool create_parent,
+                                           yyjson_ptr_ctx *ctx,
+                                           yyjson_ptr_err *err) {
+    yyjson_ptr_set_err(NONE, NULL);
+    if (ctx) memset(ctx, 0, sizeof(*ctx));
+    
+    if (yyjson_unlikely(!val || !ptr || !doc)) {
+        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
+        return false;
+    }
+    if (yyjson_unlikely(len == 0)) {
+        yyjson_ptr_set_err(SET_ROOT, "cannot set root");
+        return false;
+    }
+    if (yyjson_unlikely(*ptr != '/')) {
+        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
+        return false;
+    }
+    if (!new_val) {
+        return !!unsafe_yyjson_mut_ptr_removex(val, ptr, len, ctx, err);
+    }
+    return unsafe_yyjson_mut_ptr_putx(val, ptr, len, new_val, doc,
+                                      create_parent, false, ctx, err);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replace(
+    yyjson_mut_doc *doc, const char *ptr, yyjson_mut_val *new_val) {
+    if (!ptr) return NULL;
+    return yyjson_mut_doc_ptr_replacen(doc, ptr, strlen(ptr), new_val);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replacen(
+    yyjson_mut_doc *doc, const char *ptr, size_t len, yyjson_mut_val *new_val) {
+    return yyjson_mut_doc_ptr_replacex(doc, ptr, len, new_val, NULL, NULL);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replacex(
+    yyjson_mut_doc *doc, const char *ptr, size_t len, yyjson_mut_val *new_val,
+    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err) {
+    
+    yyjson_ptr_set_err(NONE, NULL);
+    if (ctx) memset(ctx, 0, sizeof(*ctx));
+    
+    if (yyjson_unlikely(!doc || !ptr || !new_val)) {
+        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
+        return NULL;
+    }
+    if (yyjson_unlikely(len == 0)) {
+        yyjson_mut_val *root = doc->root;
+        if (yyjson_unlikely(!root)) {
+            yyjson_ptr_set_err(RESOLVE, "JSON pointer cannot be resolved");
+            return NULL;
+        }
+        if (ctx) ctx->old = root;
+        doc->root = new_val;
+        return root;
+    }
+    if (yyjson_unlikely(!doc->root)) {
+        yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
+        return NULL;
+    }
+    if (yyjson_unlikely(*ptr != '/')) {
+        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
+        return NULL;
+    }
+    return unsafe_yyjson_mut_ptr_replacex(doc->root, ptr, len, new_val,
+                                          ctx, err);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replace(
+    yyjson_mut_val *val, const char *ptr, yyjson_mut_val *new_val) {
+    if (!ptr) return NULL;
+    return yyjson_mut_ptr_replacen(val, ptr, strlen(ptr), new_val);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replacen(
+    yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val) {
+    return yyjson_mut_ptr_replacex(val, ptr, len, new_val, NULL, NULL);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replacex(
+    yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val,
+    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err) {
+    
+    yyjson_ptr_set_err(NONE, NULL);
+    if (ctx) memset(ctx, 0, sizeof(*ctx));
+    
+    if (yyjson_unlikely(!val || !ptr || !new_val)) {
+        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
+        return NULL;
+    }
+    if (yyjson_unlikely(len == 0)) {
+        yyjson_ptr_set_err(SET_ROOT, "cannot set root");
+        return NULL;
+    }
+    if (yyjson_unlikely(*ptr != '/')) {
+        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
+        return NULL;
+    }
+    return unsafe_yyjson_mut_ptr_replacex(val, ptr, len, new_val, ctx, err);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_remove(
+    yyjson_mut_doc *doc, const char *ptr) {
+    if (!ptr) return NULL;
+    return yyjson_mut_doc_ptr_removen(doc, ptr, strlen(ptr));
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_removen(
+    yyjson_mut_doc *doc, const char *ptr, size_t len) {
+    return yyjson_mut_doc_ptr_removex(doc, ptr, len, NULL, NULL);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_removex(
+    yyjson_mut_doc *doc, const char *ptr, size_t len,
+    yyjson_ptr_ctx *ctx, yyjson_ptr_err *err) {
+    
+    yyjson_ptr_set_err(NONE, NULL);
+    if (ctx) memset(ctx, 0, sizeof(*ctx));
+    
+    if (yyjson_unlikely(!doc || !ptr)) {
+        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
+        return NULL;
+    }
+    if (yyjson_unlikely(!doc->root)) {
+        yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
+        return NULL;
+    }
+    if (yyjson_unlikely(len == 0)) {
+        yyjson_mut_val *root = doc->root;
+        if (ctx) ctx->old = root;
+        doc->root = NULL;
+        return root;
+    }
+    if (yyjson_unlikely(*ptr != '/')) {
+        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
+        return NULL;
+    }
+    return unsafe_yyjson_mut_ptr_removex(doc->root, ptr, len, ctx, err);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_remove(yyjson_mut_val *val,
+                                                        const char *ptr) {
+    if (!ptr) return NULL;
+    return yyjson_mut_ptr_removen(val, ptr, strlen(ptr));
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_removen(yyjson_mut_val *val,
+                                                         const char *ptr,
+                                                         size_t len) {
+    return yyjson_mut_ptr_removex(val, ptr, len, NULL, NULL);
+}
+
+yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_removex(yyjson_mut_val *val,
+                                                         const char *ptr,
+                                                         size_t len,
+                                                         yyjson_ptr_ctx *ctx,
+                                                         yyjson_ptr_err *err) {
+    yyjson_ptr_set_err(NONE, NULL);
+    if (ctx) memset(ctx, 0, sizeof(*ctx));
+    
+    if (yyjson_unlikely(!val || !ptr)) {
+        yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
+        return NULL;
+    }
+    if (yyjson_unlikely(len == 0)) {
+        yyjson_ptr_set_err(SET_ROOT, "cannot set root");
+        return NULL;
+    }
+    if (yyjson_unlikely(*ptr != '/')) {
+        yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
+        return NULL;
+    }
+    return unsafe_yyjson_mut_ptr_removex(val, ptr, len, ctx, err);
+}
+
+yyjson_api_inline bool yyjson_ptr_ctx_append(yyjson_ptr_ctx *ctx,
+                                             yyjson_mut_val *key,
+                                             yyjson_mut_val *val) {
+    yyjson_mut_val *ctn, *pre_key, *pre_val, *cur_key, *cur_val;
+    if (!ctx || !ctx->ctn || !val) return false;
+    ctn = ctx->ctn;
+    
+    if (yyjson_mut_is_obj(ctn)) {
+        if (!key) return false;
+        key->next = val;
+        pre_key = ctx->pre;
+        if (unsafe_yyjson_get_len(ctn) == 0) {
+            val->next = key;
+            ctn->uni.ptr = key;
+            ctx->pre = key;
+        } else if (!pre_key) {
+            pre_key = (yyjson_mut_val *)ctn->uni.ptr;
+            pre_val = pre_key->next;
+            val->next = pre_val->next;
+            pre_val->next = key;
+            ctn->uni.ptr = key;
+            ctx->pre = pre_key;
+        } else {
+            cur_key = pre_key->next->next;
+            cur_val = cur_key->next;
+            val->next = cur_val->next;
+            cur_val->next = key;
+            if (ctn->uni.ptr == cur_key) ctn->uni.ptr = key;
+            ctx->pre = cur_key;
+        }
+    } else {
+        pre_val = ctx->pre;
+        if (unsafe_yyjson_get_len(ctn) == 0) {
+            val->next = val;
+            ctn->uni.ptr = val;
+            ctx->pre = val;
+        } else if (!pre_val) {
+            pre_val = (yyjson_mut_val *)ctn->uni.ptr;
+            val->next = pre_val->next;
+            pre_val->next = val;
+            ctn->uni.ptr = val;
+            ctx->pre = pre_val;
+        } else {
+            cur_val = pre_val->next;
+            val->next = cur_val->next;
+            cur_val->next = val;
+            if (ctn->uni.ptr == cur_val) ctn->uni.ptr = val;
+            ctx->pre = cur_val;
+        }
+    }
+    unsafe_yyjson_inc_len(ctn);
+    return true;
+}
+
+yyjson_api_inline bool yyjson_ptr_ctx_replace(yyjson_ptr_ctx *ctx,
+                                              yyjson_mut_val *val) {
+    yyjson_mut_val *ctn, *pre_key, *cur_key, *pre_val, *cur_val;
+    if (!ctx || !ctx->ctn || !ctx->pre || !val) return false;
+    ctn = ctx->ctn;
+    if (yyjson_mut_is_obj(ctn)) {
+        pre_key = ctx->pre;
+        pre_val = pre_key->next;
+        cur_key = pre_val->next;
+        cur_val = cur_key->next;
+        /* replace current value */
+        cur_key->next = val;
+        val->next = cur_val->next;
+        ctx->old = cur_val;
+    } else {
+        pre_val = ctx->pre;
+        cur_val = pre_val->next;
+        /* replace current value */
+        if (pre_val != cur_val) {
+            val->next = cur_val->next;
+            pre_val->next = val;
+            if (ctn->uni.ptr == cur_val) ctn->uni.ptr = val;
+        } else {
+            val->next = val;
+            ctn->uni.ptr = val;
+            ctx->pre = val;
+        }
+        ctx->old = cur_val;
+    }
+    return true;
+}
+
+yyjson_api_inline bool yyjson_ptr_ctx_remove(yyjson_ptr_ctx *ctx) {
+    yyjson_mut_val *ctn, *pre_key, *pre_val, *cur_key, *cur_val;
+    size_t len;
+    if (!ctx || !ctx->ctn || !ctx->pre) return false;
+    ctn = ctx->ctn;
+    if (yyjson_mut_is_obj(ctn)) {
+        pre_key = ctx->pre;
+        pre_val = pre_key->next;
+        cur_key = pre_val->next;
+        cur_val = cur_key->next;
+        /* remove current key-value */
+        pre_val->next = cur_val->next;
+        if (ctn->uni.ptr == cur_key) ctn->uni.ptr = pre_key;
+        ctx->pre = NULL;
+        ctx->old = cur_val;
+    } else {
+        pre_val = ctx->pre;
+        cur_val = pre_val->next;
+        /* remove current key-value */
+        pre_val->next = cur_val->next;
+        if (ctn->uni.ptr == cur_val) ctn->uni.ptr = pre_val;
+        ctx->pre = NULL;
+        ctx->old = cur_val;
+    }
+    len = unsafe_yyjson_get_len(ctn) - 1;
+    if (len == 0) ctn->uni.ptr = NULL;
+    unsafe_yyjson_set_len(ctn, len);
+    return true;
+}
+
+#undef yyjson_ptr_set_err
+
+
+
+/*==============================================================================
+ * JSON Value at Pointer API (Implementation)
+ *============================================================================*/
+
+/**
+ Set provided `value` if the JSON Pointer (RFC 6901) exists and is type bool.
+ Returns true if value at `ptr` exists and is the correct type, otherwise false.
+ */
+yyjson_api_inline bool yyjson_ptr_get_bool(
+    yyjson_val *root, const char *ptr, bool *value) {
+    yyjson_val *val = yyjson_ptr_get(root, ptr);
+    if (value && yyjson_is_bool(val)) {
+        *value = unsafe_yyjson_get_bool(val);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/**
+ Set provided `value` if the JSON Pointer (RFC 6901) exists and is type uint.
+ Returns true if value at `ptr` exists and is the correct type, otherwise false.
+ */
+yyjson_api_inline bool yyjson_ptr_get_uint(
+    yyjson_val *root, const char *ptr, uint64_t *value) {
+    yyjson_val *val = yyjson_ptr_get(root, ptr);
+    if (value && yyjson_is_uint(val)) {
+        *value = unsafe_yyjson_get_uint(val);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/**
+ Set provided `value` if the JSON Pointer (RFC 6901) exists and is type sint.
+ Returns true if value at `ptr` exists and is the correct type, otherwise false.
+ */
+yyjson_api_inline bool yyjson_ptr_get_sint(
+    yyjson_val *root, const char *ptr, int64_t *value) {
+    yyjson_val *val = yyjson_ptr_get(root, ptr);
+    if (value && yyjson_is_sint(val)) {
+        *value = unsafe_yyjson_get_sint(val);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/**
+ Set provided `value` if the JSON Pointer (RFC 6901) exists and is type real.
+ Returns true if value at `ptr` exists and is the correct type, otherwise false.
+ */
+yyjson_api_inline bool yyjson_ptr_get_real(
+    yyjson_val *root, const char *ptr, double *value) {
+    yyjson_val *val = yyjson_ptr_get(root, ptr);
+    if (value && yyjson_is_real(val)) {
+        *value = unsafe_yyjson_get_real(val);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/**
+ Set provided `value` if the JSON Pointer (RFC 6901) exists and is type sint,
+ uint or real.
+ Returns true if value at `ptr` exists and is the correct type, otherwise false.
+ */
+yyjson_api_inline bool yyjson_ptr_get_num(
+    yyjson_val *root, const char *ptr, double *value) {
+    yyjson_val *val = yyjson_ptr_get(root, ptr);
+    if (value && yyjson_is_num(val)) {
+        *value = unsafe_yyjson_get_num(val);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/**
+ Set provided `value` if the JSON Pointer (RFC 6901) exists and is type string.
+ Returns true if value at `ptr` exists and is the correct type, otherwise false.
+ */
+yyjson_api_inline bool yyjson_ptr_get_str(
+    yyjson_val *root, const char *ptr, const char **value) {
+    yyjson_val *val = yyjson_ptr_get(root, ptr);
+    if (value && yyjson_is_str(val)) {
+        *value = unsafe_yyjson_get_str(val);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+
+
+/*==============================================================================
+ * Deprecated
+ *============================================================================*/
+
+/** @deprecated renamed to `yyjson_doc_ptr_get` */
+yyjson_deprecated("renamed to yyjson_doc_ptr_get")
+yyjson_api_inline yyjson_val *yyjson_doc_get_pointer(yyjson_doc *doc,
+                                                     const char *ptr) {
+    return yyjson_doc_ptr_get(doc, ptr);
+}
+
+/** @deprecated renamed to `yyjson_doc_ptr_getn` */
+yyjson_deprecated("renamed to yyjson_doc_ptr_getn")
+yyjson_api_inline yyjson_val *yyjson_doc_get_pointern(yyjson_doc *doc,
+                                                      const char *ptr,
+                                                      size_t len) {
+    return yyjson_doc_ptr_getn(doc, ptr, len);
+}
+
+/** @deprecated renamed to `yyjson_mut_doc_ptr_get` */
+yyjson_deprecated("renamed to yyjson_mut_doc_ptr_get")
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_pointer(
+    yyjson_mut_doc *doc, const char *ptr) {
+    return yyjson_mut_doc_ptr_get(doc, ptr);
+}
+
+/** @deprecated renamed to `yyjson_mut_doc_ptr_getn` */
+yyjson_deprecated("renamed to yyjson_mut_doc_ptr_getn")
+yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_pointern(
+    yyjson_mut_doc *doc, const char *ptr, size_t len) {
+    return yyjson_mut_doc_ptr_getn(doc, ptr, len);
+}
+
+/** @deprecated renamed to `yyjson_ptr_get` */
+yyjson_deprecated("renamed to yyjson_ptr_get")
+yyjson_api_inline yyjson_val *yyjson_get_pointer(yyjson_val *val,
+                                                 const char *ptr) {
+    return yyjson_ptr_get(val, ptr);
+}
+
+/** @deprecated renamed to `yyjson_ptr_getn` */
+yyjson_deprecated("renamed to yyjson_ptr_getn")
+yyjson_api_inline yyjson_val *yyjson_get_pointern(yyjson_val *val,
+                                                  const char *ptr,
+                                                  size_t len) {
+    return yyjson_ptr_getn(val, ptr, len);
+}
+
+/** @deprecated renamed to `yyjson_mut_ptr_get` */
+yyjson_deprecated("renamed to yyjson_mut_ptr_get")
+yyjson_api_inline yyjson_mut_val *yyjson_mut_get_pointer(yyjson_mut_val *val,
+                                                         const char *ptr) {
+    return yyjson_mut_ptr_get(val, ptr);
+}
+
+/** @deprecated renamed to `yyjson_mut_ptr_getn` */
+yyjson_deprecated("renamed to yyjson_mut_ptr_getn")
+yyjson_api_inline yyjson_mut_val *yyjson_mut_get_pointern(yyjson_mut_val *val,
+                                                          const char *ptr,
+                                                          size_t len) {
+    return yyjson_mut_ptr_getn(val, ptr, len);
+}
+
+/** @deprecated renamed to `yyjson_mut_ptr_getn` */
+yyjson_deprecated("renamed to unsafe_yyjson_ptr_getn")
+yyjson_api_inline yyjson_val *unsafe_yyjson_get_pointer(yyjson_val *val,
+                                                        const char *ptr,
+                                                        size_t len) {
+    yyjson_ptr_err err;
+    return unsafe_yyjson_ptr_getx(val, ptr, len, &err);
+}
+
+/** @deprecated renamed to `unsafe_yyjson_mut_ptr_getx` */
+yyjson_deprecated("renamed to unsafe_yyjson_mut_ptr_getx")
+yyjson_api_inline yyjson_mut_val *unsafe_yyjson_mut_get_pointer(
+    yyjson_mut_val *val, const char *ptr, size_t len) {
+    yyjson_ptr_err err;
+    return unsafe_yyjson_mut_ptr_getx(val, ptr, len, NULL, &err);
+}
+
+
+
+/*==============================================================================
+ * Compiler Hint End
+ *============================================================================*/
+
+#if defined(__clang__)
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#   pragma GCC diagnostic pop
+#   endif
+#elif defined(_MSC_VER)
+#   pragma warning(pop)
+#endif /* warning suppress end */
+
+#ifdef __cplusplus
+}
+#endif /* extern "C" end */
+
+#endif /* YYJSON_H */
diff --git a/meson.build b/meson.build
index 0af687d..d8ec305 100644
--- a/meson.build
+++ b/meson.build
@@ -1,8 +1,10 @@
 project(
-  'draconis++', 'cpp',
+  'draconis++', ['cpp', 'objcpp'],
   version: '0.1.0',
   default_options: [
-    'cpp_std=c++26',
+    'objc_std=c++20',
+    'objcpp_std=c++20',
+    'cpp_std=c++20',
     'default_library=static',
     'warning_level=everything',
     'buildtype=debugoptimized'
@@ -12,6 +14,21 @@ project(
 clangtidy = find_program('clang-tidy', required: false)
 
 cpp = meson.get_compiler('cpp')
+objcpp = meson.get_compiler('objcpp')
+
+add_project_arguments(
+  objcpp.get_supported_arguments([
+    '-Wno-c++20-compat',
+    '-Wno-c++98-compat',
+    '-Wno-c++98-compat-pedantic',
+    '-Wno-missing-prototypes',
+    '-Wno-padded',
+    '-Wno-pre-c++20-compat-pedantic',
+    '-Wno-switch-default',
+    '-Wunused-function',
+  ]),
+  language: 'objcpp'
+)
 
 add_project_arguments(
   cpp.get_supported_arguments([
@@ -22,7 +39,7 @@ add_project_arguments(
     '-Wno-padded',
     '-Wno-pre-c++20-compat-pedantic',
     '-Wno-switch-default',
-    '-Wunused-function'
+    '-Wunused-function',
   ]),
   language: 'cpp'
 )
@@ -40,7 +57,11 @@ if host_machine.system() == 'linux'
 endif
 
 if host_machine.system() == 'darwin'
-  source_file_names += ['src/os/macos.cpp']
+  source_file_names += [
+    'src/os/macos.cpp',
+    'src/os/macos/NowPlayingBridge.h',
+    'src/os/macos/NowPlayingBridge.mm'
+  ]
 endif
 
 sources = []
@@ -49,16 +70,16 @@ foreach file : source_file_names
   sources += files(file)
 endforeach
 
-quill = subproject('quill')
-
 deps = []
 
 deps += cpp.find_library('cpr')
 deps += cpp.find_library('curl')
 deps += cpp.find_library('tomlplusplus')
-deps += dependency('boost', static: true)
+deps += dependency('coost')
 deps += dependency('fmt')
-deps += quill.get_variable('quill_dep')
+deps += dependency('Foundation')
+deps += dependency('MediaPlayer')
+
 
 if host_machine.system() == 'linux'
   deps += dependency('playerctl')
@@ -73,5 +94,7 @@ executable(
   'draconis++',
   sources,
   dependencies: deps,
-  include_directories: incdir
+  include_directories: incdir,
+  objc_args: ['-fobjc-arc'],
+  link_args: ['-framework', 'Foundation', '-framework', 'MediaPlayer']
 )
diff --git a/src/config/config.cpp b/src/config/config.cpp
index 3ad95d3..04c65b0 100644
--- a/src/config/config.cpp
+++ b/src/config/config.cpp
@@ -1,9 +1,3 @@
-#include <fmt/core.h>
-#include <rfl.hpp>
-#include <rfl/toml.hpp>
-#include <toml++/toml.h>
-#include <unistd.h>
-
 #include "config.h"
 
 #define DEFINE_GETTER(class_name, type, name) \
@@ -21,9 +15,11 @@ DEFINE_GETTER(Weather, const string, ApiKey)
 DEFINE_GETTER(Weather, const string, Units)
 
 const Config& Config::getInstance() {
-  static const Config& INSTANCE =
-      *new Config(rfl::toml::load<Config>("./config.toml").value());
-  return INSTANCE;
+  static const auto* INSTANCE =
+      new Config(rfl::toml::load<Config>("./config.toml").value());
+  static std::once_flag Flag;
+  std::call_once(Flag, [] { std::atexit([] { delete INSTANCE; }); });
+  return *INSTANCE;
 }
 
 Config::Config(General general, NowPlaying now_playing, Weather weather)
diff --git a/src/config/config.h b/src/config/config.h
index 6b9cd13..00b7121 100644
--- a/src/config/config.h
+++ b/src/config/config.h
@@ -1,13 +1,9 @@
-#pragma once
-
-#include <boost/json.hpp>
+#include <co/json.h>
 #include <cpr/cpr.h>
 #include <fmt/core.h>
 #include <rfl.hpp>
+#include <rfl/toml.hpp>
 #include <string>
-#include <toml++/impl/parser.hpp>
-#include <toml++/toml.h>
-#include <unistd.h>
 #include <variant>
 
 using std::string;
@@ -29,7 +25,7 @@ class Weather {
  public:
   Weather(Location location, string api_key, string units);
 
-  [[nodiscard]] boost::json::object getWeatherInfo() const;
+  [[nodiscard]] co::Json getWeatherInfo() const;
   [[nodiscard]] const Location getLocation() const;
   [[nodiscard]] const string getApiKey() const;
   [[nodiscard]] const string getUnits() const;
diff --git a/src/config/weather.cpp b/src/config/weather.cpp
index 673d39a..9ad216d 100644
--- a/src/config/weather.cpp
+++ b/src/config/weather.cpp
@@ -1,83 +1,77 @@
-#include <rfl.hpp>
-#include <rfl/toml.hpp>
-#include <toml++/toml.h>
-#include <unistd.h>
-
 #include "config.h"
 
-using namespace std;
-using namespace chrono;
-using namespace boost;
-
 // Function to read cache from file
-optional<pair<json::object, system_clock::time_point>> ReadCacheFromFile() {
+std::optional<std::pair<co::Json, std::chrono::system_clock::time_point>>
+ReadCacheFromFile() {
   const string cacheFile = "/tmp/weather_cache.json";
-  ifstream ifs(cacheFile);
+  std::ifstream ifs(cacheFile);
 
   if (!ifs.is_open()) {
     fmt::println("Cache file not found.");
-    return nullopt;
+    return std::nullopt;
   }
 
   fmt::println("Reading from cache file...");
 
-  json::object cachedData;
-  system_clock::time_point timestamp;
+  co::Json val;
+  std::chrono::system_clock::time_point timestamp;
 
   try {
-    json::value val;
-    ifs >> val;
-    cachedData = val.as_object();
+    std::stringstream buf;
+    buf << ifs.rdbuf();
 
-    string tsStr = cachedData["timestamp"].as_string().c_str();
-    timestamp    = system_clock::time_point(milliseconds(stoll(tsStr)));
+    val.parse_from(buf.str());
 
-    cachedData.erase("timestamp");
+    string tsStr = val["timestamp"].as_string().c_str();
+    timestamp    = std::chrono::system_clock::time_point(
+        std::chrono::milliseconds(stoll(tsStr)));
+
+    val.erase("timestamp");
   } catch (...) {
     fmt::println(stderr, "Failed to read from cache file.");
 
-    return nullopt;
+    return std::nullopt;
   }
 
   fmt::println("Successfully read from cache file.");
-  return make_pair(cachedData, timestamp);
+  return make_pair(val, timestamp);
 }
 
 // Function to write cache to file
-void WriteCacheToFile(const json::object& data) {
+void WriteCacheToFile(const co::Json& data) {
   const string cacheFile = "/tmp/weather_cache.json";
   fmt::println("Writing to cache file...");
-  ofstream ofs(cacheFile);
+  std::ofstream ofs(cacheFile);
 
   if (!ofs.is_open()) {
     fmt::println(stderr, "Failed to open cache file for writing.");
     return;
   }
 
-  json::object dataToWrite = data;
+  data["timestamp"] =
+      std::to_string(duration_cast<std::chrono::milliseconds>(
+                         std::chrono::system_clock::now().time_since_epoch())
+                         .count());
 
-  dataToWrite["timestamp"] = to_string(
-      duration_cast<milliseconds>(system_clock::now().time_since_epoch())
-          .count());
-
-  ofs << json::serialize(dataToWrite);
+  ofs << data.as_string();
 
   fmt::println("Successfully wrote to cache file.");
 }
 
 // Function to make API request
-json::object MakeApiRequest(const string& url) {
+co::Json MakeApiRequest(const string& url) {
   using namespace cpr;
 
   fmt::println("Making API request...");
   const Response res = Get(Url {url});
   fmt::println("Received response from API.");
-  json::value json = json::parse(res.text);
-  return json.as_object();
+  co::Json json = json::parse(res.text);
+
+  return json;
 }
 
 // Core function to get weather information
-json::object Weather::getWeatherInfo() const {
+co::Json Weather::getWeatherInfo() const {
   using namespace cpr;
 
   const Location loc  = m_Location;
@@ -86,10 +80,11 @@ json::object Weather::getWeatherInfo() const {
 
   // Check if cache is valid
   if (auto cachedData = ReadCacheFromFile()) {
-    auto [data, timestamp] = *cachedData;
+    auto& [data, timestamp] = *cachedData;
 
-    if (system_clock::now() - timestamp <
-        minutes(10)) { // Assuming cache duration is always 10 minutes
+    if (std::chrono::system_clock::now() - timestamp <
+        std::chrono::minutes(
+            10)) { // Assuming cache duration is always 10 minutes
       fmt::println("Cache is valid. Returning cached data.");
       return data;
     }
@@ -99,7 +94,7 @@ json::object Weather::getWeatherInfo() const {
     fmt::println("No valid cache found.");
   }
 
-  json::object result;
+  co::Json result;
 
   if (holds_alternative<string>(loc)) {
     const string city = get<string>(loc);
diff --git a/src/main.cpp b/src/main.cpp
index 60f5f61..2f5bd2f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,17 +1,10 @@
-#include <boost/json/src.hpp>
-#include <cpr/cpr.h>
+#include <co/log.h>
 #include <ctime>
-#include <curl/curl.h>
 #include <fmt/chrono.h>
 #include <fmt/core.h>
-#include <fmt/format.h>
-#include <rfl.hpp>
-#include <rfl/toml.hpp>
-#include <rfl/toml/load.hpp>
-#include <rfl/toml/read.hpp>
-#include <toml++/toml.hpp>
 
 #include "config/config.h"
+#include "os/macos/NowPlayingBridge.h"
 #include "os/os.h"
 
 using std::string;
@@ -49,9 +42,10 @@ DateNum ParseDate(string const& input) {
   return Default;
 }
 
-int main() {
-  using boost::json::object;
-  using std::time_t;
+int main(int argc, char** argv) {
+  flag::parse(argc, argv);
+
+  LOG << "hello " << 23;
 
   const Config& config = Config::getInstance();
 
@@ -97,12 +91,13 @@ int main() {
 
   fmt::println("{:%B} {}, {:%-I:%0M %p}", localTime, date, localTime);
 
-  object json = config.getWeather().getWeatherInfo();
+  co::Json json = config.getWeather().getWeatherInfo();
 
+  const int temp = json.get("main", "temp").as_int();
   const char* townName =
       json["name"].is_string() ? json["name"].as_string().c_str() : "Unknown";
 
-  fmt::println("{}", townName);
+  fmt::println("It is {}°F in {}", temp, townName);
 
   return 0;
 }
diff --git a/src/os/linux.cpp b/src/os/linux.cpp
index c881e69..1c3506a 100644
--- a/src/os/linux.cpp
+++ b/src/os/linux.cpp
@@ -1,8 +1,9 @@
 #ifdef __linux__
 
 #include <fmt/core.h>
-#include <playerctl/playerctl.h>
 #include <fstream>
+#include <playerctl/playerctl.h>
+
 #include "os.h"
 
 using std::string;
diff --git a/src/os/macos.cpp b/src/os/macos.cpp
index 775f984..b788cb6 100644
--- a/src/os/macos.cpp
+++ b/src/os/macos.cpp
@@ -1,12 +1,14 @@
 #ifdef __APPLE__
 
-#include <sys/sysctl.h>
 #include <string>
+#include <sys/sysctl.h>
+
+#include "macos/NowPlayingBridge.h"
 #include "os.h"
 
 uint64_t GetMemInfo() {
   uint64_t mem = 0;
-  size_t size = sizeof(mem);
+  size_t size  = sizeof(mem);
 
   sysctlbyname("hw.memsize", &mem, &size, nullptr, 0);
 
@@ -14,7 +16,7 @@ uint64_t GetMemInfo() {
 }
 
 std::string GetNowPlaying() {
-  return "";
+  return getCurrentPlayingTitle();
 }
 
 #endif
diff --git a/src/os/macos/NowPlayingBridge.h b/src/os/macos/NowPlayingBridge.h
new file mode 100644
index 0000000..0cbfe85
--- /dev/null
+++ b/src/os/macos/NowPlayingBridge.h
@@ -0,0 +1,14 @@
+// NowPlayingBridge.h
+
+#ifdef __OBJC__
+#import <Foundation/Foundation.h>
+
+@interface NowPlayingBridge : NSObject
++ (NSDictionary*)currentPlayingMetadata;
+@end
+#else
+extern "C" {
+const char* getCurrentPlayingTitle();
+const char* getCurrentPlayingArtist();
+}
+#endif
diff --git a/src/os/macos/NowPlayingBridge.mm b/src/os/macos/NowPlayingBridge.mm
new file mode 100644
index 0000000..dae0296
--- /dev/null
+++ b/src/os/macos/NowPlayingBridge.mm
@@ -0,0 +1,90 @@
+// NowPlayingBridge.mm
+
+#import "NowPlayingBridge.h"
+#import <Foundation/Foundation.h>
+#import <dispatch/dispatch.h>
+#import <objc/runtime.h>
+
+typedef void (*MRMediaRemoteGetNowPlayingInfoFunction)(
+    dispatch_queue_t queue, void (^handler)(NSDictionary *information));
+
+@implementation NowPlayingBridge
+
++ (NSDictionary *)currentPlayingMetadata {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wold-style-cast"
+
+  CFURLRef ref = (__bridge CFURLRef)
+      [NSURL fileURLWithPath:
+                 @"/System/Library/PrivateFrameworks/MediaRemote.framework"];
+
+#pragma clang diagnostic pop
+
+  CFBundleRef bundle = CFBundleCreate(kCFAllocatorDefault, ref);
+
+  if (!bundle) {
+    NSLog(@"Failed to load MediaRemote framework");
+    return nil;
+  }
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wold-style-cast"
+
+  MRMediaRemoteGetNowPlayingInfoFunction MRMediaRemoteGetNowPlayingInfo =
+      (MRMediaRemoteGetNowPlayingInfoFunction)CFBundleGetFunctionPointerForName(
+          bundle, CFSTR("MRMediaRemoteGetNowPlayingInfo"));
+
+#pragma clang diagnostic pop
+
+  if (!MRMediaRemoteGetNowPlayingInfo) {
+    NSLog(@"Failed to get function pointer for MRMediaRemoteGetNowPlayingInfo");
+    CFRelease(bundle);
+    return nil;
+  }
+
+  __block NSDictionary *nowPlayingInfo = nil;
+  dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+
+  MRMediaRemoteGetNowPlayingInfo(
+      dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
+      ^(NSDictionary *information) {
+        nowPlayingInfo = [information copy];
+        dispatch_semaphore_signal(semaphore);
+      });
+
+  dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
+
+  CFRelease(bundle);
+  return nowPlayingInfo;
+}
+
+@end
+
+extern "C" {
+
+const char *getCurrentPlayingTitle() {
+  NSDictionary *metadata = [NowPlayingBridge currentPlayingMetadata];
+  if (metadata == nil) {
+    return nullptr;
+  }
+  NSString *title =
+      [metadata objectForKey:@"kMRMediaRemoteNowPlayingInfoTitle"];
+  if (title) {
+    return strdup([title UTF8String]);
+  }
+  return nullptr;
+}
+
+const char *getCurrentPlayingArtist() {
+  NSDictionary *metadata = [NowPlayingBridge currentPlayingMetadata];
+  if (metadata == nil) {
+    return nullptr;
+  }
+  NSString *artist =
+      [metadata objectForKey:@"kMRMediaRemoteNowPlayingInfoArtist"];
+  if (artist) {
+    return strdup([artist UTF8String]);
+  }
+  return nullptr;
+}
+}
diff --git a/subprojects/packagecache/quill-4.2.0.tar.gz b/subprojects/packagecache/quill-4.2.0.tar.gz
deleted file mode 100644
index ebbf9a3..0000000
Binary files a/subprojects/packagecache/quill-4.2.0.tar.gz and /dev/null differ
diff --git a/subprojects/packagecache/quill_4.2.0-1_patch.zip b/subprojects/packagecache/quill_4.2.0-1_patch.zip
deleted file mode 100644
index ef6ccf2..0000000
Binary files a/subprojects/packagecache/quill_4.2.0-1_patch.zip and /dev/null differ
diff --git a/subprojects/quill-4.2.0/.clang-format b/subprojects/quill-4.2.0/.clang-format
deleted file mode 100644
index c7016b7..0000000
--- a/subprojects/quill-4.2.0/.clang-format
+++ /dev/null
@@ -1,45 +0,0 @@
-AccessModifierOffset: -2
-AlignConsecutiveDeclarations: None
-AlignOperands: false
-AlignTrailingComments: true
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowShortBlocksOnASingleLine: Never
-AllowShortIfStatementsOnASingleLine: Never
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakBeforeMultilineStrings: true
-AlwaysBreakTemplateDeclarations: Yes
-BinPackParameters: true
-BreakBeforeBinaryOperators: None
-BreakBeforeBraces: Allman
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializers: BeforeColon
-ColumnLimit: 100
-CommentPragmas: ''
-ConstructorInitializerAllOnOneLineOrOnePerLine: true
-ConstructorInitializerIndentWidth: 2
-ContinuationIndentWidth: 2
-DisableFormat: false
-ExperimentalAutoDetectBinPacking: false
-IndentCaseLabels: false
-IndentPPDirectives: BeforeHash
-IndentWidth: 2
-IndentWrappedFunctionNames: false
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: None
-PenaltyBreakBeforeFirstCallParameter: 1
-PenaltyBreakComment: 300
-PenaltyBreakString: 1000
-PenaltyBreakFirstLessLess: 120
-PenaltyExcessCharacter: 1
-PenaltyReturnTypeOnItsOwnLine: 1000
-PointerAlignment: Left
-SpaceBeforeAssignmentOperators: true
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles: false
-SpacesInCStyleCastParentheses: false
-SpacesInParentheses: false
-Cpp11BracedListStyle: true
-Standard: c++20
-TabWidth: 2
-UseTab: Never
diff --git a/subprojects/quill-4.2.0/.codecov.yml b/subprojects/quill-4.2.0/.codecov.yml
deleted file mode 100644
index 28b117d..0000000
--- a/subprojects/quill-4.2.0/.codecov.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-ignore:
-  - "examples"
-  - "quill/include/quill/bundled"
-  - "quill/src/bundled"
-  - "quill/test"
diff --git a/subprojects/quill-4.2.0/.github/workflows/coverage.yml b/subprojects/quill-4.2.0/.github/workflows/coverage.yml
deleted file mode 100644
index baa4714..0000000
--- a/subprojects/quill-4.2.0/.github/workflows/coverage.yml
+++ /dev/null
@@ -1,33 +0,0 @@
-name: coverage
-
-on:
-  push:
-    branches:
-      - master
-    paths-ignore:
-      - '**.md'
-      - 'docs/**'
-
-jobs:
-  build:
-    runs-on: ubuntu-20.04
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Configure
-      run: cmake -Bbuild -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_STANDARD=17 -DQUILL_BUILD_TESTS=ON -DQUILL_CODE_COVERAGE=ON -DQUILL_BUILD_EXAMPLES=ON -DQUILL_VERBOSE_MAKEFILE=ON
-
-    - name: Build
-      run: cmake --build build -j4
-
-    - name: Test
-      run: |
-        cd build
-        ctest --build-config Debug
-
-    - name: Upload coverage to Codecov
-      uses: codecov/codecov-action@v4
-      with:
-        token: ${{ secrets.CODECOV_TOKEN }}
-        verbose: true
diff --git a/subprojects/quill-4.2.0/.github/workflows/linux.yml b/subprojects/quill-4.2.0/.github/workflows/linux.yml
deleted file mode 100644
index 859c30d..0000000
--- a/subprojects/quill-4.2.0/.github/workflows/linux.yml
+++ /dev/null
@@ -1,111 +0,0 @@
-name: linux
-
-on:
-  push:
-    branches:
-      - master
-    paths-ignore:
-      - '**.md'
-      - 'docs/**'
-
-  pull_request:
-    branches:
-      - master
-    paths-ignore:
-      - '**.md'
-      - 'docs/**'
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        cxx: [ g++-8, g++-10 ]
-        build_type: [ Debug, Release ]
-        std: [ 17 ]
-        os: [ ubuntu-20.04 ]
-        with_tests: [ ON ]
-
-        include:
-          # Build and with g++8
-          - cxx: g++-8
-            std: 17
-            os: ubuntu-20.04
-            with_tests: ON
-            install: sudo apt -o Acquire::Retries=5 install g++-8
-
-            # Build and test as shared library
-          - cxx: g++-10
-            build_type: Release
-            std: 17
-            os: ubuntu-20.04
-            with_tests: ON
-            cmake_options: -DBUILD_SHARED_LIBS=ON -DCMAKE_CXX_VISIBILITY_PRESET=hidden -DCMAKE_VISIBILITY_INLINES_HIDDEN=ON
-
-            # Builds with no exceptions
-          - cxx: g++-10
-            build_type: Release
-            std: 17
-            os: ubuntu-20.04
-            with_tests: OFF
-            cmake_options: -DQUILL_NO_EXCEPTIONS=ON
-
-            # Build and test with valgrind, sanitizers
-          - cxx: g++-10
-            build_type: Release
-            std: 20
-            os: ubuntu-20.04
-            with_tests: ON
-            cmake_options: -DQUILL_USE_VALGRIND=ON
-            ctest_options: -T memcheck
-            install: sudo apt -o Acquire::Retries=5 install valgrind
-
-            # Build and test sanitizers
-          - cxx: clang++-12
-            build_type: Release
-            std: 20
-            os: ubuntu-20.04
-            with_tests: ON
-            cmake_options: -DQUILL_SANITIZE_ADDRESS=ON
-
-            # Build and test sanitizers
-          - cxx: clang++-12
-            build_type: Release
-            std: 20
-            os: ubuntu-20.04
-            with_tests: ON
-            cmake_options: -DQUILL_SANITIZE_THREAD=ON
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Create Build Environment
-        run: |
-          sudo apt-get update
-          ${{matrix.install}}
-          cmake -E make_directory ${{runner.workspace}}/build
-
-      - name: Configure
-        working-directory: ${{runner.workspace}}/build
-        env:
-          CXX: ${{matrix.cxx}}
-          CXXFLAGS: ${{matrix.cxxflags}}
-        run: |
-          cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} ${{matrix.cmake_options}} \
-                -DCMAKE_CXX_STANDARD=${{matrix.std}} -DQUILL_BUILD_TESTS=${{matrix.with_tests}} \
-                -DQUILL_BUILD_EXAMPLES=ON -DQUILL_VERBOSE_MAKEFILE=ON $GITHUB_WORKSPACE
-
-      - name: Build
-        working-directory: ${{runner.workspace}}/build
-        run: |
-          threads=`nproc`
-          cmake --build . --config ${{matrix.build_type}} --parallel $threads
-
-      - name: Test
-        working-directory: ${{runner.workspace}}/build
-        run: |
-          threads=`nproc`
-          ctest --build-config ${{matrix.build_type}} ${{matrix.ctest_options}} --parallel $threads --output-on-failure
-        env:
-          CTEST_OUTPUT_ON_FAILURE: True
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/.github/workflows/macos.yml b/subprojects/quill-4.2.0/.github/workflows/macos.yml
deleted file mode 100644
index 0a67fec..0000000
--- a/subprojects/quill-4.2.0/.github/workflows/macos.yml
+++ /dev/null
@@ -1,50 +0,0 @@
-name: macos
-
-on:
-  push:
-    branches:
-      - master
-    paths-ignore:
-      - '**.md'
-      - 'docs/**'
-
-  pull_request:
-    branches:
-      - master
-    paths-ignore:
-      - '**.md'
-      - 'docs/**'
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ macos-14 ]
-        build_type: [ Debug, Release ]
-        std: [ 17, 20 ]
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Create Build Environment
-      run: cmake -E make_directory ${{runner.workspace}}/build
-
-    - name: Configure
-      working-directory: ${{runner.workspace}}/build
-      run: |
-        cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
-              -DCMAKE_CXX_STANDARD=${{matrix.std}} -DQUILL_BUILD_TESTS=ON \
-              -DQUILL_BUILD_EXAMPLES=ON -DQUILL_VERBOSE_MAKEFILE=ON $GITHUB_WORKSPACE
-
-    - name: Build
-      working-directory: ${{runner.workspace}}/build
-      run: |
-        threads=`sysctl -n hw.logicalcpu`
-        cmake --build . --config ${{matrix.build_type}} --parallel $threads
-
-    - name: Test
-      working-directory: ${{runner.workspace}}/build
-      run: |
-        threads=`sysctl -n hw.logicalcpu`
-        ctest --build-config ${{matrix.build_type}} --parallel $threads --output-on-failure
diff --git a/subprojects/quill-4.2.0/.github/workflows/windows.yml b/subprojects/quill-4.2.0/.github/workflows/windows.yml
deleted file mode 100644
index e61e009..0000000
--- a/subprojects/quill-4.2.0/.github/workflows/windows.yml
+++ /dev/null
@@ -1,78 +0,0 @@
-
-name: windows
-
-on:
-  push:
-    branches:
-      - master
-    paths-ignore:
-      - '**.md'
-      - 'docs/**'
-
-  pull_request:
-    branches:
-      - master
-    paths-ignore:
-      - '**.md'
-      - 'docs/**'
-
-jobs:
-  build:
-    # windows-2016 and windows-2019 have MSVC 2017 and 2019 installed
-    # respectively: https://github.com/actions/virtual-environments.
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ windows-2019, windows-2022 ]
-        platform: [ x64 ]
-        build_type: [ Debug, Release ]
-        std: [ 17, 20 ]
-        with_tests: [ ON ]
-
-        include:
-          # Builds with no exceptions
-          - os: windows-2019
-            platform: x64
-            build_type: Release
-            std: 17
-            with_tests: "OFF"
-            cmake_options: -DQUILL_NO_EXCEPTIONS=ON
-
-          # Builds for ARM
-          - os: windows-2019
-            platform: ARM64
-            build_type: Release
-            std: 17
-            with_tests: "OFF"
-
-          - os: windows-2019
-            platform: ARM
-            build_type: Release
-            std: 17
-            with_tests: "OFF"
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Create Build Environment
-        run: cmake -E make_directory ${{runner.workspace}}/build
-
-      - name: Configure
-        shell: bash         # Use a bash shell for $GITHUB_WORKSPACE.
-        working-directory: ${{runner.workspace}}/build
-        run: |
-          cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} ${{matrix.cmake_options}} \
-              -A ${{matrix.platform}} -DCMAKE_CXX_STANDARD=${{matrix.std}} -DQUILL_BUILD_TESTS=${{matrix.with_tests}} \
-              -DQUILL_BUILD_EXAMPLES=ON -DQUILL_VERBOSE_MAKEFILE=ON $GITHUB_WORKSPACE
-
-      - name: Build
-        working-directory: ${{runner.workspace}}/build
-        run: |
-          $threads = (Get-CimInstance Win32_ComputerSystem).NumberOfLogicalProcessors
-          cmake --build . --config ${{matrix.build_type}} --parallel $threads
-
-      - name: Test
-        working-directory: ${{runner.workspace}}/build
-        run: |
-          $threads = (Get-CimInstance Win32_ComputerSystem).NumberOfLogicalProcessors
-          ctest --build-config ${{matrix.build_type}} --parallel $threads --output-on-failure
diff --git a/subprojects/quill-4.2.0/.gitignore b/subprojects/quill-4.2.0/.gitignore
deleted file mode 100644
index 1801866..0000000
--- a/subprojects/quill-4.2.0/.gitignore
+++ /dev/null
@@ -1,8 +0,0 @@
-# Project exclude paths
-/cmake-build-debug/
-/.vs
-/out/build/x64-Debug
-/CMakeSettings.json
-/out/build/x64-Release
-/out/build/Mingw64-Debug
-/out/build/x64-Debug-2
diff --git a/subprojects/quill-4.2.0/.meson-subproject-wrap-hash.txt b/subprojects/quill-4.2.0/.meson-subproject-wrap-hash.txt
deleted file mode 100644
index bfd1e53..0000000
--- a/subprojects/quill-4.2.0/.meson-subproject-wrap-hash.txt
+++ /dev/null
@@ -1 +0,0 @@
-768ccd8048e2f53838c17ea6480236bb8d89fa785fb08f378539bfb0aa61ac1f
diff --git a/subprojects/quill-4.2.0/.readthedocs.yaml b/subprojects/quill-4.2.0/.readthedocs.yaml
deleted file mode 100644
index c1049bf..0000000
--- a/subprojects/quill-4.2.0/.readthedocs.yaml
+++ /dev/null
@@ -1,22 +0,0 @@
-# .readthedocs.yaml
-# Read the Docs configuration file
-# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
-
-# Required
-version: 2
-
-# Set the version of Python and other tools you might need
-build:
-  os: ubuntu-22.04
-  tools:
-    python: "3.11"
-
-# Build documentation in the docs/ directory with Sphinx
-sphinx:
-  configuration: docs/conf.py
-
-# We recommend specifying your dependencies to enable reproducible builds:
-# https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
-python:
-  install:
-  - requirements: docs/requirements.txt
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/CHANGELOG.md b/subprojects/quill-4.2.0/CHANGELOG.md
deleted file mode 100644
index 1ae4dc2..0000000
--- a/subprojects/quill-4.2.0/CHANGELOG.md
+++ /dev/null
@@ -1,1384 +0,0 @@
-- [v4.2.0](#v420)
-- [v4.1.0](#v410)
-- [v4.0.0](#v400)
-- [v3.9.0](#v390)
-- [v3.8.0](#v380)
-- [v3.7.0](#v370)
-- [v3.6.0](#v360)
-- [v3.5.1](#v351)
-- [v3.5.0](#v350)
-- [v3.4.1](#v341)
-- [v3.4.0](#v340)
-- [v3.3.1](#v331)
-- [v3.3.0](#v330)
-- [v3.2.0](#v320)
-- [v3.1.0](#v310)
-- [v3.0.2](#v302)
-- [v3.0.1](#v301)
-- [v3.0.0](#v300)
-- [v2.9.2](#v292)
-- [v2.9.1](#v291)
-- [v2.9.0](#v290)
-- [v2.8.0](#v280)
-- [v2.7.0](#v270)
-- [v2.6.0](#v260)
-- [v2.5.1](#v251)
-- [v2.5.0](#v250)
-- [v2.4.2](#v242)
-- [v2.4.1](#v241)
-- [v2.4.0](#v240)
-- [v2.3.4](#v234)
-- [v2.3.3](#v233)
-- [v2.3.2](#v232)
-- [v2.3.1](#v231)
-- [v2.3.0](#v230)
-- [v2.2.0](#v220)
-- [v2.1.0](#v210)
-- [v2.0.2](#v202)
-- [v2.0.1](#v201)
-- [v2.0.0](#v200)
-- [v1.7.3](#v173)
-- [v1.7.2](#v172)
-- [v1.7.1](#v171)
-- [v1.7.0](#v170)
-- [v1.6.3](#v163)
-- [v1.6.2](#v162)
-- [v1.6.1](#v161)
-- [v1.6.0](#v160)
-- [v1.5.2](#v152)
-- [v1.5.1](#v151)
-- [v1.5.0](#v150)
-- [v1.4.1](#v141)
-- [v1.4.0](#v140)
-- [v1.3.3](#v133)
-- [v1.3.2](#v132)
-- [v1.3.1](#v131)
-- [v1.3.0](#v130)
-- [v1.2.3](#v123)
-- [v1.2.2](#v122)
-- [v1.2.1](#v121)
-- [v1.2.0](#v120)
-- [v1.1.0](#v110)
-- [v1.0.0](#v100)
-
-## v4.2.0
-
-- Fixed the compile-time exclusion of log levels. Renamed the `QUILL_COMPILE_OUT_LOG_LEVEL` preprocessor
-  flag to `QUILL_COMPILE_ACTIVE_LOG_LEVEL`.
-- Fixed build error when `UnboundedDropping` queue is used.
-- Fixed a bug introduced in `v4.1.0`, which resulted in messages being logged out of order when
-  the `transit_events_soft_limit` was reached. Additionally, this issue affected the behavior of `flush_log()`,
-  prematurely unblocking the thread before all messages were flushed.
-- Fixed `-Wno-unused-parameter` and `-Wdocumentation` warnings.
-- Improved backend worker `_exit()` functionality and reduced code duplication in other areas of the backend worker code.
-- Added `signal_handler_timeout_seconds` parameter, which controls the timeout duration for the signal handler. Only
-  available on Linux platforms.
-- Added `sleep_duration_ns` parameter to the `flush_log(...)` function. This parameter specifies the duration in
-  nanoseconds to sleep between retries between checks for the flush completion and when a blocking queue is used,
-  and it is full. The default sleep duration is 100 nanoseconds, but users can now customize this duration according to
-  their needs. If a zero sleep duration is passed, the thread might yield instead.
-- Removed uses of `std::this_thread::sleep_for(...)`, `std::string`, `std::vector` in the signal handler when waiting for
-  the log to be flushed.
-
-## v4.1.0
-
-- Following the transition from a compiled to a header-only library, the `target_compile_options` previously applied to
-  the compiled library were mistakenly propagated to all programs linking against the header-only library.
-  This issue is now fixed by removing those flags and explicitly adding them to tests and examples. As a result,
-  executable targets no longer inherit flags from the library.
-- Removed unnecessary template specializations and merged their logic into the primary template
-  for `ArgSizeCalculator`, `Encoder`, and `Decoder` using if constexpr.
-- Eliminated `<functional>` header dependency in the frontend
-- Replaced `%(structured_keys)` with `%(named_args)` in the `PatternFormatter`. This change now appends the
-  entire key-value pair of named args to the message, not just the names.
-- Relocated certain classes to the `detail` namespace
-- Replaced `sprintf` with `snprintf` to fix macOS warning.
-- Reviewed and removed gcc cold attribute from a few functions.
-- Minor backend thread optimisations when logging c style strings or char arrays
-- Improved backend thread variable and function names and fixed a bug for an edge case when the transit event hard limit
-  is reached
-
-## v4.0.0
-
-This version represents a major revamp of the library, aiming to simplify and modernize it, resulting in the removal
-of a few features. Please read through the changes carefully before upgrading, as it is not backwards compatible with
-previous versions and some effort will be required to migrate.
-
-I understand that these changes may inconvenience some existing users. However, they have been made with good
-intentions, aiming to improve and refine the logging library. This involved significant effort and dedication.
-
-Bug fixes and releases for `v3` will continue to be supported under the `v3.x.x` branch.
-
-#### Comparison
-
-- This version significantly improves compile times. Taking a look at some compiler profiling for a `Release` build with
-  clang 15, we can see the difference. Below are the two compiler flamegraphs for building the `recommended_usage`
-  example from the new version and the `wrapper_lib` example from the previous version.
-
-The below flamegraph shows the difference in included headers between the two versions
-
-| Version |                                                          Compiler FlameGraph                                                           |
-|---------|:--------------------------------------------------------------------------------------------------------------------------------------:|
-| v4.0.0  | ![quill_v4_compiler_profile.speedscope.png](https://github.com/odygrd/quill/blob/master/docs/quill_v4_compiler_profile.speedscope.png) |
-| v3.8.0  | ![quill_v3_compiler_profile.speedscope.png](https://github.com/odygrd/quill/blob/master/docs/quill_v3_compiler_profile.speedscope.png) |
-
-A new compiler benchmark has been introduced. A Python script generates 2000 distinct log statements with various
-arguments. You can find the
-benchmark [here](https://github.com/odygrd/quill/blob/master/benchmarks/compile_time/compile_time_bench.cpp).
-Compilation now takes only about 30 seconds, whereas the previous version required over 4 minutes.
-
-| Version |                                                         Compiler FlameGraph                                                          |
-|---------|:------------------------------------------------------------------------------------------------------------------------------------:|
-| v4.0.0  |  ![quill_v4_compiler_bench.speedscope.png](https://github.com/odygrd/quill/blob/master/docs/quill_v4_compiler_bench.speedscope.png)  |
-| v3.8.0  | ![quill_v3_compiler_bench.speedscope.png](https://github.com/odygrd/quill/blob/master/docs/quill_v4_compiler_profile.speedscope.png) |
-
-- Minor increase in backend thread throughput compared to the previous version.
-
-| Version |                                 Backend Throughput                                 |
-|---------|:----------------------------------------------------------------------------------:|
-| v4.0.0  | 4.56 million msgs/sec average, total time elapsed: 876 ms for 4000000 log messages |
-| v3.8.0  | 4.39 million msgs/sec average, total time elapsed: 910 ms for 4000000 log messages |
-
-- Significant boost in hot path latency when logging complex types such as `std::vector`.
-  The performance remains consistent when logging only primitive types or strings in both versions. Refer
-  [here](https://github.com/odygrd/quill?tab=readme-ov-file#performance) for updated and detailed benchmarks.
-
-#### Changes
-
-- **Improved compile times**
-
-The library has been restructured to minimize the number of required headers. Refactoring efforts have focused on
-decoupling the frontend from the backend, resulting in reduced dependencies. Accessing the frontend logging functions
-now does not demand inclusion of any backend logic components.
-
-     "quill/Backend.h" - It can be included once to start the backend logging thread, typically in main.cpp 
-                         or in a wrapper library.
-     
-     "quill/Frontend.h"` - Used to create or obtain a `Logger*` or a `Sink`. It can be included in limited 
-                           files, since an obtained `Logger*` has pointer stability and can be passed around.
-     
-     "quill/Logger.h", "quill/LogMacros.h" - These two files are the only ones needed for logging and will have 
-                                             to be included in every file that requires logging functionality.
-
-- **Backend formatting for user-defined and standard library types**
-
-One of the significant changes lies in the support for formatting both user-defined and standard library types.
-Previously, the backend thread handled the formatting of these types sent by the frontend. It involved making a copy for
-any object passed to the `LOG_` macros as an argument using the copy constructor of a complex type instead of directly
-serializing the data to the SPSC queue. While this method facilitated logging copy-constructible user-defined types with
-ease, it also posed numerous challenges for asynchronous logging:
-
-- Error-Prone Asynchronous Logging: Copying and formatting user-defined types on the backend thread in an
-  asynchronous logging setup could lead to errors. Previous versions attempted to address this issue with type
-  trait checks, which incurred additional template instantiations and compile times.
-- Uncertainty in Type Verification: It is challenging to confidently verify types, as some trivially copiable
-  types, such as `struct A { int* m; }`, could still lead to issues due to potential modifications by the user
-  before formatting.
-- Hidden Performance Penalties: Logging non-trivially copiable types could introduce hidden cache coherence
-  performance penalties due to memory allocations and deallocations across threads. For instance,
-  consider `std::vector<int>` passed as a log argument. The vector is emplaced into the SPSC queue by the frontend,
-  invoking the copy constructor dynamically allocating memory as the only members copied to SPSC queue
-  are `size`, `capacity`, and `data*`. The backend thread reads the object, formats it, and then invokes the destructor,
-  which in turn synchronizes the
-  freed memory back to the frontend.
-
-Additionally, after years of professional use and based on experience, it has been observed that user-defined types
-are often logged during program initialization, with fewer occurrences on the hot path where mostly built-in types are
-logged. In such scenarios, the overhead of string formatting on the frontend during initialization is not an issue.
-
-In this new version, the use of the copy constructor for emplacing objects in the queue has been abandoned. Only POD
-types are copied, ensuring that only raw, tangible data is handled without any underlying pointers pointing to other
-memory locations. The only exception to this are the pointers to `Metadata`, `LoggerBase` and `DecodeFunction`
-that are passed internally for each log message. Log arguments sent from the frontend must undergo
-serialization beforehand. While this approach resolves the above issues, it does introduce more complexity when
-dealing with user-defined or standard library types.
-
-Built-in types and strings are logged by default, with the formatting being offloaded to the backend. Additionally,
-there is built-in support for most standard library types, which can also be directly passed to the logger by
-including the relevant header from `quill/std`.
-
-The recommendation for user-defined types is to format them into strings before passing them to the `LOG_` macros using
-your preferred method. You can find an example of
-this [here](https://github.com/odygrd/quill/blob/master/examples/user_defined_types_logging.cpp).
-
-It's also possible to extend the library by providing template specializations to serialize the user-defined types
-and offload their formatting to the backend. However, this approach should only be pursued if you cannot tolerate the
-formatting overhead in that part of your program. For further guidance, refer
-to [this example](https://github.com/odygrd/quill/blob/master/examples/advanced/advanced.cpp).
-
-- **Header-Only library**
-
-The library is now header-only. This change simplifies exporting the library as a C++ module in the future. See
-[here](https://github.com/odygrd/quill/blob/master/examples/recommended_usage/recommended_usage.cpp) on how to build a
-wrapper static library which includes the backend and will minimise the compile times.
-
-- **Preprocessor flags moved to template parameters**
-
-Most preprocessor flags have been moved to template parameters, with only a few remaining as `CMake` options. This
-change simplifies exporting the library as a C++ module in the future.
-
-- **Renamed Handlers to Sinks**
-
-To enhance clarity, handlers have been renamed to sinks.
-
-- **PatternFormatter moved to Logger**
-
-The `PatternFormatter` has been relocated from `Sink` to `Logger`, enabling a logger object to log in a specific
-format. This allows for different formats within the same output file, a feature not previously possible.
-
-- **Split Configuration**
-
-The configuration settings have been divided into `FrontendOptions` and `BackendOptions`.
-
-- **Refactoring of backend classes**
-
-`MacroMetadata` and many backend classes have undergone refactoring, resulting in reduced memory requirements.
-
-- **Improved wide strings handling on Windows**
-
-The library now offers significant performance enhancements for handling wide strings on Windows platforms.
-It's important to note that only wide strings containing ASCII characters are supported. Previously, wide strings were
-converted to narrow strings at the frontend, impacting the critical path of the application.
-With this update, the underlying wide char buffer is copied and the conversion to UTF-8 encoding is deferred to
-the backend logging thread. Additionally, this update adds support for logging STL containers consisting of
-wide strings
-
-- **Default logger removal**
-
-The default logger, along with the configuration inheritance feature during logger creation, has been removed. Now, when
-creating a new logger instance, configurations such as the `Sink` and log pattern format must be explicitly specified
-each time. This simplifies the codebase.
-
-- **Global logger removal**
-
-The static global logger* variable that was initialised during `quill::start()` used to obtain the default logger has
-been removed. It is possible to add this on the user side. If you require a global logger you can have a look
-at [this example](https://github.com/odygrd/quill/blob/master/examples/recommended_usage/recommended_usage.cpp)
-
-- **Removal of printf style formatting support**
-
-The support for `printf` style formatting has been removed due to its limited usage and the increased complexity. Users
-requiring this feature should stay on `v3.x.x` versions to maintain compatibility.
-
-- **Removal of external libfmt usage**
-
-The option to build the library with external `libfmt` has been removed. It becomes difficult to maintain and backwards
-support previous versions of `libfmt`. Instead, `libfmt` is now an internal component of the library, accessible under
-the namespace `fmtquill`. You can use the bundled version of `fmtquill` by including the necessary headers from
-`quill/bundled/fmt`. Alternatively, you have the freedom to integrate your own version. Since `libfmt` is encapsulated
-within a distinct namespace, there are no conflicts even if you link your own `libfmt` alongside the logging library.
-
-#### Migration Guidance
-
-- Revise include files to accommodate the removal of `Quill.h`
-- Update the code that starts the backend thread and the logger/sink creation. You can refer to any of the
-  updated examples, such as [this one](https://github.com/odygrd/quill/blob/master/examples/file_logging.cpp)
-- When logging statements involving user-defined types, make sure these types are formatted into strings using
-  your preferred method. Refer to
-  [this link](https://github.com/odygrd/quill/blob/master/examples/user_defined_types_logging.cpp) for guidance.
-  Alternatively, if you prefer delaying the conversion to strings until the backend thread and only passing a
-  binary copy of the user-defined type on the hot path, you can provide the necessary class template
-  specializations for each user-defined type. See an example
-  [here](https://github.com/odygrd/quill/blob/master/examples/advanced/user_quill_codec.h)
-
-## v3.9.0
-
-- Fix bug in `ConsoleHandler` when dynamic log level is used ([#421](https://github.com/odygrd/quill/pull/421))
-- Fix bug in `TransitEvent` when dynamic log level is used ([#427](https://github.com/odygrd/quill/pull/427))
-- Fix build error for Intel compiler classic ([#414](https://github.com/odygrd/quill/pull/414))
-- Added `JsonConsoleHandler` ([#413](https://github.com/odygrd/quill/issues/413))
-- Fix fold expression argument evaluation. This bug could occur when logging c style strings
-
-## v3.8.0
-
-- Refactored `MacroMetadata` class to reduce its size.
-- Renamed some attributes in the `PatternFormatter` class for clarity. If you are using a custom format pattern, update
-  the attribute names in your code to match the new names.
-- Improved accuracy of log statement timestamps. Previously, the timestamp was taken after checking if the queue had
-  enough space to push the message, which could make it less accurate. Additionally, in the case of a blocking queue,
-  the timestamp could be later in time. Now, the timestamp is taken and stored right after the log statement is issued,
-  before checking for the queue size.
-- Reduced template instantiations during logging operations on the hot path. Fold expressions are now used for
-  encoding/decoding arguments, minimizing template recursion overhead.
-- Removed compile-time format checks due to their significant impact on template instantiations, especially considering
-  that only a few cases are invalid. For instance, while `fmt::format("{}", 1, 2)` is considered valid,
-  `fmt::format("{} {}", 1)` is deemed invalid. In cases where an invalid format string is detected, the backend worker
-  thread catches the generated exception and logs an error.
-- The throughput of the backend worker thread has been improved by approximately 5%. This enhancement is reflected in
-  the new throughput value of 4.20 million msgs/sec, compared to the previous throughput of 3.98 million msgs/sec.
-- Detect `tmux` as colour terminal. ([#410](https://github.com/odygrd/quill/issues/410))
-
-## v3.7.0
-
-- Fixed crash triggered by insufficient space in the queue upon invocation
-  of ``flush()``. ([#398](https://github.com/odygrd/quill/pull/398))
-- Fixed windows clang-cl build error. ([#400](https://github.com/odygrd/quill/pull/400))
-- Fixed compilation errors encountered on FreeBSD and extended ``get_thread_id()`` support to various other BSD
-  operating systems. ([#401](https://github.com/odygrd/quill/pull/401))
-- Fix open_file in the FileHandler to also create the parent path before opening the
-  file. ([#395](https://github.com/odygrd/quill/issues/395))
-- Enhance logic for backend thread's flush() invocation; it now triggers only if the handler has previously written
-  data. ([#395](https://github.com/odygrd/quill/issues/395))
-- Address an uncaught exception in the backend thread that could occur when a user manually removes the log file from
-  the terminal while the logger is running. ([#395](https://github.com/odygrd/quill/issues/395))
-- Ensure that after a logger is removed, there are no subsequent calls to the Handler's flush() or run_loop(), provided
-  the Handler is not shared. ([#395](https://github.com/odygrd/quill/issues/395))
-- Ignore the virtual destructor missing warning for the `CustomTags`
-  class. ([#402](https://github.com/odygrd/quill/pull/402))
-- Update bundled `libfmt` to `v10.2.1`
-
-## v3.6.0
-
-- Fixed `QUILL_LOGGER_CALL_NOFN_LIMIT` macros. ([#381](https://github.com/odygrd/quill/pull/381))
-- Resolved a bug that caused reading destructed arguments when structured logging format was used.
-- Modified member access from `private` to `protected` in `ConsoleHandler` for potential inheritance purposes.
-- Eliminated redundant whitespaces within `JsonFileHandler`.
-- Fixed `JsonFileHandler` to notify the file event notifier before log message writes.
-- Implemented a new attribute called `%(structured_keys)` within the `PatternFormatter` to facilitate the inclusion
-  of keys in messages when using structured log formatting. This addition is useful for instances where logging occurs
-  in both JSON and regular log formats, enabling the display of keys within the regular log-formatted messages.
-  See
-  updated [example_json_structured_log.cpp](https://github.com/odygrd/quill/blob/master/examples/example_json_structured_log.cpp)
-
-## v3.5.1
-
-- Resolved issue with accessing the `name()` method within the `Logger`
-  class. ([#378](https://github.com/odygrd/quill/pull/378))
-- Fixed a compilation error in `SignalHandler` specific to Windows when `QUILL_DISABLE_NON_PREFIXED_MACROS` is
-  defined. ([#380](https://github.com/odygrd/quill/pull/380))
-
-## v3.5.0
-
-- Fixed `LOG_TRACE_CFORMAT` macros.
-- Added support for compile-time custom tags in `quill::MacroMetadata` to enhance message filtering and incorporate
-  static information. New log macros suffixed with `_WITH_TAGS` introduced for this feature.
-  Additionally, `%(custom_tags)` parameter added
-  to `PatternFormatter`. ([#349](https://github.com/odygrd/quill/issues/349))
-  See [example_custom_tags.cpp](https://github.com/odygrd/quill/blob/master/examples/example_custom_tags.cpp)
-- Improvements to reduce compilation time
-
-## v3.4.1
-
-- Reduce backend worker unnecessary allocation. ([#368](https://github.com/odygrd/quill/issues/368))
-- Adjusted handling for empty `std::string_view` instances, addressing an issue where logging empty strings triggered an
-  unintended `memcpy` with zero size and a nullptr, leading to address sanitizer warnings.
-- Fix clang build error when using `-DQUILL_NO_EXCEPTIONS:BOOL=ON`. ([#357](https://github.com/odygrd/quill/issues/357))
-
-## v3.4.0
-
-- Resolved `bad_variant_access` error occurring when using Quill as a pre-compiled library with a distinct queue
-  type. ([#276](https://github.com/odygrd/quill/pull/276))
-
-- Resolved a bug in `RotatingFileHandler` associated with logfiles located outside the working directory,
-  specifically when used with open_mode `a`. ([#340](https://github.com/odygrd/quill/pull/340))
-
-- Added a `name()` method to the Logger class which provides the logger
-  name. ([#345](https://github.com/odygrd/quill/pull/345))
-
-- Fixed library and include paths in the pkg-config configuration. ([#352](https://github.com/odygrd/quill/pull/352))
-
-- Move `get_root_logger()` definition from cpp to the header file ([#348](https://github.com/odygrd/quill/issues/348))
-
-- Introduced support for logging character arrays. You can now log character arrays, even when they don't contain a
-  null-terminating character.
-  Additionally, character arrays with null characters in the middle are supported, and the logger will
-  capture the content until the null character is encountered. ([#353](https://github.com/odygrd/quill/pull/353))
-
-  For example
-
-  ```c++
-      union
-    {
-      char no_0[2];
-      char mid_0[6]{'1', '2', '3', '4', '\0', 6};
-    } char_arrays;
-
-    // only output "12" even if there's no '\0' at the end
-    LOG_INFO(logger, R"(This is a log info example for char array without '\0': {})", char_arrays.no_0);
-
-    // output "1234" until the '\0'
-    LOG_INFO(logger, R"(This is a log info example for char array with '\0' in middle: {})",
-             char_arrays.mid_0);
-  ```
-
-- Minor improvements in the bounded queue and throughput. ([#362](https://github.com/odygrd/quill/pull/362))
-
-  Previous: 2.21 million msgs/sec average, total time elapsed: 1809 ms for 4000000 log messages.
-
-  New:      2.24 million msgs/sec average, total time elapsed: 1787 ms for 4000000 log messages.
-
-- Disable `fmt::join(data, "")` at compile time. ([#356](https://github.com/odygrd/quill/issues/356))
-- Fix compile error in Apple Clang 12. ([#360](https://github.com/odygrd/quill/issues/360))
-- Add guards for redefined preprocessor variables.
-- Fix `uint64_t` to `time_t` implicit conversion error in Clang 18.
-- Update bundled `libfmt` to `v10.1.1`
-
-## v3.3.1
-
-- Fixed `RotatingFileHandler` to prevent accidental removal of non-log files when using open mode `w`
-  and `set_remove_old_files(true)`
-
-## v3.3.0
-
-- Added a `quill::get_handler(handler_name)` function that allows easy lookup of an existing `Handler` by name. This
-  function proves helpful when you want to retrieve a handler and pass it to a new logger.
-
-- Fix build failure of Intel Compiler Classic. ([#332](https://github.com/odygrd/quill/pull/332))
-
-- Introduced `QUILL_BLOCKING_QUEUE_RETRY_INTERVAL_NS` option for user-configurable retry interval in the blocking queue.
-  Default value is 800 nanoseconds. ([#330](https://github.com/odygrd/quill/pull/330))
-
-- Improved backend thread handling. Now verifies that all producer SPSC queues are empty before entering `sleep`.
-
-- Fixed a race condition and potential crash in `quill::remove_logger(Logger*)` when called without
-  prior `quill::flush()`.
-
-- Added protection to prevent removal of the root logger with `quill::remove_logger(Logger*)`.
-
-- Improved exception handling on the backend thread when calling `fmt::format()`.
-
-  While compile-time checks ensure that the format string and arguments match, runtime errors can still occur.
-  Previously, such exceptions would affect and drop subsequent log records. Now, exceptions are caught and logged
-  in the log file and reported via the backend thread notification handler (default is `cerr`).
-
-  For example, if a dynamic precision is used (`LOG_INFO(logger, "Support for floats {:.{}f}", 1.23456, 3.321312)`),
-  the log file will show the following error message:
-
-  ```
-  LOG_INFO root [format: "Support for floats {:.{}f}", error: "precision is not integer"]
-  ```
-
-  Additionally, an error message will be printed to `cerr`
-
-  ```
-  Quill ERROR: [format: "Support for floats {:.{}f}", error: "precision is not integer"]
-  ```
-
-- Fixed a bug in timestamp formatting that occasionally displayed an hour component of 0 as
-  24. ([#329](https://github.com/odygrd/quill/pull/329))
-
-- Added support for specifying a runtime log level, allowing dynamic log level configuration at runtime.
-  The new runtime log level feature provides flexibility when needed, with a minor overhead cost.
-  It is recommended to continue using the existing static log level macros for optimal
-  performance. ([#321](https://github.com/odygrd/quill/pull/321))
-
-  For example
-
-  ```c++
-    std::array<quill::LogLevel, 4> const runtime_log_levels = {quill::LogLevel::Debug,
-                                                               quill::LogLevel::Info,
-                                                               quill::LogLevel::Warning,
-                                                               quill::LogLevel::Error};
-  
-    for (auto const& log_level : runtime_log_levels)
-    {
-      LOG_DYNAMIC(logger, log_level, "Runtime {} {}", "log", "level");
-    }
-  ```
-
-- Added support for printf-style formatting with `_CFORMAT` macros. These macros use the `printf` format string syntax,
-  simplifying the migration of legacy codebases using `printf` statements.
-
-  For example
-
-  ```c++
-    std::array<uint32_t, 4> arr = {1, 2, 3, 4};
-    LOG_INFO(logger, "This is a log info example using fmt format {}", arr);
-    
-    LOG_INFO_CFORMAT(logger, "printf style %s supported %d %f", "also", 5, 2.32);
-  ```
-
-- Added a `metadata()` member function to the `TransitEvent` class. It provides access to the `Metadata` object
-  associated with the log record, simplifying syntax for retrieving log record metadata in custom Handlers.
-
-  For example
-
-  ```c++
-  void CustomHandler::write(fmt_buffer_t const& formatted_log_message, quill::TransitEvent const& log_event)
-  {
-    MacroMetadata const macro_metadata = log_event.metadata();
-  }
-  ```
-
-- Simplified file handler configuration. Now, instead of passing multiple arguments to the constructor,
-  you only need to provide a single `FileHandlerConfig` object. This change makes creating file handlers objects
-  much easier and more flexible.
-
-  For example
-
-  ```c++
-  quill::FileHandlerConfig file_handler_cfg;
-  file_handler_cfg.set_open_mode('w');
-  file_handler_cfg.set_append_to_filename(quill::FilenameAppend::StartDateTime);
-  
-  std::shared_ptr<quill::Handler> file_handler = quill::file_handler("application.log", file_handler_cfg);
-  quill::Logger* logger_foo = quill::create_logger("my_logger", std::move(file_handler));
-  
-  LOG_INFO(my_logger, "Hello from {}", "application");
-  ```
-
-- Combined the functionalities of `RotatingFileHandler` (rotating based on file size) and `TimeRotatingFileHandler`
-  (rotating on a time interval) into a single, more versatile `RotatingFileHandler`. Users can now conveniently rotate
-  logs based on both file size and time intervals simultaneously. The updated `RotatingFileHandler` offers a variety of
-  customization options for improved flexibility. For more information on available configurations,
-  refer to the `RotatingFileHandlerConfig` documentation.
-
-  For example
-
-  ```c++
-    // Create a rotating file handler which rotates daily at 18:30 or when the file size reaches 2GB
-  std::shared_ptr<quill::Handler> file_handler =
-    quill::rotating_file_handler(filename,
-                                 []()
-                                 {
-                                   quill::RotatingFileHandlerConfig cfg;
-                                   cfg.set_rotation_time_daily("18:30");
-                                   cfg.set_rotation_max_file_size(2'000'000'000);
-                                   return cfg;
-                                 }());
-
-  // Create a logger using this handler
-  quill::Logger* logger_bar = quill::create_logger("daily_logger", std::move(file_handler));
-  ```
-
-- Improved compatibility with older versions of external `libfmt`. Quill now compiles for all versions
-  of `libfmt >= 8.0.0`.
-
-## v3.2.0
-
-- Addition of std::is_trivially_copyable<T> to default copy loggable
-  types. ([#318](https://github.com/odygrd/quill/pull/318))
-- By default, the static library now builds with '-fPIC' to generate position-independent code.
-  To disable this feature, you can use the CMake option 'QUILL_DISABLE_POSITION_INDEPENDENT_CODE'.
-- The `LOG_<LEVEL>_LIMIT` macros now support using `std::chrono` duration types for specifying the log interval.
-  Instead of providing a raw number, you can use:
-
-  ```c++
-      LOG_INFO_LIMIT(std::chrono::milliseconds {100} , quill::get_logger(), "log message");
-  ```
-
-## v3.1.0
-
-- It is now possible to set a minimum logging interval for specific logs. For example:
-
-  ```c++
-    for (uint64_t i = 0; i < 10; ++i)
-    {
-      LOG_INFO_LIMIT(2000, default_logger, "log in a loop with limit 1 message every 2000 micros for i {}", i);
-      std::this_thread::sleep_for(std::chrono::microseconds{1000});
-    }
-  ```
-
-- `quill::utility::to_string()` now uses `fmt::to_string()`
-
-- Quill now utilizes a custom namespace (`fmtquill`) for the bundled fmt library. This enables smooth integration with
-  your own external fmt library, even if it's a different version.
-
-## v3.0.2
-
-- Add missing header on clang when `QUILL_X86ARCH` is defined.
-
-## v3.0.1
-
-- Enhanced the reported message for reallocation of the unbounded queue to include the thread id.
-
-## v3.0.0
-
-- The previous unbounded queue constantly reallocated memory, risking system memory exhaustion, especially when handling
-  intensive logging from multiple threads. Starting from `v3.0.0`, the default behavior has been improved to limit
-  the queue capacity to 2 GB. When this limit is reached, the queue blocks the hot thread instead of further
-  reallocation.
-  To modify the default behavior, there is no need to recompile the `quill` library. Recompile your application
-  with one of the following header-only flags.
-
-  ```shell
-  # Previous behavior in v2.*.*: Reallocates new queues indefinitely when max capacity is reached
-  -DCMAKE_CXX_FLAGS:STRING="-DQUILL_USE_UNBOUNDED_NO_MAX_LIMIT_QUEUE"
-  
-  # Default behavior in v3.*.*: Starts small, reallocates up to 2GB, then hot thread blocks
-  -DCMAKE_CXX_FLAGS:STRING="-DQUILL_USE_UNBOUNDED_BLOCKING_QUEUE"
-  
-  # Starts small, reallocates up to 2GB, then hot thread drops log messages
-  -DCMAKE_CXX_FLAGS:STRING="-DQUILL_USE_UNBOUNDED_DROPPING_QUEUE"
-  
-  # Fixed queue size, no reallocations, hot thread drops log messages
-  -DCMAKE_CXX_FLAGS:STRING="-DQUILL_USE_BOUNDED_QUEUE"         
-  
-  # Fixed queue size, no reallocations, hot thread blocks
-  -DCMAKE_CXX_FLAGS:STRING="-DQUILL_USE_BOUNDED_BLOCKING_QUEUE"
-  ```
-
-- Added support for huge pages on Linux. Enabling this feature allows bounded or unbounded queues to utilize huge pages,
-  resulting in optimized memory allocation.
-
-  ```c++
-    quill::Config cfg;
-    cfg.enable_huge_pages_hot_path = true;
-    
-    quill::configure(cfg);
-    quill::start();
-  ```
-
-- Added support for logging `std::optional`, which is also now supported in `libfmt` `v10.0.0`.
-
-  ```c++
-    LOG_INFO(default_logger, "some optionals [{}, {}]", std::optional<std::string>{},
-             std::optional<std::string>{"hello"});
-  ```
-
-- Introduced a new function `run_loop` in the `Handler` base class, which allows users to override and execute periodic
-  tasks. This enhancement provides users with the flexibility to perform various actions at regular intervals,
-  such as batch committing data to a database.
-- In scenarios where a hot thread is blocked and unable to push messages to the queue in blocking mode, this situation
-  will now be reported through the `backend_thread_notifications_handler` to the standard error stream `cerr`.
-
-## v2.9.2
-
-- Fix increased compile times due to `x86intrin` headers. ([#298](https://github.com/odygrd/quill/pull/298))
-- Fix compile error when using `QUILL_X86ARCH` on windows.
-- Fix bugs when quill is build as a shared library on windows. ([#302](https://github.com/odygrd/quill/pull/302))
-
-## v2.9.1
-
-- Removed `CMAKE_INSTALL_RPATH` from cmake. ([#284](https://github.com/odygrd/quill/pull/284))
-- Fix compile warning on Apple M1. ([#291](https://github.com/odygrd/quill/pull/291))
-- Update bundled `libfmt` to `v10.0.0`
-- Fix for `CMAKE_MODULE_PATH` ([#295](https://github.com/odygrd/quill/pull/295))
-- Fixed a bug in `TimeRotatingFileHandler` when `quill::FilenameAppend::None` is
-  used. ([#296](https://github.com/odygrd/quill/pull/296))
-- Fixed `TimeRotatingFileHandler` and `RotatingFileHandler` to work when `/dev/null` is used as a
-  filename ([#297](https://github.com/odygrd/quill/pull/297))
-- Added `NullHandler` that can be used to discard the logs. For example:
-
-  ```c++
-  int main()
-  {
-    quill::start();
-    
-    std::shared_ptr<quill::Handler> file_handler =
-      quill::null_handler();
-  
-    quill::Logger* logger_bar = quill::create_logger("nullhandler", std::move(file_handler));
-  
-    for (uint32_t i = 0; i < 150; ++i)
-    {
-      LOG_INFO(logger_bar, "Hello");
-    }
-  ```
-
-## v2.9.0
-
-**Fixes**
-
-- Fixed a bug in TimeRotatingFileHandler. ([#287](https://github.com/odygrd/quill/pull/287))
-
-**Improvements**
-
-- Renamed `backend_thread_error_handler` to `backend_thread_notifications_handler` in `Config.h`. Previously this
-  handler was used only to report errors from the backend worker thread to the user. This callback will also now report
-  info messages to the user.
-- Report unbounded spsc queue reallocation via
-  the `backend_thread_notifications_handler`. ([#286](https://github.com/odygrd/quill/pull/286))
-- Report bounded spsc queue dropped messages via the `backend_thread_notifications_handler`.
-
-## v2.8.0
-
-**Breaking Changes**
-(see `improvements` section for more details)
-
-- If you were previously compiling with `-DQUILL_USE_BOUNDED_QUEUE` or `QUILL_X86ARCH` you should now pass the
-  flag to you target as it is not propagated by CMake anymore.
-- There is a change in the API in `Quill.h` instead of `quill::Handler*` you should now use
-  `std::shared_ptr< quill::Handler >` and also move it to the created logger.
-
-**Improvements**
-
-- Add `append_to_filename` parameter when creating `quill::time_rotating_file_handler`
-  and `quill::rotating_file_handler`
-- Fix `Handlers` failing to find the file when the working directory of the application is changed in
-  runtime. ([#247](https://github.com/odygrd/quill/pull/247))
-- When the given output directory of a log file passed to a `Handler` does not exist, it will now get automatically
-  created.
-- Support Windows 10 LTSB 2016, 1607 and Server 2016. ([#251](https://github.com/odygrd/quill/pull/251))
-- Add back `backend_thread_sleep_duration` in `Config.h` ([#256](https://github.com/odygrd/quill/pull/256))
-- For `quill::rotating_file_handler(...)` and  `quill::time_rotating_file_handler(...)` the `backup_count` argument is
-  now default to `std::numeric_limits<std::uint32_t>::max()`
-- When the logging file is deleted from the command line while the logger is still using it, then a new file will be
-  reopened for writing.
-- Added `quill::Clock` which enables taking and converting TSC timestamps to system clock timestamps.
-  When `TimestampClockType::Tsc` is used as the default clock type in `Config.h` this class
-  can also be used to generate timestamps that are in sync with the timestamps in the log
-  file. ([#264](https://github.com/odygrd/quill/pull/264))
-- Both `Unbounded` and `Bounded` queue modes can now be used without having to recompile `quill` library. This is still
-  not a runtime option, you still need to recompile your target and pass `QUILL_USE_BOUNDED_QUEUE` as a flag.
-  See [example_bounded_queue_message_dropping.cpp](https://github.com/odygrd/quill/blob/master/examples/example_bounded_queue_message_dropping.cpp)
-- Added `QUILL_USE_BOUNDED_BLOCKING_QUEUE` option that makes possible to use a bounded queue which blocks the hot
-  thread rather than dropping messages ([#270](https://github.com/odygrd/quill/pull/270))
-  See [example_bounded_queue_blocking.cpp](https://github.com/odygrd/quill/blob/master/examples/example_bounded_queue_blocking.cpp)
-- Renamed `backend_thread_max_transit_events` to `backend_thread_transit_events_soft_limit` in
-  Config.h ([#270](https://github.com/odygrd/quill/pull/270))
-- Added `backend_thread_transit_events_hard_limit` in Config.h ([#270](https://github.com/odygrd/quill/pull/270))
-- Added `backend_thread_use_transit_buffer` in Config.h ([#270](https://github.com/odygrd/quill/pull/270))
-- CMake: `QUILL_X86ARCH` and `QUILL_USE_BOUNDED_QUEUE` options have been removed. The users can decide on enabling these
-  options on their side and quill doesn't need to be recompiled as a library. For example :
-  ```cmake
-     target_compile_definitions(<target> PUBLIC QUILL_X86ARCH QUILL_USE_BOUNDED_QUEUE)
-  ```
-- Added `quill::remove_logger(Logger* logger)` in `Quill.h`. This makes it possible to remove a logger in a thread safe
-  way. When a logger is removed any associated `FileHandlers` with that logger will also be removed and the files will
-  also be closed as long as they are not being used by another logger. The logger is asynchronously removed by the
-  logging
-  thread after all the messages are written. To achieve this the API had to change to return a
-  `std::shared_ptr< quill::Handler >` instead of `quill::Handler*`. See
-  [example_file_callbacks.cpp](https://github.com/odygrd/quill/blob/master/examples/example_file_callbacks.cpp)
-- Added `quill::wake_up_logging_thread()` in `Quill.h`. This thread safe function can be used to wake up the backend
-  logging thread on demand. ([#280](https://github.com/odygrd/quill/pull/280))
-- Round up queue capacity to the nearest power of 2. ([#282](https://github.com/odygrd/quill/pull/282))
-
-## v2.7.0
-
-**Fixes**
-
-- Remove references to build directory path from the compiled library's
-  symbols. ([#221](https://github.com/odygrd/quill/pull/221))
-- Fix when compiled as shared library with hidden visibility. ([#222](https://github.com/odygrd/quill/pull/222))
-- Fix equal timestamp log messages appearing out of order. ([#223](https://github.com/odygrd/quill/pull/223))
-- Reduce padding in some structs.
-- Fix 'rename_file' throwing an exception while being marked
-  as `noexcept`. ([#230](https://github.com/odygrd/quill/pull/230))
-- Fix crash with `std::bad_alloc` and compiler warnings in
-  gcc `7.3.1`. ([#235](https://github.com/odygrd/quill/pull/235))
-- The additional compiler definitions will now be propagated to the parent targets when enabling options in
-  CMake. ([#235](https://github.com/odygrd/quill/pull/235))
-
-**Improvements**
-
-- Improved performance and throughput of the backend logging thread by approximately ~25%
-- Add missing `quill::json_file_handler(...)` that creates a `JsonFileHandler` in `Quill.h`.
-- Simplified and refactored the logic in `BoundedQueue`.
-- Added the option `do_fsync` which also calls `fsync()` during the handler flush to all file handlers.
-- Replace `backend_thread_sleep_duration` with `backend_thread_yield` in `Config.h`
-- Remove trailing spaces in log levels strings. ([#237](https://github.com/odygrd/quill/pull/237))
-- The default log pattern has changed
-  to `"%(ascii_time) [%(thread)] %(fileline:<28) LOG_%(level_name:<9) %(logger_name:<12) %(message)")`
-- Added file event notifiers, to get callbacks from quill before/after log file has been opened or
-  closed. ([#193](https://github.com/odygrd/quill/pull/193))
-  This is useful for cleanup procedures or for adding something to the start/end of the log files.
-  for example
-
-  ```c++
-  int main()
-  {
-    quill::start();
-  
-    quill::FileEventNotifier fen;
-  
-    fen.before_open = [](quill::fs::path const& filename)
-    { std::cout << "before opening " << filename << std::endl; };
-  
-    fen.after_open = [](quill::fs::path const& filename, FILE* f)
-    { std::cout << "after opening " << filename << std::endl; };
-  
-    fen.before_close = [](quill::fs::path const& filename, FILE* f)
-    { std::cout << "before closing " << filename << std::endl; };
-  
-    fen.after_close = [](quill::fs::path const& filename)
-    { std::cout << "after closing " << filename << std::endl; };
-  
-    quill::Handler* file_handler =
-      quill::file_handler("myfile.log", "w", quill::FilenameAppend::None, std::move(fen));
-  
-    quill::Logger* mylogger = quill::create_logger("mylogger", file_handler);
-  
-    LOG_INFO(mylogger, "Hello world");
-  }
-  ```
-
-- Added `QUILL_X86ARCH` in `Tweakme.h`. When enabled it will attempt to minimize the cache pollution on x86 cpus that
-  support the instructions `_mm_prefetch `, `_mm_clflush` and `_mm_clflushopt`.
-
-  To compile when this flag is enabled you should also pass `-march` to the compiler which is required,
-  you can set this to your oldest cpu architecture among your systems.
-
-  To enable this option, `DQUILL_X86ARCH` must always be defined in quill library and also in your executable,
-  for example
-
-  ```shell
-  cmake -DCMAKE_CXX_FLAGS:STRING="-DQUILL_X86ARCH -march=native"
-  ```
-
-- Added `quill:get_root_logger()` which gives quick access to the root logger object and can be used directly in the hot
-  path.
-  This gives applications that only wish to use the root logger the convenience of not having to store and
-  pass `Logger*` objects anymore.
-  for example quill existing log macros can be overwritten to not require a `Logger*` anymore
-
-  ```c++
-  #define MY_LOG_INFO(fmt, ...) QUILL_LOG_INFO(quill::get_root_logger(), fmt, ##__VA_ARGS__)
-  ``````
-
-- Added `QUILL_ROOT_LOGGER_ONLY` in `Tweakme.h`. Define ths if you only plan to use the single `root` logger object,
-  When this is defined it will replace the LOG_ macros with the equivalent LOG_ macros but without the need of
-  passing `Logger*` objects anymore.
-  for example
-
-  ```c++
-  #define QUILL_ROOT_LOGGER_ONLY
-  #include "quill/Quill.h"
-  
-  int main()
-  {
-    quill::start();
-  
-    // because we defined QUILL_ROOT_LOGGER_ONLY we do not have to pass a logger* anymore, the root logger is always used
-    LOG_INFO("Hello {}", "world");
-    LOG_ERROR("This is a log error example {}", 7);
-  }
-  ```
-
-## v2.6.0
-
-**Fixes**
-
-- Fix filepath on Windows when MinGW is used. ([#212](https://github.com/odygrd/quill/pull/212))
-
-**Improvements**
-
-- Removed the creation of `static Metadata` objects during initialisation time.
-- `#define QUILL_QUEUE_CAPACITY` has been removed.
-- Added Config option `default_queue_capacity` that can be used to specify the initial capacity of the queue.
-- When Unbounded queue is used the newly allocated queue will now have enough space to fit any
-  object. ([#215](https://github.com/odygrd/quill/pull/215))
-
-## v2.5.1
-
-**Improvements**
-
-- Reduced the allocations performed by the backend worker thread as the same objects are now being reused rather than
-  destroyed.
-
-**Summary of changes since v2.3.2**
-
-In version `2.3.2` when multiple threads performed heavy logging, the backend logging thread incorrectly gave
-priority to the logs of the same threads. That made logs from the remaining threads to appear much later or sometimes
-never in the log files.
-
-There was a series of fixes and releases to address this.
-
-Below is the summary of the changes from `v2.3.2`
-
-- Previously when multiple threads were logging, the backend logging thread would first try to read the log messages of
-  the same thread until its queue was completely empty before reading the log messages of the next thread.
-  When one of the threads was logging a lot, it could result in only displaying the log of that thread, hiding the
-  logs of the other threads. This has now been fixed and all log messages from all threads are read fairly.
-
-- Optimise the backend logging thread to read all log messages from each queue. Ensure all queues
-  from all active threads are fairly read.
-
-- `fmt::basic_memory_buffer` buffer stack size has been reduced. The backend thread shows better performance with
-  a reduced stack size. This also reduces the risk of a stack overflow when too many log messages are cached.lllllllllll
-
-- Reduced the allocations performed by the backend worker thread as the same objects are now being reused rather than
-  destroyed.
-
-- Added a config option `backend_thread_strict_log_timestamp_order`. This option enables an extra timestamp
-  check on the backend logging thread when each message is popped from the queues. It prevents a rare
-  situation where log messages from different threads could appear in the log file in the wrong order. This flag
-  is now enabled by default.
-
-- Added a config option `backend_thread_empty_all_queues_before_exit`. This option makes the backend logging thread
-  to wait until all the queues are empty before exiting. This ensures no log messages are lost when the application
-  exists. This flag is now enabled by default.
-
-## v2.5.0
-
-**Improvements**
-
-- Performance improvements for the backend logging thread
-
-## v2.4.2
-
-**Fixes**
-
-- Fixes an assertion that was triggered in debug mode due to changes in v2.4.1
-
-## v2.4.1
-
-**Improvements**
-
-- Previously the backend worker thread would read all the log messages from the queue but not read the log messages when
-  the buffer had wrapped around. It will now read all the messages.
-- Removed the `min_available_bytes` cache from the SPSC queue as an optimisation. It is not needed anymore as we now
-  read all messages at once instead of reading message by message.
-
-## v2.4.0
-
-**Improvements**
-
-- Added a config option `backend_thread_strict_log_timestamp_order`. This option enables an extra timestamp
-  check on the backend logging thread when each message is popped from the queues. It prevents a rare
-  situation where log messages from different threads could appear in the log file in the wrong order. This flag
-  is now enabled by default.
-
-- Added a config option `backend_thread_empty_all_queues_before_exit`. This option makes the backend logging thread
-  to wait until all the queues are empty before exiting. This ensures no log messages are lost when the application
-  exists. This flag is now enabled by default.
-
-## v2.3.4
-
-**Improvements**
-
-- Optimise the backend logging thread to read multiple log messages from the same queue, but still fairly read each
-  queue from all active threads.
-
-## v2.3.3
-
-**Fixes**
-
-- Previously when multiple threads were logging, Quill backend logging thread would first try reading the log messages
-  of
-  one thread until the queue was completely empty before reading the log messages of the next thread.
-  When one of the threads was logging a lot, it could result in only displaying the log of that thread, hiding the
-  logs of the other threads. This has now been fixed and all log messages from all threads are read fairly.
-
-## v2.3.2
-
-**Fixes**
-
-- Fix code not compiling with treat warnings as errors set on
-  Windows. ([#198](https://github.com/odygrd/quill/pull/198))
-
-## v2.3.1
-
-**Fixes**
-
-- Optimise logging queue cache alignment of variables. It seems that v2.3.0 made the hot path slower by ~5 ns per
-  message. This has been fixed in this version and the performance is now the same as in the previous versions.
-
-## v2.3.0
-
-**Improvements**
-
-- Cache the available bytes for reading in the logging queue. This is meant to offer some minor performance
-  improvement to the backend logging thread. [#185](https://github.com/odygrd/quill/issues/185)
-
-- Fixed static code analysis and clang '-Wdocumentation' warnings.
-
-- The `Handler.h` API has changed in this version to support structured logs. If you have implemented your own custom
-  `Handler` you will have to change it to follow the new API.
-
-- This version adds support for writing structured logs. Structured logs provide easier search through events.
-  Structured logging is automatically enabled when named arguments are provided to the format string. Structured logs
-  are only supported by the new `quill::JsonFileHandler` handler. The already existing `FileHandler` and
-  `ConsoleHandler` are compatible with named arguments, but they will ignore them and output the log in its
-  original format, as defined by the pattern formatter.
-  Structured logs are not supported for wide characters at the moment.
-  See [example_json_structured_log.cpp](https://github.com/odygrd/quill/blob/master/examples/example_json_structured_log.cpp)
-
-For example :
-
-```c++
-  quill::start();
-
-  quill::Handler* json_handler =
-    quill::create_handler<quill::JsonFileHandler>("json_output.log", "w");
-
-  // create another logger tha logs e.g. to stdout and to the json file at the same time
-  quill::Logger* logger = quill::create_logger("dual_logger", {quill::stdout_handler(), json_handler});
-  for (int i = 2; i < 4; ++i)
-  {
-    LOG_INFO(logger, "{method} to {endpoint} took {elapsed} ms", "POST", "http://", 10 * i);
-  }
-```
-
-1) Will write to stdout (stdout_handler) :
-
-````
-23:37:19.850432433 [11811] example_json_structured_log.cpp:39 LOG_INFO      dual_logger  - POST to http:// took 20 ms
-23:37:19.850440154 [11811] example_json_structured_log.cpp:39 LOG_INFO      dual_logger  - POST to http:// took 30 ms
-````
-
-2) Will produce a JSON file (json_handler) :
-
-```
-{ "timestamp": "23:37:19.850432433", "file": "example_json_structured_log.cpp", "line": "39", "thread_id": "11811", "logger": "dual_logger", "level": "Info", "message": "{method} to {endpoint} took {elapsed} ms", "method": "POST", "endpoint": "http://", "elapsed": "20" }
-{ "timestamp": "23:37:19.850440154", "file": "example_json_structured_log.cpp", "line": "39", "thread_id": "11811", "logger": "dual_logger", "level": "Info", "message": "{method} to {endpoint} took {elapsed} ms", "method": "POST", "endpoint": "http://", "elapsed": "30" }
-```
-
-## v2.2.0
-
-**Improvements**
-
-- Previously storing the default root logger by calling `quill::get_logger()` followed by `quill::configure(cfg)`
-  would invalidate the pointer to the default root logger returned by the former function. This has now been fixed and
-  the obtained `Logger*` pointer is still valid.
-- Disable `fmt::streamed()`. ([#189](https://github.com/odygrd/quill/issues/189))
-- Update bundled fmt to 9.1.0
-- `logger->should_log(level)` is removed. A compile time check was added to `logger->should_log<level>()`
-  . ([#187](https://github.com/odygrd/quill/issues/187))
-
-## v2.1.0
-
-**Improvements**
-
-This version includes breaking changes to the API. Those changes are related to how quill is configured,
-before calling `quill::start()` to start the backend thread.
-
-Check the updated [examples](https://github.com/odygrd/quill/blob/master/examples).
-
-[Config.h](https://github.com/odygrd/quill/blob/master/quill/include/quill/Config.h) - contains runtime configuration
-options
-
-[TweakMe.h](https://github.com/odygrd/quill/blob/master/quill/include/quill/TweakMe.h) - contains compile time
-configuration
-
-For example `quill::set_default_logger_handler(...)` has been removed. To set a default filehandler :
-
-```cpp
-  // create a handler
-  quill::Handler* file_handler = quill::file_handler("test.log", "w");
-
-  file_handler->set_pattern(
-    "%(ascii_time) [%(thread)] %(fileline:<28) %(level_name) %(logger_name:<12) - %(message)",
-    "%Y-%m-%d %H:%M:%S.%Qms", quill::Timezone::GmtTime);
-
-  // set the handler as the default handler for any newly created logger in the config
-  quill::Config cfg;
-  cfg.default_handlers.emplace_back(file_handler);
-
-  // configure must always be called prior to `start()`
-  quill::configure(cfg);
-  quill::start();
-```
-
-- Removed some API functions from `Quill.h` that were previously used for configuration. Instead, `quill::Config` object
-  has to be created. For example `quill::config::set_backend_thread_cpu_affinity(1);` has been removed and instead the
-  following code is needed :
-
-```cpp
-  quill::Config cfg;
-  cfg.backend_thread_cpu_affinity = 1;
-  quill::configure(cfg);
-```
-
-- `QUILL_CHRONO_CLOCK` has been moved from `TweakMe.h` to `Config.h`. It is now possible to switch between `rdtsc`
-  and `system`
-  clocks without re-compiling.
-  See [example_trivial_system_clock.cpp](https://github.com/odygrd/quill/blob/master/examples/example_trivial_system_clock.cpp)
-- `QUILL_RDTSC_RESYNC_INTERVAL` has been moved from `TweakMe.h` to `Config.h`.
-- It is now possible to log user timestamps rather than the system's. This feature is useful for time simulations.
-  See [example_custom_clock.cpp](https://github.com/odygrd/quill/blob/master/examples/example_custom_clock.cpp)
-  and [example_custom_clock_advanced.cpp](https://github.com/odygrd/quill/blob/master/examples/example_custom_clock_advanced.cpp)
-- Previously the logger names were limited to a maximum of 22 characters. This limitation has been removed.
-- Added support for gcc 7.5.0. ([#178](https://github.com/odygrd/quill/issues/178))
-- Updated bundled fmt to 9.0.0
-
-## v2.0.2
-
-**Fixes**
-
-- Fix crash when a `std::string` containing null-terminated characters is passed to the
-  logger. ([#176](https://github.com/odygrd/quill/issues/176))
-
-## v2.0.1
-
-**Improvements**
-
-- Add a flag to RotatingFileHandler to disable removing the old files when `w` mode is used.
-
-## v2.0.0
-
-From version `v2` and onwards only c++17 is supported.
-
-This version is a major refactor.
-
-**Fixes**
-
-- RotatingFileHandler will now correctly rotate the files when append mode is
-  used ([#123](https://github.com/odygrd/quill/issues/123))
-
-**Improvements**
-
-- Reduced and simplified codebase.
-- Improved backend worker thread performance.
-- `QUILL_DUAL_QUEUE_MODE` has been removed. A single queue now handles every case.
-- `QUILL_STRING` has been removed. That macro is no longer required when passing a format string to the
-  PatternFormatter.
-
-**Differences**
-
-- `v1.7` compiles with c++14, `v2` only compiles for c++17.
-- `v1.7` on Windows supports wide character logging, `v2` has limited wide character support such as logging `wchar_t`
-  , `std::wstring`, `std::wstring_view`. For example, logging `std::vector<std::wstring>` is not supported.
-- `v1.7` on Windows requires the filepath used for the handlers as a wide strings, `v2` supports only filenames as
-  narrow strings.
-
-## v1.7.3
-
-**Improvements/Fixes**
-
-- Fix crash on windows when a long wstring (>500 chars) is logged ([#173](https://github.com/odygrd/quill/issues/173))
-- Fix compiler error when trying to compile with
-  -DQUILL_DISABLE_NON_PREFIXED_MACROS ([#174](https://github.com/odygrd/quill/issues/174))
-- Fix a compile warning in clang ([#175](https://github.com/odygrd/quill/issues/175))
-
-## v1.7.2
-
-**Improvements/Fixes**
-
-- Fix compile error when C++20 is used on windows ([#162](https://github.com/odygrd/quill/issues/162))
-
-## v1.7.1
-
-**Improvements/Fixes**
-
-- Fix support for wide characters on Windows ([#168](https://github.com/odygrd/quill/issues/168))
-- Fix compilation error when `Quill::Logger*` is stored as a class member in templated classes
-- Add `FilenameAppend::DateTime` as an option when creating a file handler
-
-## v1.7.0
-
-**New Features**
-
-- Add a new function `quill::get_all_loggers()` that returns all the existing
-  loggers. ([#114](https://github.com/odygrd/quill/issues/114))
-- Add `%(level_id)` to pattern formatter. ([#136](https://github.com/odygrd/quill/issues/136))
-- Users can now specialise `copy_loggable<T>` to mark user defined types as safe to
-  copy. ([#132](https://github.com/odygrd/quill/issues/132))
-
-**Improvements/Fixes**
-
-- Fix initializations for C++17.
-- Fix compiler warning in `check_format()` function.
-- Replace `QUILL_DUAL_QUEUE_MODE` with `QUILL_DISABLE_DUAL_QUEUE_MODE`.
-- Update bundled fmt to 8.1.1
-- Minor performance and accuracy improvements to rdtsc clock used by the backend thread.
-- Fix compile error when C++20 is used. ([#162](https://github.com/odygrd/quill/issues/162))
-- Fix `get_page_size()` to only call sysconf once. ([#160](https://github.com/odygrd/quill/issues/160))
-- Fix incorrect timestamps in the log file when the system clock is
-  updated. ([#127](https://github.com/odygrd/quill/issues/127))
-- Previously if `quill:start(true)` was called more than once in the application, the signal handlers would get
-  initialised again. Now any subsequent calls to `quill:start(true)` will now have no effect
-  ([#167](https://github.com/odygrd/quill/issues/167))
-- Previously when the max limit of rotated files in `RotatingFileHandler` was reached, quill would stop rotating and
-  instead keep logging everything into the last log file. Now when the maximum limit of files is reached,
-  quill will now keep rotating by replacing the oldest logs. ([#157](https://github.com/odygrd/quill/issues/157))
-- Improve the backend logging thread responsiveness when variables are logged in loops without any delay
-  from multiple threads. ([#116](https://github.com/odygrd/quill/issues/116))
-- Fix some undefined behaviour issues reported via the AddressSantizer on the backend logging
-  thread. ([#166](https://github.com/odygrd/quill/issues/166))
-
-## v1.6.3
-
-**Improvements/Fixes**
-
-- Add support for `%(thread_name)` in PatternFormatter. ([#97](https://github.com/odygrd/quill/issues/97))
-- Add missing header needed for recent versions of fmt. ([#95](https://github.com/odygrd/quill/issues/95))
-- Force flush all active handlers on application exit.
-- Update bundled fmt to 8.0.1
-
-## v1.6.2
-
-**Fixes**
-
-- Fix WIN32 compilation error when `NOMINMAX` is already defined.
-- Fix `string` to `wstring` MinGW conversion. ([#92](https://github.com/odygrd/quill/issues/92))
-- Log enums via the main queue. ([#90](https://github.com/odygrd/quill/issues/90))
-- Fix windows compiler error when `min/max` macros are defined. ([#94](https://github.com/odygrd/quill/issues/94))
-
-## v1.6.1
-
-**Improvements/Fixes**
-
-- Fix windows C++20 build. ([#83](https://github.com/odygrd/quill/issues/83))
-- Fix ARM build on windows.
-- Fix `example_backtrace` and minor bug when destructing with empty backtrace.
-
-## v1.6.0
-
-**New Features**
-
-- Dual queue mode offering even lower latencies on hot paths.
-  See [Dual Queue Mode](https://github.com/odygrd/quill/wiki/9.-Dual-Queue-Mode).
-- Added a signal handler for linux and windows. The signal handler flushes the log when the app crashes or
-  exits. ([#1](https://github.com/odygrd/quill/issues/1))
-- Added support for custom handlers. ([#75](https://github.com/odygrd/quill/issues/75))
-- Quill now compiles and runs on Cygwin.
-
-**Improvements/Fixes**
-
-- The queue from the caller to the backend worker thread has been reworked. The new queue generates slightly better
-  assembly than the previous one. Quill does no longer depend on mapping the same region of physical memory twice.
-- Replaced an assertion check that could trigger incorrectly. ([#68](https://github.com/odygrd/quill/issues/68))
-- Fixed build on `ARM_ARCH < 6`. ([#78](https://github.com/odygrd/quill/issues/78))
-- Fixed compile errors when `QUILL_NOEXCEPTIONS`, `CMAKE_CXX_STANDARD 20`, `QUILL_USE_BOUNDED_QUEUE` are set.
-- The unit tests have been moved to a separate binary with their own `main()`. This increased build times when building
-  the tests, but the failures are now easier to debug on different CI platforms and the tests can also run faster in
-  parallel.
-- Fixed minor compiler warnings on windows.
-- Upgraded bundled libfmt to `7.1.3`
-
-**Note**
-
-- If a custom queue capacity is defined using `#define QUILL_QUEUE_CAPACITY` after `1.6.0` the whole library needs to be
-  recompiled.
-
-## v1.5.2
-
-- Removed the use of `fmt::format()` in `FileUtilities.cpp` as a workaround to the link errors in fmt v7. Use the header
-  only version of libfmt when external libfmt is defiend is no longer required.
-
-## v1.5.1
-
-- When QUILL_FMT_EXTERNAL is defined, `quill` will use the header only version of `libfmt`. This is a workaround to the
-  link errors after libftm v7
-
-## v1.5.0
-
-- Upgraded bundled libfmt to `7.1.2`
-- Added `Filters`. The filter class can be used for filtering log records. Filters can be added to handler instances.
-  See [example_filters.cpp](https://github.com/odygrd/quill/blob/master/examples/example_filters.cpp)
-- It is now possible to set the log level severity on the handler objects.
-  See [example_filters.cpp](https://github.com/odygrd/quill/blob/master/examples/example_handler_log_levels.cpp) ([#49](https://github.com/odygrd/quill/issues/49))
-- Timestamp formatting optimisation for the backend worker thread.
-- Free list allocator optimisation for the backend worker thread.
-- Fixed PatternFormatter ignoring a portion of the pattern was ignored, when no format specifiers were
-  present. ([#56](https://github.com/odygrd/quill/issues/56))
-- When `%(function_name)` is used in PatternFormatter the namespace delimiter is replaced from `::` to `.` (Windows
-  only). ([#61](https://github.com/odygrd/quill/issues/61))
-- Arguments passed to the logger are no longer being evaluated when the log statement is not
-  logged. ([#67](https://github.com/odygrd/quill/issues/67))
-- PatternFormatter enhancement. It is now possible to pass [{fmt} string syntax](https://fmt.dev/latest/syntax.html)
-  to `QUILL_STRING`. The default PatternFormatter string has been changed
-  to: `"%(ascii_time) [%(thread)] %(fileline:<28) LOG_%(level_name) %(logger_name:<12) - %(message)"`. This results to
-  the following log being properly aligned despite the different lengths of each filename and logger name.
-
-```
-22:31:07.995438465 [2666041] file1.h:11                   LOG_INFO      logger1      - Log from file.
-22:31:07.995445699 [2666041] long_file2.h:11              LOG_INFO      logger_fl2   - Log from other file.
-22:31:07.995457144 [2666041] a_longer_file_3.hpp:11       LOG_INFO      logger_fl2_l - Log from other file.
-22:31:07.995462471 [2666041] example_trivial.cpp:30       LOG_TRACE_L3  root         - This is a log trace l3 example 1
-```
-
-## v1.4.1
-
-- Do not force `quill` to always build as `static` library in cmake.
-- Minor fix when `quill` is compiled with no exceptions.
-- Add the option to disable the non prefixed macro definitions if `QUILL_DISABLE_NON_PREFIXED_MACROS` is
-  defined. ([#40](https://github.com/odygrd/quill/issues/40))
-
-## v1.4.0
-
-- Added support for printing colour codes in the terminal.
-  See [ConsoleHandler](https://github.com/odygrd/quill/wiki/2.-Handlers#consolehandler)
-- RotatingFileHandler improvements and minor change in API.
-  See [RotatingFileHandler](https://github.com/odygrd/quill/wiki/2.-Handlers#rotatingfilehandler)
-- DailyFileHandler is removed and replaced by TimeRotatingFileHandler.
-  See [TimeRotatingFileHandler](https://github.com/odygrd/quill/wiki/2.-Handlers#timerotatingfilehandler)
-- Added backtrace logging. Log messages can be stored in a buffer and flushed later on demand.
-  See [Backtrace Logging](https://github.com/odygrd/quill/wiki/6.-Backtrace-Logging)
-- Added bundled `doctest` `2.4.0`
-- Migrated all tests from `gtest` to `doctest`.
-- Upgraded bundled libfmt to `7.0.3`
-
-## v1.3.3
-
-- Upgraded bundled libfmt to `7.0.2`
-- Fixed compile error with libfmt versions > `7.0.0`
-
-## v1.3.2
-
-- Add a CMake option `QUILL_USE_BOUNDED_QUEUE` for bounded queue.
-- Fixed a clang 10 warning
-- Fixed MinGw build
-
-## v1.3.1
-
-- Minor CMake fixes when `QUILL_FMT_EXTERNAL` option is used.
-
-## v1.3.0
-
-**New Features**
-
-- Added option `QUILL_NO_EXCEPTIONS` to disable exceptions, std::abort() is called instead of an
-  exception. ([#16](https://github.com/odygrd/quill/issues/16))
-- Exceptions thrown in the backend worker thread, will now call a user provided error handler callback to handle the
-  error. ([#21](https://github.com/odygrd/quill/issues/21))
-- Compile time checks for unsafe to copy user defined types. Non trivial user defined types must be explicitly tagged as
-  safe to copy with the use of `QUILL_COPY_LOGGABLE;`. Otherwise they have to be formatted and passed as a string to the
-  logger by the user. The old unsafe mode is still usable
-  by `#define QUILL_MODE_UNSAFE` ([#20](https://github.com/odygrd/quill/issues/20))
-- Added `QUILL_USE_BOUNDED_QUEUE`. In this mode no new queues get allocated but instead log messages get lost. Number of
-  lost messages is reported to stderr.
-- Minor hot path optimisation. The pointer to the metadata for each log message is no logger copied to the queue but
-  passed as a template argument instead.
-- Added a latency benchmark, easily extendable for any logger
-
-**Improvements/Fixes**
-
-- `QUILL_RDTSC_CLOCK` option is replaced by `QUILL_CHRONO_CLOCK` which is by OFF by default.
-- Improve compiler error message when trying to log a non copy constructible user defined type
-- Fix buffer reallocation bug on TimestampFormatter. In previous versions any timestamp format set to 'set_pattern'
-  expanding to a string longer than 32 bytes would cause a crash. ([#24](https://github.com/odygrd/quill/issues/24))
-- The backend logging thread will now copy all messages from the SPSC queue to a local priority queue. This keeps the
-  SPSC less empty avoiding a potential allocation on the hot path.
-- `std::string_view` is now promoted to `std::string` to take a deep copy
-- The queue capacity has been moved from `config` to `Tweakme.h`.
-- Multiple formats patterns support for `stdout` and `stderr` handlers.
-  See [example_stdout_multiple_formatters.cpp](https://github.com/odygrd/quill/blob/master/examples/example_custom_formatter.cpp)
-- `quill::start()` will now block until the backend worker has started.
-- Upgraded bundled libfmt to `6.2.1`
-
-## v1.2.3
-
-- CMake changes to support package installation in conan.
-
-## v1.2.2
-
-- Support for `arm/arm64`. ([#19](https://github.com/odygrd/quill/issues/19))
-- Add a cmake option `QUILL_ENABLE_INSTALL` to enable cpack.
-
-## v1.2.1
-
-- Improved `QUILL_RDTSC_CLOCK` tweak option. It is now possible to switch between using `rdtsc` or `std::chrono` clock
-  without having to recompile quill as library.
-
-## v1.2.0
-
-- Linking and including an external version of `fmt` is now supported. See `TweakMe.h`
-- Fixed compiler warnings when using clang's `-Wdocumentation`. ([#12](https://github.com/odygrd/quill/issues/12))
-- Fixed a bug that wouldn't report a compile-time error for invalid format
-  strings. ([#13](https://github.com/odygrd/quill/issues/13))
-- Added process ID to Formatter. ([#14](https://github.com/odygrd/quill/issues/14))
-- Enhanced timestamp formatting. The `timestamp_format` string passed
-  in `handler->set_pattern(format_pattern, timestamp_format, timezone)` now accepts three additional specifiers `%Qms`
-  , `%Qus`, `%Qus` that can be used to format the fractional seconds.
-  See [here](https://github.com/odygrd/quill/wiki/3.-Formatters). ([#15](https://github.com/odygrd/quill/issues/15))
-
-## v1.1.0
-
-- Daily file handler. The file handler rollover every 24 hours
-- Rotating file handler. The file handler will rollover based on the size of the file
-- MinGW compatibility
-- Added a CMake option `QUILL_VERBOSE_MAKEFILE`. Building Quill as a master project now defaults to non verbose makefile
-  output unless `-DQUILL_VERBOSE_MAKEFILE=ON` is passed to CMake. ([#6](https://github.com/odygrd/quill/issues/6))
-- Flush policy improvement. Previously Quill backend worker thread would never `flush`. This made watching the live log
-  of the application harder because the user has to wait for the operating system to flush or `quill::flush()` had to be
-  called on the caller threads. This has now been fixed, when the backend thread worker has no more log messages to
-  process it will automatically `flush`. ([#8](https://github.com/odygrd/quill/issues/8))
-- The log level names have been changed from `"LOG_INFO"`, `"LOG_DEBUG"`, etc to `"INFO"`, `"DEBUG"`, etc .. The default
-  formatter string is now using `"LOG_"%(level_name)` instead of `%(level_name)` therefore there is now change in the
-  behaviour. This change gives a lot of more flexibility to users who prefer to see e.g. `INFO` instead of `LOG_INFO` in
-  the logs. ([#7](https://github.com/odygrd/quill/issues/7))
-- An option has been added to append the date to the filename when using a
-  FileHandler `quill::file_handler(filename, mode, FilenameAppend);`. ([#7](https://github.com/odygrd/quill/issues/7))
-- It is now possible to specify the timezone of each handler timestamp. A new parameter is added
-  to `file_handler->set_pattern(...)`. See `PatternFormatter::Timezone`
-  . ([#7](https://github.com/odygrd/quill/issues/7))
-- Rename `emit` as it can conflict with Qt macros. ([#4](https://github.com/odygrd/quill/issues/4))
-- Upgraded `libfmt` to `6.2.0`.
-
-## v1.0.0
-
-- Initial release.
-- Using `libfmt` to `6.1.2`.
diff --git a/subprojects/quill-4.2.0/CMakeLists.txt b/subprojects/quill-4.2.0/CMakeLists.txt
deleted file mode 100644
index d8e771e..0000000
--- a/subprojects/quill-4.2.0/CMakeLists.txt
+++ /dev/null
@@ -1,166 +0,0 @@
-cmake_minimum_required(VERSION 3.8)
-project(quill)
-
-#-------------------------------------------------------------------------------------------------------
-# Options
-#-------------------------------------------------------------------------------------------------------
-
-# Builds Quill without exceptions by adding the -fno-exceptions flag to the compiler.
-option(QUILL_NO_EXCEPTIONS "Build without exceptions using -fno-exceptions flag" OFF)
-
-# Disables features that rely on retrieving the thread name, which is not supported in older versions of Windows (e.g., Windows Server 2012/2016).
-# Enabling this option ensures compatibility with older Windows versions.
-option(QUILL_NO_THREAD_NAME_SUPPORT "Disable features not supported on Windows Server 2012/2016" OFF)
-
-# Enables the use of _mm_prefetch, _mm_clflush, and _mm_clflushopt instructions to enhance cache coherence performance on x86 architectures.
-# When enabled, Quill will utilize these instructions on the frontend's queue operations.
-# Ensure to specify the target architecture with -march="..." when compiling to maximize compatibility and performance.
-option(QUILL_X86ARCH "Enable optimizations for cache coherence on x86 architectures using specific CPU instructions" OFF)
-
-# When enabled, removes the non-prefixed `LOG_*` macros, leaving only `QUILL_LOG_*` macros available.
-# This is useful in scenarios where the original macro names conflict with those of an existing logging library.
-option(QUILL_DISABLE_NON_PREFIXED_MACROS "Disable non-prefixed macros" OFF)
-
-option(QUILL_DISABLE_POSITION_INDEPENDENT_CODE "Disable position-independent code" OFF)
-
-option(QUILL_BUILD_EXAMPLES "Build the examples" OFF)
-
-option(QUILL_BUILD_TESTS "Build the tests (Requires https://github.com/google/googletest to be installed)" OFF)
-
-option(QUILL_BUILD_BENCHMARKS "Build the benchmarks" OFF)
-
-option(QUILL_SANITIZE_ADDRESS "Enable address sanitizer in tests" OFF)
-
-option(QUILL_SANITIZE_THREAD "Enable thread sanitizer in tests (Using this option with any other compiler except clang may result to false positives)" OFF)
-
-option(QUILL_CODE_COVERAGE "Enable code coverage" OFF)
-
-option(QUILL_USE_VALGRIND "Use valgrind as the default memcheck tool in CTest (Requires Valgrind)" OFF)
-
-option(QUILL_ENABLE_INSTALL "Enable CMake Install when Quill is not a master project" OFF)
-
-option(QUILL_DOCS_GEN "Generate documentation" OFF)
-
-#-------------------------------------------------------------------------------------------------------
-# Use newer policies if possible, up to most recent tested version of CMake.
-#-------------------------------------------------------------------------------------------------------
-cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
-
-#-------------------------------------------------------------------------------------------------------
-# Include common compiler options
-#-------------------------------------------------------------------------------------------------------
-include(${PROJECT_SOURCE_DIR}/cmake/SetCommonCompileOptions.cmake)
-
-#-------------------------------------------------------------------------------------------------------
-# Determine if quill is built as a subproject (using add_subdirectory) or if it is the master project.
-#-------------------------------------------------------------------------------------------------------
-set(QUILL_MASTER_PROJECT FALSE CACHE BOOL "Master Project" FORCE)
-if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-    set(QUILL_MASTER_PROJECT TRUE CACHE BOOL "Master Project" FORCE)
-endif ()
-
-#-------------------------------------------------------------------------------------------------------
-# Custom cmake functions
-#-------------------------------------------------------------------------------------------------------
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/quill/cmake")
-include(Utility)
-
-#-------------------------------------------------------------------------------------------------------
-# Resolve version
-#-------------------------------------------------------------------------------------------------------
-quill_extract_version()
-
-project(quill VERSION ${QUILL_VERSION} LANGUAGES CXX)
-
-#-------------------------------------------------------------------------------------------------------
-# Set default build to release
-#-------------------------------------------------------------------------------------------------------
-if (NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build" FORCE)
-endif ()
-
-#---------------------------------------------------------------------------------------
-# Compiler config
-#---------------------------------------------------------------------------------------
-if (NOT CMAKE_CXX_STANDARD)
-    set(CMAKE_CXX_STANDARD 17)
-    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-endif ()
-
-#-------------------------------------------------------------------------------------------------------
-# Required Packages
-#-------------------------------------------------------------------------------------------------------
-find_package(Threads REQUIRED)
-
-if (QUILL_BUILD_TESTS)
-    enable_testing()
-
-    if (QUILL_USE_VALGRIND)
-        # find valgrind
-        find_program(MEMORYCHECK_COMMAND NAMES valgrind)
-        if (NOT MEMORYCHECK_COMMAND)
-            message(WARNING "Valgrind not found")
-        endif ()
-
-        # set valgrind params
-        set(MEMORYCHECK_COMMAND_OPTIONS "--tool=memcheck --leak-check=full --leak-resolution=med --show-leak-kinds=all --track-origins=yes --vgdb=no --fair-sched=yes")
-
-        # add memcheck test action to ctest
-        include(CTest)
-    endif ()
-endif ()
-
-#-------------------------------------------------------------------------------------------------------
-# Log Info
-#-------------------------------------------------------------------------------------------------------
-if (QUILL_MASTER_PROJECT)
-    option(QUILL_VERBOSE_MAKEFILE "Verbose make output" OFF)
-
-    message(STATUS "CMAKE_BUILD_TYPE: " ${CMAKE_BUILD_TYPE})
-    message(STATUS "QUILL_VERSION: ${QUILL_VERSION}")
-endif ()
-
-message(STATUS "QUILL_NO_EXCEPTIONS: " ${QUILL_NO_EXCEPTIONS})
-message(STATUS "QUILL_NO_THREAD_NAME_SUPPORT: " ${QUILL_NO_THREAD_NAME_SUPPORT})
-message(STATUS "QUILL_X86ARCH: " ${QUILL_X86ARCH})
-message(STATUS "QUILL_DISABLE_NON_PREFIXED_MACROS: " ${QUILL_DISABLE_NON_PREFIXED_MACROS})
-
-#---------------------------------------------------------------------------------------
-# Verbose make file option
-#---------------------------------------------------------------------------------------
-if (QUILL_VERBOSE_MAKEFILE)
-    set(CMAKE_VERBOSE_MAKEFILE TRUE CACHE BOOL "Verbose output" FORCE)
-endif ()
-
-# address sanitizer flags
-if (QUILL_SANITIZE_ADDRESS)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,undefined -fno-omit-frame-pointer -g")
-endif ()
-
-# thread sanitizer flags
-if (QUILL_SANITIZE_THREAD)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
-endif ()
-
-# Append extra options for coverage
-if (QUILL_CODE_COVERAGE)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g -fprofile-arcs -ftest-coverage")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
-endif ()
-
-# Build Examples
-if (QUILL_BUILD_EXAMPLES)
-    add_subdirectory(examples)
-endif ()
-
-if (QUILL_BUILD_BENCHMARKS)
-    add_subdirectory(benchmarks)
-endif ()
-
-add_subdirectory(quill)
-
-if (QUILL_DOCS_GEN)
-    # Add the cmake folder so the FindSphinx module is found
-    set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
-    add_subdirectory(docs)
-endif ()
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/LICENSE b/subprojects/quill-4.2.0/LICENSE
deleted file mode 100644
index 7cc1c04..0000000
--- a/subprojects/quill-4.2.0/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 - present, Odysseas Georgoudis
-
-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.
diff --git a/subprojects/quill-4.2.0/LICENSE.build b/subprojects/quill-4.2.0/LICENSE.build
deleted file mode 100644
index b59833d..0000000
--- a/subprojects/quill-4.2.0/LICENSE.build
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (c) 2021 The Meson development team
-
-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.
diff --git a/subprojects/quill-4.2.0/README.md b/subprojects/quill-4.2.0/README.md
deleted file mode 100644
index 6d09ff9..0000000
--- a/subprojects/quill-4.2.0/README.md
+++ /dev/null
@@ -1,511 +0,0 @@
-<div align="center">
-  <a href="https://github.com/odygrd/quill">
-    <img width="125" src="https://i.postimg.cc/DZrH8HkX/quill-circle-photos-v2-x2-colored-toned.png" alt="Quill logo">
-  </a>
-  <h1>Quill</h1>
-
-  <div>
-    <a href="https://github.com/odygrd/quill/actions?query=workflow%3Alinux">
-      <img src="https://img.shields.io/github/actions/workflow/status/odygrd/quill/linux.yml?branch=master&label=linux&logo=linux&style=flat-square" alt="linux-ci" />
-    </a>
-    <a href="https://github.com/odygrd/quill/actions?query=workflow%3Amacos">
-      <img src="https://img.shields.io/github/actions/workflow/status/odygrd/quill/macos.yml?branch=master&label=macos&logo=apple&logoColor=white&style=flat-square" alt="macos-ci" />
-    </a>
-    <a href="https://github.com/odygrd/quill/actions?query=workflow%3Awindows">
-      <img src="https://img.shields.io/github/actions/workflow/status/odygrd/quill/windows.yml?branch=master&label=windows&logo=windows&logoColor=blue&style=flat-square" alt="windows-ci" />
-    </a>
-  </div>
-
-  <div>
-    <a href="https://codecov.io/gh/odygrd/quill">
-      <img src="https://img.shields.io/codecov/c/gh/odygrd/quill/master.svg?logo=codecov&style=flat-square" alt="Codecov" />
-    </a>
-    <a href="https://app.codacy.com/gh/odygrd/quill/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade">
-      <img src="https://img.shields.io/codacy/grade/cd387bc34658475d98bff84db3ad5287?logo=codacy&style=flat-square" alt="Codacy" />
-    </a>
-    <a href="https://www.codefactor.io/repository/github/odygrd/quill">
-      <img src="https://img.shields.io/codefactor/grade/github/odygrd/quill?logo=codefactor&style=flat-square" alt="CodeFactor" />
-     </a>
-  </div>
-
-  <div>
-    <a href="https://opensource.org/licenses/MIT">
-      <img src="https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square" alt="license" />
-    </a>
-    <a href="https://en.wikipedia.org/wiki/C%2B%2B17">
-      <img src="https://img.shields.io/badge/language-C%2B%2B17-red.svg?style=flat-square" alt="language" />
-    </a>
-  </div>
-
-  <p><b>Asynchronous Low Latency C++ Logging Library</b></p>
-
-</div>
-
-
-<br>
-
-- [Introduction](#introduction)
-- [Documentation](#documentation)
-- [Features](#features)
-- [Caveats](#caveats)
-- [Performance](#performance)
-- [Quick Start](#quick-start)
-- [CMake Integration](#cmake-integration)
-- [Design](#design)
-- [License](#license)
-
-|       homebrew       |         vcpkg         |       conan       |
-|:--------------------:|:---------------------:|:-----------------:|
-| `brew install quill` | `vcpkg install quill` | `quill/[>=1.2.3]` |
-
-## Introduction
-
-Quill is a high-performance, cross-platform logging library designed for C++17 and onwards.
-Quill is a production-ready logging library that has undergone extensive unit testing. It has been successfully utilized
-in production environments, including financial trading applications, providing high-performance and reliable logging
-capabilities.
-
-## Documentation
-
-For detailed documentation and usage instructions, please visit
-the [Quill Documentation on Read the Docs](http://quillcpp.readthedocs.io/). It provides comprehensive information on
-how to integrate and utilize Quill in your C++ applications.
-
-Additionally, you can explore the [examples](http://github.com/odygrd/quill/tree/master/examples) folder in the Quill
-repository on GitHub. These examples serve as valuable resources to understand different usage scenarios and demonstrate
-the capabilities of the library.
-
-## Features
-
-- **Low Latency Logging**: Achieve fast logging performance with low latency. Refer to
-  the [Benchmarks](http://github.com/odygrd/quill#performance) for more details.
-- **Asynchronous logging**: Log arguments and messages are formatted in a backend logging thread, effectively offloading
-  the formatting overhead from the critical path.
-- **Custom Formatters**: Customize log formatting based on user-defined patterns.
-  Explore [Formatters](http://quillcpp.readthedocs.io/en/latest/tutorial.html#formatters) for further details.
-- **Flexible Timestamp Generation**: Choose between rdtsc, chrono, or custom clocks (useful for simulations) for
-  log message timestamp generation.
-- **Log Stack Traces**: Store log messages in a ring buffer and display them later in response to a higher severity log
-  statement or on demand. Refer
-  to [Backtrace Logging](http://quillcpp.readthedocs.io/en/latest/tutorial.html#backtrace-logging) for more information.
-- **Multiple Logging Sinks**: Utilize various logging targets, including:
-  - Console logging with color support.
-  - File logging.
-  - Rotating log files based on time or size.
-  - JSON logging.
-  - Custom sinks.
-- **Log Message Filtering**: Apply filters to selectively process log messages. Learn more
-  about [Filters](http://quillcpp.readthedocs.io/en/latest/tutorial.html#filters).
-- **Structured Logging**: Generate JSON structured logs.
-  See [Structured-Log](http://quillcpp.readthedocs.io/en/latest/tutorial.html#json-log) for details.
-- **Blocking or Dropping Message Modes**: Choose between `blocking` or `dropping` message modes in the library.
-  In `blocking` mode, the hot threads pause and wait when the queue is full until space becomes available, ensuring no
-  message loss but introducing potential latency. In `dropping` mode, log messages beyond the queue's capacity may be
-  dropped to prioritize low latency. The library provides reports on dropped messages, queue reallocations, and blocked
-  hot threads for monitoring purposes.
-- **Queue Types**: The library supports different types of queues for transferring logs from the hot path to the backend
-  thread: bounded queues with a fixed capacity and unbounded queues that start small and can dynamically grow.
-- **Wide Character Support**: Wide strings compatible with ASCII encoding are supported, applicable to Windows only.
-  Additionally, there is support for logging STL containers consisting of wide strings. Note that chaining STL types,
-  such as `std::vector<std::vector<std::wstring>>` is not supported for wide strings.
-- **Ordered Log Statements**: Log statements are ordered by timestamp even when produced by different threads,
-  facilitating easier debugging of multithreaded applications.
-- **Compile-Time Log Level Stripping**: Completely strip out log levels at compile time, reducing `if` branches.
-- **Clean and Warning-Free Codebase**: Ensure a clean and warning-free codebase, even with high compiler warning levels.
-- **Crash-Safe Behavior**: Benefit from crash-safe behavior with a built-in signal handler.
-- **Type-Safe API**: Type safe api using the excellent [{fmt}](http://github.com/fmtlib/fmt) library.
-- **Huge Pages**: Benefit from support for huge pages on the hot path. This feature allows for improved performance and
-  efficiency.
-
-## Caveats
-
-Quill may not work well with `fork()` since it spawns a background thread and `fork()` doesn't work well
-with multithreading.
-
-If your application uses `fork()` and you want to log in the child processes as well, you should call
-`quill::start()` after the `fork()` call. Additionally, you should ensure that you write to different
-files in the parent and child processes to avoid conflicts.
-
-For example :
-
-```c++
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/FileSink.h"
-
-int main()
-{
-  // DO NOT CALL THIS BEFORE FORK
-  // quill::Backend::start();
-
-  if (fork() == 0)
-  {
-    quill::Backend::start();
-        
-    // Get or create a handler to the file - Write to a different file
-    auto file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(
-      "child.log");
-    
-    quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(file_sink));
-
-    QUILL_LOG_INFO(logger, "Hello from Child {}", 123);
-  }
-  else
-  {
-    quill::Backend::start();
-          
-    // Get or create a handler to the file - Write to a different file
-    auto file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(
-      "parent.log");
-    
-    quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(file_sink));
-    
-    QUILL_LOG_INFO(logger, "Hello from Parent {}", 123);
-  }
-}
-```
-
-## Performance
-
-### Latency
-
-The results presented in the tables below are measured in `nanoseconds (ns)`.
-
-#### Logging Numbers
-
-The following message is logged 100'000 times for each thread:
-
-`LOG_INFO(logger, "Logging int: {}, int: {}, double: {}", i, j, d)`.
-
-##### 1 Thread Logging
-
-| Library                                                             | 50th | 75th | 90th | 95th | 99th | 99.9th |
-|---------------------------------------------------------------------|:----:|:----:|:----:|:----:|:----:|:------:|
-| [Quill v4.1 Bounded Dropping Queue](http://github.com/odygrd/quill) |  7   |  7   |  8   |  8   |  9   |   10   |
-| [fmtlog](http://github.com/MengRao/fmtlog)                          |  8   |  8   |  9   |  9   |  10  |   13   |
-| [Quill v4.1 Unbounded Queue](http://github.com/odygrd/quill)        |  8   |  8   |  9   |  9   |  10  |   13   |
-| [Quill v3.8 Unbounded Queue](http://github.com/odygrd/quill)        |  8   |  8   |  9   |  9   |  10  |   13   |
-| [PlatformLab NanoLog](http://github.com/PlatformLab/NanoLog)        |  11  |  12  |  13  |  14  |  15  |   20   |
-| [MS BinLog](http://github.com/Morgan-Stanley/binlog)                |  21  |  21  |  22  |  24  |  28  |   57   |
-| [Reckless](http://github.com/mattiasflodin/reckless)                |  41  |  45  |  47  |  48  |  49  |   69   |
-| [Iyengar NanoLog](http://github.com/Iyengar111/NanoLog)             |  51  |  54  |  63  |  81  | 113  |  160   |
-| [spdlog](http://github.com/gabime/spdlog)                           | 148  | 153  | 159  | 163  | 169  |  176   |    
-| [g3log](http://github.com/KjellKod/g3log)                           | 1192 | 1282 | 1363 | 1440 | 1624 |  1802  |
-
-##### 4 Threads Logging Simultaneously
-
-| Library                                                             | 50th | 75th | 90th | 95th | 99th | 99.9th |
-|---------------------------------------------------------------------|:----:|:----:|:----:|:----:|:----:|:------:|
-| [Quill v4.1 Bounded Dropping Queue](http://github.com/odygrd/quill) |  7   |  8   |  9   |  9   |  10  |   13   |
-| [fmtlog](http://github.com/MengRao/fmtlog)                          |  8   |  8   |  9   |  9   |  11  |   13   |
-| [Quill v3.8 Unbounded Queue](http://github.com/odygrd/quill)        |  8   |  9   |  10  |  10  |  11  |   13   |
-| [Quill v4.1 Unbounded Queue](http://github.com/odygrd/quill)        |  9   |  9   |  10  |  11  |  12  |   15   |
-| [PlatformLab NanoLog](http://github.com/PlatformLab/NanoLog)        |  12  |  13  |  13  |  14  |  15  |   19   |
-| [MS BinLog](http://github.com/Morgan-Stanley/binlog)                |  21  |  21  |  22  |  22  |  29  |   62   |
-| [Reckless](http://github.com/mattiasflodin/reckless)                |  42  |  46  |  47  |  48  |  54  |   78   |
-| [Iyengar NanoLog](http://github.com/Iyengar111/NanoLog)             |  53  |  62  |  93  | 122  | 150  |  216   |
-| [spdlog](http://github.com/gabime/spdlog)                           | 209  | 236  | 276  | 304  | 409  |  700   | 
-| [g3log](http://github.com/KjellKod/g3log)                           | 1344 | 1415 | 1489 | 1557 | 1815 |  5855  |
-
-#### Logging Large Strings
-
-The following message is logged 100'000 times for each thread:
-
-`LOG_INFO(logger, "Logging int: {}, int: {}, string: {}", i, j, large_string)`.
-
-The large string used in the log message is over 35 characters to prevent the short string optimization
-of `std::string`.
-
-##### 1 Thread Logging
-
-| Library                                                             | 50th | 75th | 90th | 95th | 99th | 99.9th |
-|---------------------------------------------------------------------|:----:|:----:|:----:|:----:|:----:|:------:|
-| [Quill v3.8 Unbounded Queue](http://github.com/odygrd/quill)        |  10  |  12  |  13  |  13  |  14  |   16   |
-| [Quill v4.1 Bounded Dropping Queue](http://github.com/odygrd/quill) |  11  |  12  |  13  |  14  |  15  |   17   |
-| [fmtlog](http://github.com/MengRao/fmtlog)                          |  11  |  12  |  13  |  14  |  15  |   17   |
-| [PlatformLab NanoLog](http://github.com/PlatformLab/NanoLog)        |  13  |  14  |  15  |  15  |  17  |   19   |
-| [Quill v4.1 Unbounded Queue](http://github.com/odygrd/quill)        |  13  |  14  |  16  |  16  |  17  |   21   |
-| [MS BinLog](http://github.com/Morgan-Stanley/binlog)                |  22  |  23  |  23  |  25  |  30  |   59   |
-| [Iyengar NanoLog](http://github.com/Iyengar111/NanoLog)             |  52  |  55  |  64  |  83  | 114  |  160   |
-| [Reckless](http://github.com/mattiasflodin/reckless)                | 102  | 122  | 134  | 137  | 143  |  153   |
-| [spdlog](http://github.com/gabime/spdlog)                           | 120  | 123  | 127  | 130  | 138  |  145   |    
-| [g3log](http://github.com/KjellKod/g3log)                           | 955  | 1049 | 1129 | 1190 | 1351 |  1539  |
-
-##### 4 Threads Logging Simultaneously
-
-| Library                                                             | 50th | 75th | 90th | 95th | 99th | 99.9th |
-|---------------------------------------------------------------------|:----:|:----:|:----:|:----:|:----:|:------:|
-| [Quill v4.1 Bounded Dropping Queue](http://github.com/odygrd/quill) |  11  |  12  |  13  |  15  |  16  |   18   |
-| [fmtlog](http://github.com/MengRao/fmtlog)                          |  11  |  12  |  13  |  15  |  16  |   18   |
-| [Quill v3.8 Unbounded Queue](http://github.com/odygrd/quill)        |  12  |  13  |  14  |  15  |  16  |   19   |
-| [PlatformLab NanoLog](http://github.com/PlatformLab/NanoLog)        |  13  |  15  |  15  |  16  |  17  |   20   |
-| [Quill v4.1 Unbounded Queue](http://github.com/odygrd/quill)        |  14  |  16  |  17  |  18  |  19  |   22   |
-| [MS BinLog](http://github.com/Morgan-Stanley/binlog)                |  23  |  24  |  24  |  25  |  31  |   62   |
-| [Iyengar NanoLog](http://github.com/Iyengar111/NanoLog)             |  53  |  60  |  92  | 121  | 149  |  212   |
-| [Reckless](http://github.com/mattiasflodin/reckless)                | 101  | 121  | 133  | 136  | 143  |  160   |
-| [spdlog](http://github.com/gabime/spdlog)                           | 186  | 215  | 266  | 297  | 381  |  641   |
-| [g3log](http://github.com/KjellKod/g3log)                           | 1089 | 1164 | 1252 | 1328 | 1578 |  5563  |
-
-#### Logging Complex Types
-
-The following message is logged 100'000 times for each thread:
-
-`LOG_INFO(logger, "Logging int: {}, int: {}, vector: {}", i, j, v)`.
-
-Logging `std::vector<std::string> v` containing 16 large strings, each ranging from 50 to 60 characters.
-The strings used in the log message are over 35 characters to prevent the short string optimization of `std::string`.
-
-##### 1 Thread Logging
-
-| Library                                                             | 50th | 75th | 90th | 95th | 99th | 99.9th |
-|---------------------------------------------------------------------|:----:|:----:|:----:|:----:|:----:|:------:|
-| [Quill v4.1 Unbounded Queue](http://github.com/odygrd/quill)        |  52  |  54  |  56  |  58  |  60  |   63   |
-| [Quill v4.1 Bounded Dropping Queue](http://github.com/odygrd/quill) |  53  |  55  |  57  |  59  |  62  |  103   |
-| [MS BinLog](http://github.com/Morgan-Stanley/binlog)                |  66  |  70  |  79  |  81  |  84  |   91   |
-| [Quill v3.8 Unbounded Queue](http://github.com/odygrd/quill)        | 632  | 651  | 676  | 698  | 737  |  1049  | 
-| [fmtlog](http://github.com/MengRao/fmtlog)                          | 724  | 752  | 776  | 789  | 814  |  857   |
-| [spdlog](http://github.com/gabime/spdlog)                           | 6242 | 6331 | 6438 | 6523 | 6782 |  7341  |
-
-##### 4 Threads Logging Simultaneously
-
-| Library                                                             | 50th | 75th | 90th | 95th | 99th | 99.9th |
-|---------------------------------------------------------------------|:----:|:----:|:----:|:----:|:----:|:------:|
-| [Quill v4.1 Bounded Dropping Queue](http://github.com/odygrd/quill) |  55  |  57  |  59  |  61  |  64  |   77   |
-| [MS BinLog](http://github.com/Morgan-Stanley/binlog)                |  70  |  74  |  83  |  85  |  88  |  102   |
-| [Quill v4.1 Unbounded Queue](http://github.com/odygrd/quill)        |  92  | 100  | 110  | 118  | 135  |  157   |
-| [Quill v3.8 Unbounded Queue](http://github.com/odygrd/quill)        | 674  | 694  | 736  | 762  | 805  |  884   |
-| [fmtlog](http://github.com/MengRao/fmtlog)                          | 789  | 813  | 833  | 845  | 872  |  908   |
-| [spdlog](http://github.com/gabime/spdlog)                           | 6500 | 6596 | 6724 | 6848 | 7560 |  9036  |
-
-The benchmark was conducted on `Linux RHEL 9` with an `Intel Core i5-12600` at 4.8 GHz.
-The cpus are isolated on this system and each thread was pinned to a different CPU. `GCC 13.1` was used as the compiler.
-
-The benchmark methodology involved logging 20 messages in a loop, calculating and storing the average latency for those
-20 messages, then waiting around ~2 milliseconds, and repeating this process for a specified number of iterations.
-
-_In the `Quill Bounded Dropping` benchmarks, the dropping queue size is set to `262,144` bytes, which is double the
-default size of `131,072` bytes._
-
-You can find the benchmark code on the [logger_benchmarks](http://github.com/odygrd/logger_benchmarks) repository.
-
-### Throughput
-
-The maximum throughput is measured by determining the maximum number of log messages the backend logging thread can
-write to the log file per second.
-
-When measured on the same system as the latency benchmarks mentioned above the average throughput of the backend
-logging thread is `4.56 million msgs/sec`
-
-While the primary focus of the library is not on throughput, it does provide efficient handling of log messages across
-multiple threads. The backend logging thread, responsible for formatting and ordering log messages from hot threads,
-ensures that all queues are emptied on a high priority basis. The backend thread internally buffers the log messages 
-and then writes them later when the caller thread queues are empty or when a predefined limit, 
-`backend_thread_transit_events_soft_limit`, is reached. This approach prevents the need for allocating new queues
-or dropping messages on the hot path.
-
-Comparing throughput with other logging libraries in an asynchronous logging scenario has proven challenging. Some
-libraries may drop log messages, resulting in smaller log files than expected, while others only offer asynchronous
-flush, making it difficult to determine when the logging thread has finished processing all messages.
-In contrast, Quill provides a blocking flush log guarantee, ensuring that every log message from the hot threads up to
-that point is flushed to the file.
-
-For benchmarking purposes, you can find the
-code [here](https://github.com/odygrd/quill/blob/master/benchmarks/backend_throughput/quill_backend_throughput.cpp).
-
-### Compilation Time
-
-Compile times are measured using `clang 15` and for `Release` build.
-
-Below, you can find the additional headers that the library will include when you need to log, following
-the [recommended_usage](https://github.com/odygrd/quill/blob/master/examples/recommended_usage/recommended_usage.cpp)
-example
-
-![quill_v4_1_compiler_profile.speedscope.png](docs%2Fquill_v4_1_compiler_profile.speedscope.png)
-
-There is also a compile-time benchmark measuring the compilation time of 2000 auto-generated log statements with
-various arguments. You can find
-it [here](https://github.com/odygrd/quill/blob/master/benchmarks/compile_time/compile_time_bench.cpp). It takes approximately 30
-seconds to compile.
-
-![quill_v4_compiler_bench.speedscope.png](docs%2Fquill_v4_compiler_bench.speedscope.png)
-
-## Quick Start
-
-```c++
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/FileSink.h"
-
-int main()
-{
-  // Start the backend thread
-  quill::Backend::start();
-
-  // Log to file
-  auto file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(
-    "example_file_logging.log");
-
-  quill::Logger* logger =
-    quill::Frontend::create_or_get_logger("root", std::move(file_sink));
-
-  // set the log level of the logger to trace_l3 (default is info)
-  logger->set_log_level(quill::LogLevel::TraceL3);
-  
-  LOG_INFO(logger, "Welcome to Quill!");
-  LOG_ERROR(logger, "An error message. error code {}", 123);
-  LOG_WARNING(logger, "A warning message.");
-  LOG_CRITICAL(logger, "A critical error.");
-  LOG_DEBUG(logger, "Debugging foo {}", 1234);
-  LOG_TRACE_L1(logger, "{:>30}", "right aligned");
-  LOG_TRACE_L2(logger, "Positional arguments are {1} {0} ", "too", "supported");
-  LOG_TRACE_L3(logger, "Support for floats {:03.2f}", 1.23456);
-}
-```
-
-```c++
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/ConsoleSink.h"
-
-int main()
-{
-  // Start the backend thread
-  quill::Backend::start();
-
-  // Frontend
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-  quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));
-
-  // Change the LogLevel to print everything
-  logger->set_log_level(quill::LogLevel::TraceL3);
-
-  LOG_INFO(logger, "Welcome to Quill!");
-  LOG_ERROR(logger, "An error message. error code {}", 123);
-  LOG_WARNING(logger, "A warning message.");
-  LOG_CRITICAL(logger, "A critical error.");
-  LOG_DEBUG(logger, "Debugging foo {}", 1234);
-  LOG_TRACE_L1(logger, "{:>30}", "right aligned");
-  LOG_TRACE_L2(logger, "Positional arguments are {1} {0} ", "too", "supported");
-  LOG_TRACE_L3(logger, "Support for floats {:03.2f}", 1.23456);
-}
-```
-
-### Output
-
-[![Screenshot-2020-08-14-at-01-09-43.png](http://i.postimg.cc/02Vbt8LH/Screenshot-2020-08-14-at-01-09-43.png)](http://postimg.cc/LnZ95M4z)
-
-## CMake-Integration
-
-#### External
-
-##### Building and Installing Quill
-
-```
-git clone http://github.com/odygrd/quill.git
-mkdir cmake_build
-cd cmake_build
-cmake ..
-make install
-```
-
-Note: To install in custom directory invoke cmake with `-DCMAKE_INSTALL_PREFIX=/quill/install-dir/`
-
-Then use the library from a CMake project, you can locate it directly with `find_package()`
-
-##### Directory Structure
-
-```
-my_project/
-├── CMakeLists.txt
-├── main.cpp
-```
-
-##### CMakeLists.txt
-
-```cmake
-# Set only if needed - quill was installed under a custom non-standard directory
-set(CMAKE_PREFIX_PATH /test_quill/usr/local/)
-
-find_package(quill REQUIRED)
-
-# Linking your project against quill
-add_executable(example main.cpp)
-target_link_libraries(example PUBLIC quill::quill)
-```
-
-#### Embedded
-
-To embed the library directly, copy the source [folder](http://github.com/odygrd/quill/tree/master/quill/quill) to your
-project and call `add_subdirectory()` in your `CMakeLists.txt` file
-
-##### Directory Structure
-
-```
-my_project/
-├── quill/            (source folder)
-├── CMakeLists.txt
-├── main.cpp
-```
-
-##### CMakeLists.txt
-
-```cmake
-cmake_minimum_required(VERSION 3.1.0)
-project(my_project)
-
-set(CMAKE_CXX_STANDARD 17)
-
-add_subdirectory(quill)
-
-add_executable(my_project main.cpp)
-target_link_libraries(my_project PUBLIC quill::quill)
-```
-
-#### Building Quill for Android NDK
-
-To build Quill for Android NDK add the following `CMake` flags when configuring the build:
-
-  ```
-  -DQUILL_NO_THREAD_NAME_SUPPORT:BOOL=ON
-  ```
-
-## Design
-
-### Frontend (caller-thread)
-
-When invoking a `LOG_` macro:
-
-1. Creates a static constexpr metadata object to store `Metadata` such as the format string and source location.
-
-2. Pushes the data SPSC lock-free queue. For each log message, the following variables are pushed
-
-| Variable   |                                                  Description                                                   |
-|------------|:--------------------------------------------------------------------------------------------------------------:|
-| timestamp  |                                               Current timestamp                                                |
-| Metadata*  |                                        Pointer to metadata information                                         |
-| Logger*    |                                         Pointer to the logger instance                                         |
-| DecodeFunc | A pointer to a templated function containing all the log message argument types, used for decoding the message |
-| Args...    |           A serialized binary copy of each log message argument that was passed to the `LOG_` macro            |
-
-### Backend
-
-Consumes each message from the SPSC queue, retrieves all the necessary information and then formats the message.
-Subsequently, forwards the log message to all Sinks associated with the Logger.
-
-![design.jpg](docs%2Fdesign.jpg)
-
-## License
-
-Quill is licensed under the [MIT License](http://opensource.org/licenses/MIT)
-
-Quill depends on third party libraries with separate copyright notices and license terms.
-Your use of the source code for these subcomponents is subject to the terms and conditions of the following licenses.
-
-- ([MIT License](http://opensource.org/licenses/MIT)) {fmt} (http://github.com/fmtlib/fmt/blob/master/LICENSE.rst)
-- ([MIT License](http://opensource.org/licenses/MIT)) doctest (http://github.com/onqtam/doctest/blob/master/LICENSE.txt)
diff --git a/subprojects/quill-4.2.0/benchmarks/CMakeLists.txt b/subprojects/quill-4.2.0/benchmarks/CMakeLists.txt
deleted file mode 100644
index 81fe064..0000000
--- a/subprojects/quill-4.2.0/benchmarks/CMakeLists.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-add_subdirectory(hot_path_latency)
-add_subdirectory(backend_throughput)
-add_subdirectory(compile_time)
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/benchmarks/backend_throughput/CMakeLists.txt b/subprojects/quill-4.2.0/benchmarks/backend_throughput/CMakeLists.txt
deleted file mode 100644
index 33ae268..0000000
--- a/subprojects/quill-4.2.0/benchmarks/backend_throughput/CMakeLists.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-add_executable(BENCHMARK_quill_backend_throughput quill_backend_throughput.cpp)
-set_common_compile_options(BENCHMARK_quill_backend_throughput)
-target_link_libraries(BENCHMARK_quill_backend_throughput quill)
-
-add_executable(BENCHMARK_quill_backend_throughput_no_buffering quill_backend_throughput_no_buffering.cpp)
-set_common_compile_options(BENCHMARK_quill_backend_throughput_no_buffering)
-target_link_libraries(BENCHMARK_quill_backend_throughput_no_buffering quill)
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/benchmarks/backend_throughput/quill_backend_throughput.cpp b/subprojects/quill-4.2.0/benchmarks/backend_throughput/quill_backend_throughput.cpp
deleted file mode 100644
index 87eac80..0000000
--- a/subprojects/quill-4.2.0/benchmarks/backend_throughput/quill_backend_throughput.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#include <chrono>
-#include <iostream>
-
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-static constexpr size_t total_iterations = 4'000'000;
-
-/**
- * The backend worker just spins, so we just measure the total time elapsed for total_iterations
- */
-int main()
-{
-  // main thread affinity
-  quill::detail::set_cpu_affinity(0);
-
-  quill::BackendOptions backend_options;
-  backend_options.backend_cpu_affinity = 5;
-
-  // Start the logging backend thread and give it some tiem to init
-  quill::Backend::start(backend_options);
-
-  std::this_thread::sleep_for(std::chrono::milliseconds{100});
-
-  // Create a file sink to write to a file
-  std::shared_ptr<quill::Sink> file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(
-    "quill_backend_total_time.log",
-    []()
-    {
-      quill::FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    quill::FileEventNotifier{});
-
-  quill::Logger* logger = quill::Frontend::create_or_get_logger(
-    "bench_logger", std::move(file_sink),
-    "%(time) [%(thread_id)] %(short_source_location) %(log_level) %(message)");
-
-  quill::Frontend::preallocate();
-
-  // start counting the time until backend worker finishes
-  auto const start_time = std::chrono::steady_clock::now();
-  for (size_t iteration = 0; iteration < total_iterations; ++iteration)
-  {
-    LOG_INFO(logger, "Iteration: {} int: {} double: {}", iteration, iteration * 2,
-             static_cast<double>(iteration) / 2);
-  }
-
-  // block until all messages are flushed
-  logger->flush_log();
-
-  auto const end_time = std::chrono::steady_clock::now();
-  auto const delta = end_time - start_time;
-  auto delta_d = std::chrono::duration_cast<std::chrono::duration<double>>(delta).count();
-
-  std::cout << fmtquill::format(
-                 "Throughput is {:.2f} million msgs/sec average, total time elapsed: {} ms for {} "
-                 "log messages \n",
-                 total_iterations / delta_d / 1e6,
-                 std::chrono::duration_cast<std::chrono::milliseconds>(delta).count(), total_iterations)
-            << std::endl;
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/benchmarks/backend_throughput/quill_backend_throughput_no_buffering.cpp b/subprojects/quill-4.2.0/benchmarks/backend_throughput/quill_backend_throughput_no_buffering.cpp
deleted file mode 100644
index 6bbf1bf..0000000
--- a/subprojects/quill-4.2.0/benchmarks/backend_throughput/quill_backend_throughput_no_buffering.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#include <chrono>
-#include <iostream>
-
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-static constexpr size_t total_iterations = 4'000'000;
-
-/**
- * The backend worker just spins, so we just measure the total time elapsed for total_iterations
- */
-int main()
-{
-  // main thread affinity
-  quill::detail::set_cpu_affinity(0);
-
-  quill::BackendOptions backend_options;
-  backend_options.backend_cpu_affinity = 5;
-  backend_options.transit_events_hard_limit = 1;
-
-  // Start the logging backend thread and give it some tiem to init
-  quill::Backend::start(backend_options);
-
-  std::this_thread::sleep_for(std::chrono::milliseconds{100});
-
-  // Create a file sink to write to a file
-  std::shared_ptr<quill::Sink> file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(
-    "quill_backend_total_time.log",
-    []()
-    {
-      quill::FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    quill::FileEventNotifier{});
-
-  quill::Logger* logger = quill::Frontend::create_or_get_logger(
-    "bench_logger", std::move(file_sink),
-    "%(time) [%(thread_id)] %(short_source_location) %(log_level) %(message)");
-
-  quill::Frontend::preallocate();
-
-  // start counting the time until backend worker finishes
-  auto const start_time = std::chrono::steady_clock::now();
-  for (size_t iteration = 0; iteration < total_iterations; ++iteration)
-  {
-    LOG_INFO(logger, "Iteration: {} int: {} double: {}", iteration, iteration * 2,
-             static_cast<double>(iteration) / 2);
-  }
-
-  // block until all messages are flushed
-  logger->flush_log();
-
-  auto const end_time = std::chrono::steady_clock::now();
-  auto const delta = end_time - start_time;
-  auto delta_d = std::chrono::duration_cast<std::chrono::duration<double>>(delta).count();
-
-  std::cout << fmtquill::format(
-                 "Throughput is {:.2f} million msgs/sec average, total time elapsed: {} ms for {} "
-                 "log messages \n",
-                 total_iterations / delta_d / 1e6,
-                 std::chrono::duration_cast<std::chrono::milliseconds>(delta).count(), total_iterations)
-            << std::endl;
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/benchmarks/compile_time/CMakeLists.txt b/subprojects/quill-4.2.0/benchmarks/compile_time/CMakeLists.txt
deleted file mode 100644
index 34fba58..0000000
--- a/subprojects/quill-4.2.0/benchmarks/compile_time/CMakeLists.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-add_subdirectory(qwrapper)
-
-add_executable(BENCHMARK_quill_compile_time compile_time_bench.cpp)
-set_common_compile_options(BENCHMARK_quill_compile_time)
-target_link_libraries(BENCHMARK_quill_compile_time qwrapper_compile_time_bench)
diff --git a/subprojects/quill-4.2.0/benchmarks/compile_time/compile_time_bench.cpp b/subprojects/quill-4.2.0/benchmarks/compile_time/compile_time_bench.cpp
deleted file mode 100644
index 6363df0..0000000
--- a/subprojects/quill-4.2.0/benchmarks/compile_time/compile_time_bench.cpp
+++ /dev/null
@@ -1,3365 +0,0 @@
-#include "qwrapper/qwrapper.h"
-
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-
-int main()
-{
-  setup_quill("recommended_usage.log");
-  auto logger = quill::Frontend::get_logger("root");
-
-  LOG_INFO(logger, "example lazy brown {} {} {}", "example2", 4.0f, "example3");
-  LOG_INFO(logger, "jumps brown example lazy {} {} {} {} {}", std::string("str1"),
-           static_cast<short>(9), 6LL, "example1", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown test jumps fox {} {} {} {} {} {} {} {} {}", false, std::string("str1"),
-           3.0, "example3", 6LL, "example2", static_cast<unsigned short>(10), 1, true);
-  LOG_INFO(logger, "dog test example lazy {} {} {} {} {} {} {} {} {} {}", std::string_view("view1"), 7UL,
-           static_cast<short>(9), false, 6LL, 5L, true, "example3", "example2", std::string("str1"));
-  LOG_INFO(logger, "example fox lazy {} {} {} {} {} {} {} {} {} {}", "example1", 4.0f, 7UL, 5L,
-           true, 2, 3.0, 6LL, false, "example3");
-  LOG_INFO(logger, "quick test over fox {} {} {} {}", true, static_cast<short>(9), "example3", 6LL);
-  LOG_INFO(logger, "lazy logging test {} {} {} {} {}", 8ULL, 4.0f, std::string_view("view2"),
-           "example1", "example3");
-  LOG_INFO(logger, "lazy over fox {} {}", std::string_view("view1"), 8ULL);
-  LOG_INFO(logger, "lazy fox brown {} {} {}", 5L, static_cast<short>(9), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "logging brown over dog {} {} {} {} {} {} {} {}", std::string_view("view1"),
-           "example2", std::string("str2"), std::string("str1"), 8ULL, std::string_view("view2"), false, 2);
-  LOG_INFO(logger, "brown fox test example {} {} {} {}", static_cast<unsigned short>(10), 6LL,
-           static_cast<short>(9), 7UL);
-  LOG_INFO(logger, "fox logging brown {} {} {} {} {} {} {} {}", 2, std::string("str2"),
-           static_cast<short>(9), "example2", false, 7UL, "example3", 4.0f);
-  LOG_INFO(logger, "over quick logging lazy {} {} {} {}", std::string("str2"), "example3", 7UL, 5L);
-  LOG_INFO(logger, "dog over test jumps {} {} {} {} {}", 1, std::string_view("view2"), 8ULL,
-           "example3", 4.0f);
-  LOG_INFO(logger, "fox example dog {}", 5L);
-  LOG_INFO(logger, "example test fox dog {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10), 6LL,
-           3.0, static_cast<short>(9), 2, false, std::string_view("view2"), std::string_view("view1"));
-  LOG_INFO(logger, "test lazy jumps fox {} {} {} {} {} {}", 4.0f, std::string_view("view1"),
-           static_cast<unsigned short>(10), std::string("str2"), 3.0, true);
-  LOG_INFO(logger, "over jumps brown {}", 4.0f);
-  LOG_INFO(logger, "dog brown over {} {} {} {} {} {} {} {}", "example1",
-           static_cast<unsigned short>(10), false, 1, 6LL, std::string_view("view1"), 2, 8ULL);
-  LOG_INFO(logger, "over test jumps {} {} {} {} {} {} {} {}", true, std::string("str1"), 6LL,
-           "example3", 1, 7UL, 2, "example1");
-  LOG_INFO(logger, "over dog example fox {} {} {} {} {} {} {} {} {} {}", 8ULL, 2, 5L, std::string("str1"),
-           std::string_view("view1"), std::string_view("view2"), 1, "example1", 7UL, std::string("str2"));
-  LOG_INFO(logger, "logging lazy fox {} {} {} {} {} {} {} {} {} {}", 8ULL, std::string("str2"), 7UL,
-           false, std::string("str1"), "example3", 3.0, std::string_view("view1"), "example1", 6LL);
-  LOG_INFO(logger, "logging example quick dog {} {} {} {} {} {} {} {} {}", 6LL, 1, 5L, 3.0,
-           "example3", 4.0f, 8ULL, std::string("str1"), false);
-  LOG_INFO(logger, "example jumps over {} {} {} {} {} {}", 6LL, static_cast<short>(9),
-           static_cast<unsigned short>(10), "example3", true, 7UL);
-  LOG_INFO(logger, "dog fox brown quick {} {} {}", 1, 5L, 6LL);
-  LOG_INFO(logger, "brown example dog {} {} {} {}", std::string("str2"), 6LL, true, std::string_view("view1"));
-  LOG_INFO(logger, "jumps example fox test {} {}", 6LL, std::string("str1"));
-  LOG_INFO(logger, "brown over dog fox {} {} {} {} {} {} {}", std::string("str1"),
-           std::string("str2"), 4.0f, false, 8ULL, "example2", true);
-  LOG_INFO(logger, "example over fox dog {} {} {} {} {} {} {} {} {} {}", "example1", 1,
-           static_cast<short>(9), static_cast<unsigned short>(10), "example2", std::string("str1"),
-           false, std::string_view("view1"), 4.0f, 7UL);
-  LOG_INFO(logger, "brown example test quick {} {} {} {} {} {}", std::string("str2"), 3.0,
-           static_cast<short>(9), "example2", std::string("str1"), 8ULL);
-  LOG_INFO(logger, "fox brown jumps {} {} {} {} {} {} {} {} {} {}", "example3", std::string("str2"),
-           "example2", 7UL, false, 6LL, 5L, 4.0f, 2, std::string("str1"));
-  LOG_INFO(logger, "brown quick dog over {} {} {} {} {} {} {} {}", 1, 4.0f, std::string_view("view1"),
-           false, true, "example2", static_cast<unsigned short>(10), std::string("str2"));
-  LOG_INFO(logger, "lazy jumps brown {} {} {}", 8ULL, 5L, "example1");
-  LOG_INFO(logger, "example dog over {} {} {} {} {} {}", static_cast<short>(9), "example2", 3.0,
-           std::string("str1"), 5L, std::string_view("view2"));
-  LOG_INFO(logger, "fox example dog {} {} {} {} {} {}", true, "example2", 3.0, 5L, 6LL, 1);
-  LOG_INFO(logger, "example lazy dog {} {} {} {} {} {} {}", 6LL, std::string("str2"), 4.0f,
-           "example2", std::string("str1"), static_cast<unsigned short>(10), 8ULL);
-  LOG_INFO(logger, "fox logging brown {} {} {} {} {} {}", 2, true, "example1", 6LL,
-           std::string_view("view1"), 7UL);
-  LOG_INFO(logger, "example brown over test {} {}", 5L, std::string_view("view1"));
-  LOG_INFO(logger, "over test dog {} {} {} {} {}", std::string("str1"), std::string_view("view1"),
-           "example2", "example1", 6LL);
-  LOG_INFO(logger, "logging test example {} {} {} {} {} {} {} {} {} {}", 6LL, "example3",
-           static_cast<short>(9), true, 7UL, 5L, std::string_view("view2"), 2, 1, std::string_view("view1"));
-  LOG_INFO(logger, "example test lazy quick {} {} {} {} {} {} {} {}", std::string("str1"), 6LL, 7UL,
-           std::string_view("view2"), static_cast<short>(9), 5L, std::string("str2"), "example1");
-  LOG_INFO(logger, "over lazy logging {} {} {} {} {}", "example3", std::string_view("view1"), 6LL,
-           false, "example2");
-  LOG_INFO(logger, "lazy example jumps over {} {} {} {} {} {} {} {}", 3.0, "example3", 2,
-           "example2", 4.0f, 6LL, true, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox brown example {}", 5L);
-  LOG_INFO(logger, "jumps lazy test over {} {}", false, std::string_view("view2"));
-  LOG_INFO(logger, "lazy over quick {} {} {} {} {} {} {}", true, 7UL, std::string("str1"),
-           "example1", 5L, 4.0f, static_cast<short>(9));
-  LOG_INFO(logger, "fox brown over jumps {} {} {} {} {} {} {}", 1, 3.0, true, std::string("str2"),
-           4.0f, 6LL, "example3");
-  LOG_INFO(logger, "example logging test quick {} {} {} {} {} {} {}", 1, "example2",
-           static_cast<short>(9), 6LL, static_cast<unsigned short>(10), 5L, std::string_view("view1"));
-  LOG_INFO(logger, "brown logging quick test {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           5L, true, 8ULL, "example1", 2, 3.0, "example3", std::string("str2"));
-  LOG_INFO(logger, "logging dog over fox {} {} {}", false, std::string_view("view2"), 7UL);
-  LOG_INFO(logger, "quick fox test {} {} {} {} {} {} {} {}", std::string("str2"), 4.0f, 8ULL,
-           "example3", 5L, false, 7UL, std::string_view("view1"));
-  LOG_INFO(logger, "over logging lazy {} {} {} {} {} {} {} {}", 7UL, "example1", 3.0, "example2",
-           std::string_view("view2"), static_cast<short>(9), std::string_view("view1"), 1);
-  LOG_INFO(logger, "brown dog example fox {} {} {} {} {} {} {} {} {}", std::string("str2"),
-           std::string_view("view1"), 1, 4.0f, 2, "example1", "example2", 7UL, 5L);
-  LOG_INFO(logger, "jumps brown dog test {} {} {} {} {} {} {} {} {}", "example2",
-           std::string("str2"), 7UL, 2, static_cast<short>(9), false, 6LL, 5L, 3.0);
-  LOG_INFO(logger, "quick lazy logging {} {} {}", 4.0f, "example1", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "jumps test quick fox {} {} {} {} {} {} {} {}", false, 4.0f, 1,
-           static_cast<short>(9), "example1", 2, 6LL, "example3");
-  LOG_INFO(logger, "over example dog {} {} {} {} {}", 6LL, 5L, "example1", 1, 4.0f);
-  LOG_INFO(logger, "brown fox logging {} {} {} {}", 5L, 3.0, 7UL, static_cast<short>(9));
-  LOG_INFO(logger, "over example brown {} {} {} {} {} {} {} {} {}", 2, std::string("str1"), 7UL,
-           true, false, 1, 5L, std::string("str2"), "example3");
-  LOG_INFO(logger, "lazy test over jumps {} {} {} {} {} {} {} {} {} {}", false, "example3",
-           std::string_view("view2"), static_cast<short>(9), 2, 4.0f, std::string("str2"),
-           std::string_view("view1"), std::string("str1"), "example2");
-  LOG_INFO(logger, "test quick brown {} {}", std::string_view("view2"), std::string("str2"));
-  LOG_INFO(logger, "dog example over lazy {} {} {}", "example3", static_cast<unsigned short>(10), true);
-  LOG_INFO(logger, "over test brown lazy {} {}", 3.0, 4.0f);
-  LOG_INFO(logger, "lazy jumps example {} {} {} {} {} {} {}", std::string_view("view1"), false, 6LL,
-           "example2", true, "example1", static_cast<short>(9));
-  LOG_INFO(logger, "fox example jumps over {} {} {} {} {} {} {} {} {}", 4.0f, 7UL, "example2", 8ULL,
-           std::string("str2"), 6LL, false, "example3", static_cast<short>(9));
-  LOG_INFO(logger, "dog example lazy jumps {} {} {} {} {} {} {} {}", 3.0, std::string_view("view2"),
-           2, 6LL, std::string_view("view1"), std::string("str1"), 4.0f, std::string("str2"));
-  LOG_INFO(logger, "quick lazy test dog {} {}", "example1", std::string("str1"));
-  LOG_INFO(logger, "fox example quick dog {} {} {} {} {} {} {} {}", 2, 6LL,
-           static_cast<unsigned short>(10), 7UL, std::string_view("view1"), 1, "example2", false);
-  LOG_INFO(logger, "jumps test quick fox {} {} {} {} {} {} {} {} {}", 8ULL, 2, std::string_view("view2"),
-           false, 6LL, 3.0, static_cast<short>(9), "example1", "example2");
-  LOG_INFO(logger, "dog jumps quick lazy {} {} {}", 2, 4.0f, "example2");
-  LOG_INFO(logger, "dog over brown logging {} {} {} {}", std::string("str1"), 1, "example2", false);
-  LOG_INFO(logger, "dog lazy over example {} {} {} {}", 2, std::string("str2"), std::string("str1"),
-           "example1");
-  LOG_INFO(logger, "logging jumps brown fox {} {} {} {} {} {} {} {} {} {}", std::string("str2"),
-           std::string_view("view2"), 7UL, std::string("str1"), 3.0, true, false, 6LL, 2,
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "example over jumps brown {} {} {} {} {}", std::string_view("view2"),
-           std::string("str2"), 3.0, 2, 4.0f);
-  LOG_INFO(logger, "example dog jumps lazy {} {} {} {} {} {}", 8ULL, "example3", "example2", 6LL, true, false);
-  LOG_INFO(logger, "example dog fox {} {} {} {} {} {} {} {} {}", "example2", 1, 3.0,
-           std::string("str1"), "example1", 8ULL, std::string_view("view2"), false, 2);
-  LOG_INFO(logger, "example fox over {} {} {} {} {} {} {}", 7UL, 6LL,
-           static_cast<unsigned short>(10), true, 4.0f, "example2", 5L);
-  LOG_INFO(logger, "lazy example jumps logging {} {} {} {} {} {} {}", false, "example3", 4.0f,
-           "example1", 8ULL, 3.0, std::string_view("view2"));
-  LOG_INFO(logger, "test dog lazy {} {} {}", std::string_view("view2"), 3.0, 5L);
-  LOG_INFO(logger, "jumps example over logging {} {} {}", 7UL, 4.0f, static_cast<short>(9));
-  LOG_INFO(logger, "dog example jumps quick {} {} {} {}", 2, 5L, 1, static_cast<short>(9));
-  LOG_INFO(logger, "test quick fox over {} {} {} {} {}", "example3", 1, 7UL, "example2",
-           std::string_view("view1"));
-  LOG_INFO(logger, "brown jumps over {} {} {} {} {} {} {} {} {}", "example2", false, std::string_view("view1"),
-           std::string("str2"), true, "example3", 3.0, 5L, static_cast<short>(9));
-  LOG_INFO(logger, "dog over fox {} {} {} {}", std::string("str2"), std::string("str1"), 1,
-           "example2");
-  LOG_INFO(logger, "brown lazy dog over {} {} {} {} {}", std::string_view("view2"), 3.0, 4.0f, true,
-           std::string_view("view1"));
-  LOG_INFO(logger, "jumps lazy example {} {} {} {} {} {} {} {} {}", static_cast<short>(9),
-           "example3", std::string_view("view2"), std::string("str1"), true, 7UL,
-           static_cast<unsigned short>(10), 6LL, 5L);
-  LOG_INFO(logger, "dog quick jumps {} {} {} {} {} {} {} {} {} {}", "example3", 5L, true,
-           std::string("str1"), 8ULL, "example2", std::string_view("view1"), 1, 7UL, "example1");
-  LOG_INFO(logger, "jumps quick example {} {} {} {} {} {} {}", 7UL, 5L, 2, static_cast<short>(9),
-           std::string_view("view2"), 6LL, std::string("str1"));
-  LOG_INFO(logger, "quick logging brown {} {} {} {} {} {} {}", 3.0, "example1",
-           static_cast<unsigned short>(10), 6LL, static_cast<short>(9), 2, "example2");
-  LOG_INFO(logger, "example test dog quick {}", static_cast<short>(9));
-  LOG_INFO(logger, "lazy jumps dog {}", 7UL);
-  LOG_INFO(logger, "example fox quick {} {} {} {} {} {} {}", std::string_view("view2"), 7UL, 2,
-           8ULL, std::string("str1"), 6LL, 4.0f);
-  LOG_INFO(logger, "brown over dog test {} {}", 7UL, "example3");
-  LOG_INFO(logger, "logging dog fox test {} {} {} {} {} {}", 4.0f, static_cast<short>(9), true,
-           std::string_view("view2"), static_cast<unsigned short>(10), std::string("str1"));
-  LOG_INFO(logger, "quick dog test {} {} {} {} {} {} {}", 6LL, 8ULL, "example2",
-           std::string("str1"), "example1", true, false);
-  LOG_INFO(logger, "jumps dog logging over {} {} {} {}", "example1", static_cast<unsigned short>(10), 4.0f, false);
-  LOG_INFO(logger, "lazy dog example {} {} {} {} {} {} {} {} {}", true, 1, 2, 5L,
-           static_cast<unsigned short>(10), "example1", 3.0, 8ULL, "example3");
-  LOG_INFO(logger, "fox dog lazy jumps {} {} {}", std::string_view("view1"), 3.0, 8ULL);
-  LOG_INFO(logger, "lazy logging test quick {} {} {}", 5L, std::string_view("view2"), std::string("str1"));
-  LOG_INFO(logger, "jumps logging quick {}", false);
-  LOG_INFO(logger, "quick logging over {} {} {} {} {} {} {} {}", 5L, std::string_view("view1"), 1,
-           std::string_view("view2"), true, "example3", static_cast<unsigned short>(10), false);
-  LOG_INFO(logger, "fox lazy test {} {} {} {} {} {} {}", std::string("str2"), "example3", 6LL, 1,
-           true, false, 4.0f);
-  LOG_INFO(logger, "fox over quick dog {} {} {} {}", "example2", true,
-           static_cast<unsigned short>(10), std::string("str1"));
-  LOG_INFO(logger, "brown fox dog logging {} {} {} {} {} {} {} {}", 3.0, static_cast<unsigned short>(10),
-           std::string_view("view1"), 7UL, 4.0f, false, 1, "example1");
-  LOG_INFO(logger, "fox logging quick lazy {} {} {} {} {} {} {}", 5L, true, "example1", 6LL,
-           std::string_view("view2"), "example2", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "quick dog jumps example {} {} {} {}", 6LL, std::string_view("view1"),
-           static_cast<unsigned short>(10), std::string("str1"));
-  LOG_INFO(logger, "quick brown fox {} {} {} {} {} {} {} {} {} {}", std::string("str1"), 2,
-           std::string_view("view1"), 4.0f, false, "example1", 5L, static_cast<unsigned short>(10),
-           static_cast<short>(9), std::string("str2"));
-  LOG_INFO(logger, "dog quick brown {} {} {} {} {} {} {} {}", true, static_cast<short>(9), 8ULL,
-           std::string("str2"), static_cast<unsigned short>(10), 6LL, "example2", 2);
-  LOG_INFO(logger, "jumps dog logging over {} {} {} {} {} {} {} {}", 8ULL, true,
-           std::string("str2"), "example2", 4.0f, 5L, 6LL, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "dog lazy example {}", static_cast<short>(9));
-  LOG_INFO(logger, "brown logging lazy {} {} {} {} {} {}", std::string_view("view2"), 5L, 2,
-           static_cast<unsigned short>(10), true, "example1");
-  LOG_INFO(logger, "jumps over brown {} {} {} {} {} {}", false, true, static_cast<short>(9), 2,
-           std::string("str2"), "example3");
-  LOG_INFO(logger, "lazy example quick {} {} {} {} {}", true, 3.0, 7UL, 4.0f, std::string_view("view1"));
-  LOG_INFO(logger, "logging dog over {} {} {} {} {} {}", std::string_view("view1"), 7UL, "example3",
-           true, static_cast<unsigned short>(10), 5L);
-  LOG_INFO(logger, "jumps quick logging {} {}", 2, 7UL);
-  LOG_INFO(logger, "test lazy brown jumps {} {} {} {} {} {} {} {}", "example1", std::string("str1"),
-           4.0f, 3.0, static_cast<unsigned short>(10), std::string_view("view1"), 6LL, 7UL);
-  LOG_INFO(logger, "jumps example lazy test {} {}", 1, true);
-  LOG_INFO(logger, "jumps over dog {} {} {} {} {} {} {}", "example3", std::string_view("view1"),
-           static_cast<short>(9), static_cast<unsigned short>(10), std::string_view("view2"), true, 1);
-  LOG_INFO(logger, "logging dog example {} {} {} {}", false, 5L, std::string("str2"),
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "logging quick brown {} {} {} {} {} {} {} {} {} {}", 8ULL, "example3",
-           std::string("str1"), "example1", "example2", 1, 3.0, 4.0f, 7UL, std::string_view("view2"));
-  LOG_INFO(logger, "logging over test {} {} {} {} {} {} {} {} {}", 2, std::string_view("view2"),
-           "example1", 6LL, true, 7UL, static_cast<short>(9), static_cast<unsigned short>(10), 3.0);
-  LOG_INFO(logger, "over example fox dog {} {}", std::string_view("view1"), 1);
-  LOG_INFO(logger, "quick logging lazy dog {} {}", "example2", std::string("str2"));
-  LOG_INFO(logger, "lazy over quick example {} {} {} {} {} {} {}", std::string("str2"), false, 4.0f,
-           std::string_view("view2"), 3.0, 6LL, std::string("str1"));
-  LOG_INFO(logger, "test dog brown {} {} {} {} {} {} {} {} {}", std::string("str1"), "example2",
-           4.0f, 3.0, 8ULL, static_cast<unsigned short>(10), false, 7UL, 5L);
-  LOG_INFO(logger, "brown quick logging jumps {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           "example2", true, false, 2, std::string_view("view1"));
-  LOG_INFO(logger, "quick over example {} {} {} {} {} {} {}", 5L, 1, 4.0f,
-           std::string_view("view2"), std::string("str2"), "example1", 3.0);
-  LOG_INFO(logger, "fox quick over test {} {}", std::string_view("view1"), 3.0);
-  LOG_INFO(logger, "dog lazy fox jumps {} {} {} {} {} {} {} {} {} {}", "example3", 1, 7UL,
-           static_cast<unsigned short>(10), std::string("str2"), "example2", "example1",
-           static_cast<short>(9), 6LL, 4.0f);
-  LOG_INFO(logger, "dog fox jumps example {} {} {} {} {} {} {} {}", static_cast<short>(9),
-           "example3", 5L, 7UL, 2, std::string_view("view2"), false, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "dog quick example lazy {} {} {} {} {} {} {} {}", 8ULL, 2, "example3", 4.0f,
-           std::string_view("view2"), static_cast<short>(9), static_cast<unsigned short>(10), 6LL);
-  LOG_INFO(logger, "over example brown {}", 6LL);
-  LOG_INFO(logger, "logging test jumps quick {} {} {} {} {}", true, std::string("str2"), 2,
-           std::string_view("view1"), 7UL);
-  LOG_INFO(logger, "brown fox over {} {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           std::string_view("view2"), false, std::string("str1"), "example1", 7UL,
-           std::string("str2"), true, 6LL, 1);
-  LOG_INFO(logger, "logging test dog fox {}", 3.0);
-  LOG_INFO(logger, "over brown dog {} {} {} {} {} {} {}", "example1", "example2", 6LL,
-           std::string("str1"), 7UL, std::string_view("view1"), false);
-  LOG_INFO(logger, "fox over lazy {} {} {} {} {} {} {} {} {} {}", static_cast<short>(9), 8ULL, 5L, 6LL,
-           std::string_view("view2"), std::string_view("view1"), 1, std::string("str1"), "example2", 3.0);
-  LOG_INFO(logger, "lazy quick fox {} {} {} {}", std::string("str2"), "example3", 1, std::string_view("view2"));
-  LOG_INFO(logger, "brown fox logging lazy {} {} {} {} {}", std::string_view("view2"),
-           std::string("str1"), 5L, std::string_view("view1"), "example3");
-  LOG_INFO(logger, "brown over fox {} {} {}", 2, 6LL, 4.0f);
-  LOG_INFO(logger, "logging fox jumps over {} {} {} {} {} {} {} {}", 7UL, 4.0f, "example1", 8ULL,
-           "example2", 5L, false, std::string("str2"));
-  LOG_INFO(logger, "over test logging jumps {} {} {} {} {} {}", true, 4.0f, "example1", 7UL,
-           std::string_view("view1"), "example3");
-  LOG_INFO(logger, "example quick test {} {} {} {} {} {} {} {}", std::string("str1"), 7UL, 6LL, 3.0,
-           2, 8ULL, 1, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "example brown quick test {} {} {} {} {} {} {} {}", 2, false, 6LL, 4.0f,
-           std::string_view("view1"), 8ULL, "example3", "example2");
-  LOG_INFO(logger, "brown example quick test {} {}", std::string("str1"), 8ULL);
-  LOG_INFO(logger, "logging example brown {} {} {} {} {}", std::string("str1"), 5L, 4.0f,
-           static_cast<short>(9), "example1");
-  LOG_INFO(logger, "quick logging lazy {} {}", static_cast<short>(9), "example3");
-  LOG_INFO(logger, "dog jumps over fox {} {} {} {} {} {} {}", 3.0, static_cast<short>(9), 6LL,
-           false, 7UL, std::string_view("view1"), true);
-  LOG_INFO(logger, "brown dog example {} {} {} {} {} {} {} {} {}", "example1", std::string("str2"), true,
-           static_cast<unsigned short>(10), 7UL, 8ULL, 1, std::string("str1"), std::string_view("view1"));
-  LOG_INFO(logger, "example test quick logging {} {} {} {} {} {} {} {} {}", 6LL, "example1",
-           "example3", 1, false, static_cast<unsigned short>(10), 2, std::string("str2"), std::string("str1"));
-  LOG_INFO(logger, "quick lazy jumps example {} {} {} {} {} {} {} {}", "example2", 6LL, 4.0f, 7UL,
-           2, 5L, std::string_view("view2"), static_cast<short>(9));
-  LOG_INFO(logger, "dog test logging quick {} {}", false, "example2");
-  LOG_INFO(logger, "example dog over lazy {} {} {} {} {} {} {} {} {} {}", 6LL, 2, 3.0,
-           std::string_view("view2"), "example3", 4.0f, 8ULL, true, std::string("str2"), std::string("str1"));
-  LOG_INFO(logger, "test example logging {} {} {} {}", 1, std::string("str1"), 6LL, false);
-  LOG_INFO(logger, "logging over jumps lazy {} {} {} {} {} {} {} {} {}", true, 7UL, "example2",
-           static_cast<short>(9), "example3", std::string_view("view2"), 5L,
-           std::string_view("view1"), std::string("str2"));
-  LOG_INFO(logger, "fox logging brown {} {} {} {} {} {} {} {} {} {}", std::string_view("view1"), 2,
-           false, static_cast<short>(9), 3.0, "example2", std::string_view("view2"),
-           static_cast<unsigned short>(10), true, "example1");
-  LOG_INFO(logger, "over jumps logging {} {} {}", 5L, std::string("str2"), true);
-  LOG_INFO(logger, "lazy fox example brown {}", std::string_view("view1"));
-  LOG_INFO(logger, "test over quick {} {}", 8ULL, 5L);
-  LOG_INFO(logger, "example jumps quick fox {}", 6LL);
-  LOG_INFO(logger, "fox dog example quick {} {} {} {} {} {} {} {} {} {}", 5L, 7UL, "example2", 8ULL,
-           3.0, static_cast<short>(9), 6LL, true, static_cast<unsigned short>(10), "example1");
-  LOG_INFO(logger, "over test example dog {} {} {} {} {} {} {} {}", 2, 8ULL, 4.0f, "example1",
-           static_cast<short>(9), std::string("str2"), 5L, std::string_view("view1"));
-  LOG_INFO(logger, "over dog test {} {}", 7UL, 2);
-  LOG_INFO(logger, "brown fox logging {}", 7UL);
-  LOG_INFO(logger, "fox jumps logging dog {} {} {} {} {} {} {} {}", 3.0, "example1", "example3",
-           std::string_view("view2"), false, 4.0f, 5L, true);
-  LOG_INFO(logger, "brown example logging {}", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown jumps logging over {} {} {} {} {} {}", 6LL, 1, 8ULL, "example2",
-           std::string_view("view2"), "example3");
-  LOG_INFO(logger, "logging fox brown {} {} {} {} {}", 2, 8ULL, static_cast<short>(9), 6LL, 3.0);
-  LOG_INFO(logger, "lazy dog jumps fox {} {} {} {} {} {} {}", std::string_view("view2"),
-           std::string("str2"), std::string_view("view1"), "example1", 1, false, 4.0f);
-  LOG_INFO(logger, "brown quick dog {}", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown dog lazy {} {} {} {} {}", static_cast<unsigned short>(10), 3.0,
-           std::string_view("view2"), static_cast<short>(9), 2);
-  LOG_INFO(logger, "lazy fox quick {} {} {}", 5L, "example1", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox over quick {} {} {} {} {} {}", 4.0f, 6LL, std::string_view("view1"),
-           "example2", 1, std::string_view("view2"));
-  LOG_INFO(logger, "fox brown dog {} {} {} {} {} {} {}", false, 3.0, 4.0f,
-           std::string_view("view2"), 1, 6LL, 5L);
-  LOG_INFO(logger, "test brown jumps {} {} {} {} {}", true, 4.0f, static_cast<unsigned short>(10),
-           "example1", std::string("str1"));
-  LOG_INFO(logger, "example fox test dog {} {}", std::string_view("view2"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown example quick {} {} {} {} {} {} {} {} {} {}", 2, 6LL, "example3",
-           static_cast<short>(9), std::string_view("view1"), false, 4.0f, std::string("str1"), 7UL, 1);
-  LOG_INFO(logger, "example lazy over {} {} {} {} {} {}", static_cast<short>(9), 5L, "example3",
-           std::string("str1"), 7UL, std::string("str2"));
-  LOG_INFO(logger, "quick logging fox {} {} {} {} {} {}", 5L, true, false, 2, std::string_view("view1"), 4.0f);
-  LOG_INFO(logger, "logging lazy dog {} {} {} {} {} {}", std::string_view("view1"), 4.0f,
-           "example1", "example3", false, std::string("str2"));
-  LOG_INFO(logger, "fox dog over test {} {} {} {} {} {} {} {} {}", std::string("str2"), 5L, 3.0,
-           "example3", static_cast<short>(9), true, 6LL, 8ULL, 1);
-  LOG_INFO(logger, "dog lazy jumps {}", static_cast<short>(9));
-  LOG_INFO(logger, "test example dog {} {} {} {} {} {} {} {} {} {}",
-           static_cast<unsigned short>(10), std::string("str2"), 7UL, std::string("str1"), true,
-           static_cast<short>(9), std::string_view("view2"), false, 1, 8ULL);
-  LOG_INFO(logger, "fox jumps dog test {} {} {} {} {}", 1, 8ULL, std::string("str1"), "example2",
-           std::string_view("view2"));
-  LOG_INFO(logger, "example brown fox quick {} {}", static_cast<short>(9), false);
-  LOG_INFO(logger, "over quick dog {} {} {} {} {}", 5L, 1, 8ULL, 7UL, 3.0);
-  LOG_INFO(logger, "brown test over quick {} {} {} {} {} {} {} {} {} {}", std::string_view("view1"),
-           3.0, 4.0f, 2, false, "example3", 7UL, static_cast<short>(9), true, 5L);
-  LOG_INFO(logger, "brown lazy over {} {} {} {} {} {}", std::string("str2"), 7UL,
-           static_cast<short>(9), true, 8ULL, 2);
-  LOG_INFO(logger, "brown lazy fox {} {} {} {} {} {} {} {}", 7UL, 4.0f, static_cast<short>(9), 1,
-           6LL, false, "example2", std::string_view("view1"));
-  LOG_INFO(logger, "fox logging jumps quick {} {}", 6LL, 5L);
-  LOG_INFO(logger, "quick fox brown {} {} {} {} {}", std::string_view("view1"),
-           std::string_view("view2"), "example1", 2, "example2");
-  LOG_INFO(logger, "example quick over brown {} {} {}", 8ULL, static_cast<unsigned short>(10),
-           std::string_view("view1"));
-  LOG_INFO(logger, "quick over lazy {} {} {} {} {} {}", 7UL, 2, static_cast<unsigned short>(10), 1, 3.0, 8ULL);
-  LOG_INFO(logger, "logging fox test brown {} {} {} {} {}", false, 8ULL, 1, 5L, std::string_view("view2"));
-  LOG_INFO(logger, "fox over dog test {}", std::string_view("view2"));
-  LOG_INFO(logger, "brown jumps logging {} {} {} {} {}", 4.0f, 8ULL, true,
-           std::string_view("view1"), static_cast<short>(9));
-  LOG_INFO(logger, "quick over brown jumps {} {} {} {} {} {}", "example2", "example3", 7UL, false, 8ULL, 5L);
-  LOG_INFO(logger, "test dog example over {} {} {} {} {} {}", 2, 1, static_cast<short>(9),
-           "example3", std::string_view("view2"), std::string_view("view1"));
-  LOG_INFO(logger, "fox logging lazy over {} {} {} {}", "example2", std::string("str1"), 5L, 3.0);
-  LOG_INFO(logger, "logging fox test {} {} {} {}", false, static_cast<short>(9),
-           static_cast<unsigned short>(10), "example3");
-  LOG_INFO(logger, "brown logging dog example {} {} {} {} {} {} {} {} {}", "example2",
-           std::string_view("view1"), std::string("str1"), "example3", std::string_view("view2"),
-           "example1", false, static_cast<unsigned short>(10), 5L);
-  LOG_INFO(logger, "dog test example over {}", "example1");
-  LOG_INFO(logger, "over jumps logging test {} {} {} {}", true, 4.0f, std::string("str2"), false);
-  LOG_INFO(logger, "brown example test logging {} {} {} {} {} {}", 3.0, 6LL, std::string("str2"),
-           static_cast<unsigned short>(10), "example2", std::string_view("view1"));
-  LOG_INFO(logger, "example over dog quick {} {} {} {} {}", 1, 2, false, "example1", "example3");
-  LOG_INFO(logger, "test dog example {} {} {} {} {} {} {} {} {} {}", true, "example2", "example3",
-           std::string("str2"), 1, static_cast<unsigned short>(10), std::string_view("view1"),
-           "example1", 7UL, false);
-  LOG_INFO(logger, "dog example lazy test {} {} {} {}", "example2", std::string_view("view2"), 5L, 7UL);
-  LOG_INFO(logger, "logging over dog {}", std::string("str1"));
-  LOG_INFO(logger, "logging jumps test example {} {} {} {} {} {} {}", "example2", 8ULL,
-           std::string_view("view1"), "example1", static_cast<unsigned short>(10), 5L, "example3");
-  LOG_INFO(logger, "quick dog example {} {} {} {} {} {} {} {} {} {}", std::string("str1"),
-           std::string_view("view2"), true, 8ULL, std::string_view("view1"), 7UL,
-           static_cast<short>(9), 3.0, static_cast<unsigned short>(10), std::string("str2"));
-  LOG_INFO(logger, "brown quick over {} {}", 7UL, 2);
-  LOG_INFO(logger, "over lazy fox test {} {}", 8ULL, std::string("str2"));
-  LOG_INFO(logger, "example test brown jumps {} {}", std::string("str2"), 4.0f);
-  LOG_INFO(logger, "quick example lazy {} {} {} {} {} {} {} {} {} {}", std::string_view("view2"), false,
-           2, static_cast<short>(9), 3.0, "example3", std::string_view("view1"), "example1", true, 1);
-  LOG_INFO(logger, "dog fox test {} {} {} {} {} {} {}", 3.0, false, static_cast<short>(9),
-           static_cast<unsigned short>(10), 6LL, 1, "example3");
-  LOG_INFO(logger, "test quick fox logging {} {} {} {}", true, 1, 7UL, 2);
-  LOG_INFO(logger, "brown example dog {} {} {} {} {}", std::string("str1"), 5L, "example1",
-           std::string("str2"), "example2");
-  LOG_INFO(logger, "logging test dog {} {} {} {} {} {} {}", 5L, static_cast<short>(9), 8ULL, false,
-           4.0f, 6LL, std::string("str2"));
-  LOG_INFO(logger, "jumps brown quick {} {} {} {} {}", "example3", "example2", std::string("str2"), 4.0f, 5L);
-  LOG_INFO(logger, "test over dog {} {} {} {} {} {} {} {} {} {}", 6LL, 2, "example3",
-           std::string_view("view1"), static_cast<short>(9), 1, 5L, "example1", 4.0f, "example2");
-  LOG_INFO(logger, "jumps test quick {} {} {} {} {} {} {}", false, "example2", 8ULL, std::string_view("view1"),
-           static_cast<unsigned short>(10), static_cast<short>(9), std::string("str1"));
-  LOG_INFO(logger, "test logging fox {} {} {} {} {} {} {} {} {}", static_cast<short>(9), "example3",
-           std::string_view("view1"), true, std::string("str2"), 7UL,
-           static_cast<unsigned short>(10), std::string("str1"), 8ULL);
-  LOG_INFO(logger, "lazy dog over {} {} {} {} {} {} {} {} {}", 4.0f, 1, "example3",
-           std::string("str2"), true, 3.0, 5L, "example2", std::string_view("view2"));
-  LOG_INFO(logger, "test lazy dog {} {} {} {}", true, std::string_view("view2"), 6LL, "example1");
-  LOG_INFO(logger, "jumps over logging example {} {} {} {} {}", std::string_view("view1"),
-           "example2", static_cast<unsigned short>(10), std::string("str2"), 3.0);
-  LOG_INFO(logger, "example over jumps {} {}", std::string("str1"), "example3");
-  LOG_INFO(logger, "quick brown test {} {} {} {} {} {} {} {} {} {}", std::string_view("view1"),
-           std::string("str1"), 6LL, 8ULL, "example1", std::string_view("view2"), "example3", 2, 7UL, 5L);
-  LOG_INFO(logger, "dog lazy quick over {} {} {} {} {} {} {} {}", 5L, 8ULL, true, false,
-           std::string("str1"), std::string_view("view2"), "example1", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "jumps test dog {} {} {}", "example1", 4.0f, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "example test lazy {} {} {} {} {} {} {} {} {}", "example1", true, std::string_view("view2"),
-           std::string("str1"), 7UL, 6LL, 8ULL, static_cast<unsigned short>(10), "example2");
-  LOG_INFO(logger, "fox brown quick over {} {} {} {}", 6LL, std::string_view("view1"), "example3", 4.0f);
-  LOG_INFO(logger, "dog jumps test brown {}", true);
-  LOG_INFO(logger, "quick dog test {} {} {} {}", static_cast<short>(9), 3.0, 2,
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "lazy over brown {} {} {} {} {} {} {} {} {} {}", std::string("str2"), 8ULL, 6LL,
-           7UL, 4.0f, false, 5L, 3.0, std::string_view("view2"), "example1");
-  LOG_INFO(logger, "quick jumps fox {} {} {} {}", static_cast<short>(9), 2, 8ULL, std::string_view("view1"));
-  LOG_INFO(logger, "quick lazy test brown {} {} {} {} {}", 6LL, false, "example2", 2, 1);
-  LOG_INFO(logger, "test lazy logging dog {} {} {} {}", 2, static_cast<short>(9),
-           std::string_view("view2"), false);
-  LOG_INFO(logger, "quick lazy logging {} {} {} {} {} {} {} {} {}", std::string_view("view1"),
-           static_cast<short>(9), 2, std::string("str2"), 7UL, 3.0, std::string_view("view2"), 4.0f, 6LL);
-  LOG_INFO(logger, "over lazy fox test {} {} {} {} {} {} {} {}", "example2", static_cast<unsigned short>(10),
-           std::string("str1"), "example3", 1, 2, true, std::string_view("view2"));
-  LOG_INFO(logger, "brown logging over {} {} {} {}", 1, false, 8ULL, true);
-  LOG_INFO(logger, "dog brown jumps quick {} {} {} {} {}", std::string_view("view1"), true, 7UL,
-           std::string_view("view2"), 5L);
-  LOG_INFO(logger, "jumps dog fox logging {} {} {} {} {} {} {} {}", "example1", 6LL, 1,
-           static_cast<short>(9), 3.0, 2, std::string("str2"), 7UL);
-  LOG_INFO(logger, "logging lazy dog test {} {} {} {}", 5L, "example3", std::string_view("view1"),
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "over fox test {} {} {} {}", 4.0f, false, "example1", true);
-  LOG_INFO(logger, "quick logging jumps over {} {} {} {} {} {} {} {}", false, true,
-           std::string_view("view1"), 2, "example3", 3.0, "example2", std::string("str1"));
-  LOG_INFO(logger, "test brown fox {} {}", std::string_view("view2"), 7UL);
-  LOG_INFO(logger, "example lazy dog {} {} {} {} {} {} {} {}", "example2", 4.0f,
-           std::string("str2"), std::string("str1"), 8ULL, 7UL, std::string_view("view2"), 2);
-  LOG_INFO(logger, "example logging fox test {} {} {} {} {} {} {} {}", true, static_cast<short>(9),
-           2, 7UL, 3.0, "example2", std::string("str2"), std::string("str1"));
-  LOG_INFO(logger, "brown jumps logging test {} {} {}", 6LL, true, std::string_view("view1"));
-  LOG_INFO(logger, "fox lazy jumps {} {} {} {}", "example3", std::string("str1"), true, 3.0);
-  LOG_INFO(logger, "fox test over quick {} {} {} {} {} {} {} {}", 8ULL, 4.0f, std::string("str1"),
-           3.0, 7UL, std::string_view("view2"), "example2", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown dog over logging {} {} {} {} {} {} {}", 4.0f, 7UL, "example3",
-           std::string("str2"), 3.0, 8ULL, "example2");
-  LOG_INFO(logger, "lazy dog brown logging {} {}", 4.0f, 8ULL);
-  LOG_INFO(logger, "quick over jumps lazy {} {} {} {} {} {} {} {} {} {}", std::string("str2"),
-           "example2", 7UL, std::string("str1"), std::string_view("view2"), "example3",
-           static_cast<short>(9), 2, "example1", true);
-  LOG_INFO(logger, "jumps logging lazy over {} {} {} {} {}", true, std::string_view("view2"), 3.0,
-           "example3", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown quick example {} {} {} {}", true, "example1", std::string("str1"), 2);
-  LOG_INFO(logger, "over fox quick lazy {} {} {}", 5L, 3.0, std::string_view("view1"));
-  LOG_INFO(logger, "fox logging example {}", "example2");
-  LOG_INFO(logger, "over dog test {} {} {} {} {} {} {}", 4.0f, static_cast<unsigned short>(10), 1,
-           7UL, true, false, 6LL);
-  LOG_INFO(logger, "quick logging lazy dog {} {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           true, "example3", 5L, 8ULL, 1, static_cast<short>(9), std::string("str1"), "example2", 6LL);
-  LOG_INFO(logger, "brown jumps lazy test {} {} {} {} {} {} {}", 8ULL, "example3", 6LL,
-           std::string_view("view2"), std::string("str2"), "example2", false);
-  LOG_INFO(logger, "quick example test lazy {} {} {} {} {}", true, false, "example2", 6LL,
-           "example3");
-  LOG_INFO(logger, "brown jumps logging {} {} {} {} {} {}", static_cast<unsigned short>(10), 3.0,
-           8ULL, "example3", true, 4.0f);
-  LOG_INFO(logger, "fox jumps logging {}", "example3");
-  LOG_INFO(logger, "jumps test example {} {}", std::string("str2"), 1);
-  LOG_INFO(logger, "quick example jumps lazy {} {} {} {} {} {} {} {} {} {}", 5L, 6LL, static_cast<short>(9),
-           4.0f, "example3", "example2", 1, std::string("str2"), std::string_view("view2"), false);
-  LOG_INFO(logger, "fox quick over logging {} {} {} {} {} {} {} {} {}", 1, std::string_view("view2"),
-           8ULL, false, 3.0, std::string_view("view1"), "example1", true, 7UL);
-  LOG_INFO(logger, "brown logging test fox {} {} {} {} {} {} {} {}", std::string("str1"), 5L,
-           static_cast<short>(9), 7UL, 6LL, std::string_view("view2"), "example2", 8ULL);
-  LOG_INFO(logger, "brown example quick test {} {} {}", std::string_view("view2"), "example2",
-           std::string_view("view1"));
-  LOG_INFO(logger, "logging example test brown {} {} {} {} {} {}", std::string_view("view2"),
-           "example3", std::string("str2"), 8ULL, 3.0, std::string_view("view1"));
-  LOG_INFO(logger, "over quick fox dog {} {} {} {} {} {}", std::string("str2"), 5L, 6LL, "example3",
-           8ULL, std::string_view("view2"));
-  LOG_INFO(logger, "test example brown {} {} {} {} {} {} {} {} {} {}", "example1", 7UL, 6LL,
-           "example2", 2, std::string("str1"), 1, false, 4.0f, 5L);
-  LOG_INFO(logger, "over test logging {} {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10), 5L,
-           "example3", static_cast<short>(9), 6LL, std::string_view("view1"), 2, "example1", 3.0, 7UL);
-  LOG_INFO(logger, "logging over dog {} {}", std::string_view("view1"), 6LL);
-  LOG_INFO(logger, "jumps test example over {} {} {}", 5L, 7UL, "example1");
-  LOG_INFO(logger, "fox test over {}", 5L);
-  LOG_INFO(logger, "quick jumps over brown {} {} {} {} {} {} {} {} {}", std::string("str2"),
-           std::string_view("view2"), 1, static_cast<short>(9), std::string_view("view1"), true,
-           false, 8ULL, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "over test jumps example {} {} {} {} {} {}", std::string("str2"), 1,
-           std::string_view("view1"), "example2", std::string_view("view2"), 6LL);
-  LOG_INFO(logger, "fox brown test lazy {} {} {} {}", static_cast<unsigned short>(10), 2,
-           std::string("str1"), "example3");
-  LOG_INFO(logger, "brown test jumps lazy {} {} {}", 7UL, std::string("str2"), 1);
-  LOG_INFO(logger, "over jumps brown dog {} {} {}", 7UL, std::string("str2"), static_cast<short>(9));
-  LOG_INFO(logger, "brown test example {} {} {} {} {} {} {}", 5L, static_cast<unsigned short>(10),
-           "example3", 7UL, "example2", std::string_view("view1"), 6LL);
-  LOG_INFO(logger, "test brown dog {} {} {} {} {} {} {}", 1, 2, 6LL, 8ULL, true, "example1", 5L);
-  LOG_INFO(logger, "lazy fox over {} {} {} {} {} {} {} {} {}", std::string_view("view1"), true,
-           std::string("str2"), 4.0f, 3.0, "example2", 1, std::string_view("view2"),
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "dog over jumps {} {}", "example2", 3.0);
-  LOG_INFO(logger, "test quick jumps dog {} {} {} {} {} {}", std::string("str1"),
-           std::string("str2"), 5L, std::string_view("view2"), 3.0, 4.0f);
-  LOG_INFO(logger, "logging over example {} {} {} {} {}", static_cast<unsigned short>(10), 4.0f, 5L,
-           2, "example2");
-  LOG_INFO(logger, "dog example jumps {} {} {}", "example1", static_cast<unsigned short>(10), 8ULL);
-  LOG_INFO(logger, "example dog fox logging {} {} {} {}", 5L, std::string("str2"), "example3",
-           "example2");
-  LOG_INFO(logger, "fox dog test lazy {} {} {} {} {} {} {}", "example3", std::string("str1"),
-           "example2", 1, "example1", std::string_view("view2"), false);
-  LOG_INFO(logger, "fox logging lazy quick {}", 2);
-  LOG_INFO(logger, "test quick over {}", std::string_view("view2"));
-  LOG_INFO(logger, "example logging jumps dog {} {}", std::string("str1"), std::string_view("view2"));
-  LOG_INFO(logger, "over lazy logging {} {} {} {} {} {}", 7UL, 6LL, static_cast<short>(9),
-           "example1", std::string_view("view1"), "example3");
-  LOG_INFO(logger, "logging example dog {} {} {} {} {} {} {} {} {} {}", 3.0, static_cast<unsigned short>(10),
-           5L, "example3", 2, static_cast<short>(9), false, std::string("str1"), 6LL, 4.0f);
-  LOG_INFO(logger, "example quick lazy {} {}", static_cast<unsigned short>(10), false);
-  LOG_INFO(logger, "example fox over logging {} {} {}", "example2", static_cast<short>(9),
-           "example1");
-  LOG_INFO(logger, "logging jumps brown {} {} {} {} {} {} {} {} {} {}", 5L, 2, 6LL, 4.0f,
-           "example2", std::string_view("view2"), 3.0, static_cast<unsigned short>(10), "example3",
-           std::string_view("view1"));
-  LOG_INFO(logger, "quick logging example fox {}", 2);
-  LOG_INFO(logger, "example over quick {} {} {} {} {} {} {}", 6LL, 1, 5L, 2, 4.0f, 8ULL, "example3");
-  LOG_INFO(logger, "quick lazy test example {} {} {} {} {} {} {}", 4.0f, std::string("str2"), 2,
-           7UL, false, "example2", 1);
-  LOG_INFO(logger, "dog jumps fox lazy {} {} {} {} {} {}", true, 3.0, std::string("str2"), false,
-           std::string("str1"), 5L);
-  LOG_INFO(logger, "brown quick dog jumps {} {} {}", 6LL, 4.0f, false);
-  LOG_INFO(logger, "test lazy over brown {} {} {}", std::string("str2"), static_cast<short>(9),
-           "example2");
-  LOG_INFO(logger, "fox example quick jumps {} {} {} {}", 6LL, std::string("str2"), 2, 8ULL);
-  LOG_INFO(logger, "logging brown dog over {} {} {} {}", 4.0f, 2, std::string_view("view2"), 6LL);
-  LOG_INFO(logger, "over fox brown lazy {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           4.0f, true, 7UL, 5L, "example2", std::string_view("view1"), std::string("str1"));
-  LOG_INFO(logger, "fox quick lazy {} {} {} {} {} {} {} {} {}", "example1",
-           std::string_view("view2"), true, 7UL, 2, std::string_view("view1"),
-           static_cast<short>(9), std::string("str1"), std::string("str2"));
-  LOG_INFO(logger, "test brown example fox {} {} {} {} {} {} {} {} {} {}", 1, static_cast<short>(9),
-           false, true, 5L, std::string("str2"), "example3", 8ULL, 6LL, 7UL);
-  LOG_INFO(logger, "dog lazy logging example {} {} {} {} {} {}", 5L,
-           static_cast<unsigned short>(10), 3.0, 1, true, 8ULL);
-  LOG_INFO(logger, "logging quick fox test {} {} {} {} {} {} {} {} {}", true, false, std::string("str1"), 7UL,
-           static_cast<short>(9), static_cast<unsigned short>(10), 5L, "example3", std::string("str2"));
-  LOG_INFO(logger, "test quick over brown {} {}", false, "example3");
-  LOG_INFO(logger, "lazy quick over test {} {} {} {} {} {} {}", std::string("str1"),
-           static_cast<short>(9), std::string("str2"), std::string_view("view1"), 8ULL, 7UL, 6LL);
-  LOG_INFO(logger, "fox brown example {} {} {} {} {} {} {}", 7UL, static_cast<unsigned short>(10),
-           6LL, true, false, "example2", std::string("str2"));
-  LOG_INFO(logger, "brown logging quick {} {} {} {} {} {} {} {} {} {}", "example3", 4.0f, 5L, true,
-           "example1", "example2", static_cast<short>(9), 2, 6LL, 1);
-  LOG_INFO(logger, "test dog jumps {} {}", "example2", 4.0f);
-  LOG_INFO(logger, "brown test dog {} {}", 5L, 3.0);
-  LOG_INFO(logger, "dog jumps test {} {} {} {} {}", 8ULL, std::string("str1"), 6LL, 1, false);
-  LOG_INFO(logger, "example over jumps {} {} {} {} {} {} {} {} {} {}", std::string_view("view1"),
-           3.0, 2, "example1", 5L, 6LL, std::string_view("view2"), 4.0f, static_cast<short>(9), 8ULL);
-  LOG_INFO(logger, "quick logging brown jumps {} {} {} {} {}", 7UL, 1,
-           static_cast<unsigned short>(10), true, "example3");
-  LOG_INFO(logger, "test dog fox brown {} {} {} {} {} {} {} {}", std::string_view("view2"), 6LL,
-           7UL, std::string("str1"), static_cast<short>(9), true, std::string_view("view1"), false);
-  LOG_INFO(logger, "over lazy brown {} {} {} {} {} {} {}", "example3", 8ULL, std::string_view("view1"),
-           false, std::string("str1"), std::string_view("view2"), "example2");
-  LOG_INFO(logger, "dog over logging lazy {} {} {} {} {} {} {} {}", "example1", 4.0f, "example3",
-           true, 8ULL, std::string("str2"), std::string_view("view1"), 3.0);
-  LOG_INFO(logger, "logging over dog quick {} {} {} {} {} {}", 5L, std::string("str2"), 7UL,
-           "example3", std::string("str1"), 4.0f);
-  LOG_INFO(logger, "dog example test {} {} {} {}", static_cast<unsigned short>(10),
-           std::string("str1"), "example2", std::string_view("view2"));
-  LOG_INFO(logger, "quick example jumps {} {} {} {} {}", 1, 7UL, 3.0, "example3", 6LL);
-  LOG_INFO(logger, "quick brown dog {} {} {} {} {} {} {} {} {}", std::string_view("view2"), false,
-           6LL, static_cast<unsigned short>(10), 5L, "example2", 8ULL, 7UL, true);
-  LOG_INFO(logger, "example brown test quick {} {} {}", 3.0, 2, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "test over fox {} {} {} {}", "example3", "example1", true, static_cast<short>(9));
-  LOG_INFO(logger, "logging quick example {} {} {} {} {}", static_cast<short>(9), 5L,
-           std::string_view("view1"), "example1", 2);
-  LOG_INFO(logger, "example brown over {} {} {} {} {} {}", std::string_view("view2"),
-           std::string("str2"), 2, 7UL, std::string_view("view1"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "dog test lazy fox {} {} {} {} {} {} {}", std::string("str2"), 8ULL, 6LL, 2,
-           4.0f, "example3", false);
-  LOG_INFO(logger, "test brown dog {}", false);
-  LOG_INFO(logger, "jumps example lazy {}", 4.0f);
-  LOG_INFO(logger, "over lazy jumps logging {} {} {} {} {} {} {} {} {} {}", 8ULL,
-           static_cast<unsigned short>(10), 3.0, std::string_view("view2"), false, true, 5L, 4.0f,
-           static_cast<short>(9), "example1");
-  LOG_INFO(logger, "fox lazy brown jumps {} {} {} {} {} {} {}", std::string("str2"),
-           static_cast<unsigned short>(10), 5L, 1, "example2", 4.0f, false);
-  LOG_INFO(logger, "example brown logging jumps {} {} {} {} {} {} {} {}", 6LL, std::string_view("view1"),
-           2, false, static_cast<short>(9), static_cast<unsigned short>(10), "example1", 4.0f);
-  LOG_INFO(logger, "fox test brown {} {} {} {} {}", static_cast<short>(9), 3.0, 8ULL, 5L, 4.0f);
-  LOG_INFO(logger, "over logging dog test {} {} {}", std::string_view("view1"), 8ULL,
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown dog jumps test {} {} {}", 3.0, "example2", 5L);
-  LOG_INFO(logger, "jumps example lazy {} {}", "example1", false);
-  LOG_INFO(logger, "lazy dog test {} {} {} {}", std::string("str2"),
-           static_cast<unsigned short>(10), false, static_cast<short>(9));
-  LOG_INFO(logger, "test fox lazy logging {} {}", static_cast<unsigned short>(10), 8ULL);
-  LOG_INFO(logger, "logging jumps fox {} {} {}", true, 3.0, 5L);
-  LOG_INFO(logger, "quick example lazy brown {} {} {} {} {} {} {} {} {} {}", "example1", true, 3.0, 7UL,
-           8ULL, std::string("str2"), std::string("str1"), 4.0f, "example2", std::string_view("view2"));
-  LOG_INFO(logger, "brown example over lazy {} {} {} {} {} {} {}", std::string_view("view1"), 3.0,
-           4.0f, "example3", std::string("str2"), 8ULL, 6LL);
-  LOG_INFO(logger, "example test brown quick {} {} {} {} {} {}", "example2", 7UL, 4.0f,
-           static_cast<short>(9), "example1", 2);
-  LOG_INFO(logger, "over logging example jumps {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           6LL, 4.0f, 7UL, 3.0, true);
-  LOG_INFO(logger, "example fox lazy test {} {} {} {} {} {}", static_cast<short>(9), 6LL, 7UL, 1, 4.0f, 8ULL);
-  LOG_INFO(logger, "brown lazy quick {} {} {} {} {} {} {}", static_cast<short>(9), 6LL, true,
-           static_cast<unsigned short>(10), "example2", false, 5L);
-  LOG_INFO(logger, "quick example lazy {}", std::string_view("view2"));
-  LOG_INFO(logger, "fox example over {} {} {}", static_cast<unsigned short>(10), std::string_view("view2"), 5L);
-  LOG_INFO(logger, "dog over fox {} {} {} {}", 1, std::string_view("view2"), 2, std::string("str2"));
-  LOG_INFO(logger, "test jumps quick dog {} {} {} {} {} {} {}", std::string("str1"), 1, "example3",
-           4.0f, static_cast<unsigned short>(10), 8ULL, "example2");
-  LOG_INFO(logger, "example jumps lazy {} {} {} {} {}", std::string("str2"), "example2",
-           static_cast<short>(9), 6LL, 8ULL);
-  LOG_INFO(logger, "quick jumps lazy example {} {} {} {} {} {} {}", 4.0f, 7UL, false,
-           static_cast<unsigned short>(10), "example2", static_cast<short>(9), 1);
-  LOG_INFO(logger, "dog quick brown {} {} {} {} {}", false, 4.0f, "example3", 7UL, true);
-  LOG_INFO(logger, "quick brown jumps {} {} {} {} {} {} {}", 2, 3.0, "example3", 1, 8ULL,
-           static_cast<unsigned short>(10), std::string("str1"));
-  LOG_INFO(logger, "test lazy dog quick {} {} {} {} {}", std::string("str2"), static_cast<short>(9),
-           8ULL, false, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "over quick lazy fox {} {}", "example1", std::string_view("view1"));
-  LOG_INFO(logger, "quick over lazy {} {} {} {} {} {}", false, static_cast<short>(9), 2, 1, 3.0,
-           std::string("str1"));
-  LOG_INFO(logger, "fox lazy logging {} {} {} {} {} {} {}", 4.0f, "example3", true, false,
-           std::string_view("view2"), static_cast<short>(9), std::string("str1"));
-  LOG_INFO(logger, "example jumps dog fox {} {} {} {}", std::string_view("view1"),
-           static_cast<unsigned short>(10), std::string("str1"), 8ULL);
-  LOG_INFO(logger, "dog lazy test logging {} {} {} {} {} {} {} {}", std::string_view("view2"), 8ULL,
-           2, std::string("str1"), static_cast<short>(9), "example3", std::string("str2"), true);
-  LOG_INFO(logger, "logging dog jumps {} {} {} {} {} {} {} {} {} {}", "example2", 1, false, 6LL,
-           3.0, static_cast<unsigned short>(10), std::string_view("view2"), 4.0f, true, "example3");
-  LOG_INFO(logger, "example dog logging quick {} {} {} {} {} {}", false, "example3", 4.0f,
-           std::string("str1"), 7UL, 5L);
-  LOG_INFO(logger, "test fox quick brown {}", std::string_view("view2"));
-  LOG_INFO(logger, "example quick logging {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           std::string("str1"), 2, "example2", std::string("str2"), std::string_view("view2"),
-           "example1");
-  LOG_INFO(logger, "jumps fox quick test {} {} {} {} {} {} {} {}", 4.0f, 5L, "example2", 3.0,
-           static_cast<short>(9), 1, 8ULL, std::string_view("view1"));
-  LOG_INFO(logger, "logging lazy jumps quick {} {} {} {} {}", 7UL, "example2",
-           std::string_view("view2"), 4.0f, 3.0);
-  LOG_INFO(logger, "test logging lazy over {} {} {} {} {} {} {} {}", "example1",
-           std::string_view("view2"), 6LL, 5L, std::string("str1"), 8ULL, 3.0, static_cast<short>(9));
-  LOG_INFO(logger, "logging test fox {}", 8ULL);
-  LOG_INFO(logger, "dog lazy jumps {} {} {} {} {} {} {}", 3.0, 7UL, "example2", 1,
-           std::string_view("view2"), 6LL, std::string_view("view1"));
-  LOG_INFO(logger, "dog over fox jumps {} {} {} {} {} {} {} {}", static_cast<short>(9),
-           std::string_view("view2"), 2, "example2", 6LL, 8ULL, std::string("str2"),
-           std::string_view("view1"));
-  LOG_INFO(logger, "logging quick lazy {} {} {} {} {}", 8ULL, std::string("str1"), 4.0f,
-           std::string("str2"), "example2");
-  LOG_INFO(logger, "dog test fox {} {} {} {} {} {} {} {} {}", "example1", std::string("str2"), 1,
-           3.0, std::string_view("view2"), 7UL, false, 8ULL, 2);
-  LOG_INFO(logger, "over dog quick jumps {} {} {} {} {} {} {} {} {}", std::string("str2"), 8ULL,
-           "example3", 3.0, false, true, 2, std::string_view("view2"), static_cast<short>(9));
-  LOG_INFO(logger, "quick logging brown {} {} {} {} {}", "example3",
-           static_cast<unsigned short>(10), 8ULL, "example1", false);
-  LOG_INFO(logger, "lazy example logging fox {} {} {} {} {} {} {}", 7UL, 6LL, 3.0, false, 5L,
-           std::string("str2"), true);
-  LOG_INFO(logger, "fox over brown lazy {} {} {} {} {}", 3.0, 6LL, true, std::string_view("view2"),
-           "example3");
-  LOG_INFO(logger, "test fox quick {} {} {} {} {} {} {} {} {}", "example2", 4.0f, std::string("str2"),
-           static_cast<unsigned short>(10), 6LL, 5L, static_cast<short>(9), false, true);
-  LOG_INFO(logger, "brown quick lazy dog {} {} {} {} {} {}", static_cast<short>(9), "example1", 2,
-           4.0f, 8ULL, 7UL);
-  LOG_INFO(logger, "example dog logging {} {}", true, "example1");
-  LOG_INFO(logger, "logging example jumps over {} {} {} {}", 4.0f, static_cast<unsigned short>(10),
-           "example2", static_cast<short>(9));
-  LOG_INFO(logger, "lazy brown example test {} {} {} {} {} {}", true, 1, static_cast<short>(9),
-           8ULL, 3.0, std::string("str1"));
-  LOG_INFO(logger, "test example jumps {} {} {} {} {}", "example3", 4.0f, true, std::string_view("view1"), 6LL);
-  LOG_INFO(logger, "fox quick over {} {} {} {} {} {} {}", 3.0, std::string_view("view1"), 2, 8ULL,
-           7UL, true, "example3");
-  LOG_INFO(logger, "test logging jumps brown {}", 1);
-  LOG_INFO(logger, "jumps lazy logging quick {}", "example2");
-  LOG_INFO(logger, "lazy quick dog logging {} {} {} {} {} {}", "example3", 5L, "example1", 3.0,
-           std::string("str2"), std::string("str1"));
-  LOG_INFO(logger, "example test logging {} {}", std::string_view("view2"), "example1");
-  LOG_INFO(logger, "brown logging dog fox {} {} {} {} {} {} {} {} {} {}", 1, static_cast<short>(9),
-           "example2", 7UL, 8ULL, std::string("str2"), "example3", 5L, 2, 6LL);
-  LOG_INFO(logger, "logging lazy dog {} {} {}", std::string("str1"), "example2", "example1");
-  LOG_INFO(logger, "test lazy fox brown {} {} {}", static_cast<short>(9), std::string_view("view1"),
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "over test example fox {}", std::string_view("view2"));
-  LOG_INFO(logger, "fox test lazy {}", std::string("str2"));
-  LOG_INFO(logger, "over test dog {} {} {} {}", std::string("str2"), 7UL, std::string("str1"), 8ULL);
-  LOG_INFO(logger, "fox example brown {} {} {} {} {} {} {} {} {}", true, std::string("str1"), 1,
-           std::string_view("view1"), "example2", "example1", std::string_view("view2"), 6LL, 7UL);
-  LOG_INFO(logger, "test jumps fox example {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           "example3", static_cast<short>(9), 5L, std::string("str2"), 8ULL, true, 7UL);
-  LOG_INFO(logger, "fox jumps over {} {} {} {} {} {} {} {}", 5L, std::string_view("view1"), 4.0f,
-           8ULL, "example2", std::string("str1"), "example3", static_cast<short>(9));
-  LOG_INFO(logger, "jumps fox logging lazy {} {} {} {} {} {} {} {}", "example2", 3.0, 5L,
-           std::string("str2"), 2, 6LL, 8ULL, 1);
-  LOG_INFO(logger, "quick lazy dog example {}", static_cast<short>(9));
-  LOG_INFO(logger, "jumps example lazy {} {} {} {} {} {} {} {} {}", 1, 3.0, 4.0f, true, 5L, 8ULL,
-           "example3", std::string_view("view1"), 7UL);
-  LOG_INFO(logger, "over test quick {} {} {}", static_cast<short>(9), 2, 5L);
-  LOG_INFO(logger, "jumps fox lazy {} {} {} {} {}", "example2", 3.0, "example3",
-           std::string_view("view1"), std::string_view("view2"));
-  LOG_INFO(logger, "jumps dog test {} {} {} {} {} {} {}", false, 7UL, std::string("str2"), 8ULL,
-           std::string_view("view2"), 6LL, std::string("str1"));
-  LOG_INFO(logger, "fox quick brown {} {} {} {}", 7UL, "example2", std::string_view("view1"), 5L);
-  LOG_INFO(logger, "over quick jumps {} {} {} {} {} {} {} {} {}", 4.0f, 6LL, static_cast<short>(9),
-           3.0, "example2", std::string("str1"), "example3", "example1", std::string_view("view1"));
-  LOG_INFO(logger, "lazy jumps over fox {} {} {} {} {} {} {} {} {}", std::string_view("view2"), 1,
-           3.0, static_cast<unsigned short>(10), std::string("str2"), "example2",
-           static_cast<short>(9), true, 6LL);
-  LOG_INFO(logger, "jumps dog brown example {} {} {} {} {} {}", 8ULL, 6LL, std::string("str2"),
-           "example2", false, 4.0f);
-  LOG_INFO(logger, "test fox jumps logging {} {} {} {} {} {} {} {} {} {}", false, "example2", 4.0f,
-           std::string("str1"), "example3", true, std::string_view("view2"), 1, std::string("str2"),
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "logging test example over {}", false);
-  LOG_INFO(logger, "jumps brown dog {}", 5L);
-  LOG_INFO(logger, "dog lazy brown quick {} {} {} {} {} {} {} {} {} {}", std::string("str2"),
-           std::string("str1"), "example3", 8ULL, std::string_view("view1"), "example1", "example2",
-           false, 6LL, static_cast<short>(9));
-  LOG_INFO(logger, "lazy fox brown {} {} {}", std::string_view("view2"), static_cast<unsigned short>(10), 5L);
-  LOG_INFO(logger, "jumps brown lazy {} {} {} {} {} {} {}", std::string_view("view1"),
-           static_cast<short>(9), 1, 2, std::string("str1"), 4.0f, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "jumps lazy fox {} {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           3.0, 2, std::string("str2"), 6LL, "example2", "example3", true, 4.0f, std::string("str1"));
-  LOG_INFO(logger, "test logging dog {} {} {} {} {} {}", false, std::string_view("view2"), 3.0, 6LL,
-           "example1", 2);
-  LOG_INFO(logger, "dog logging example fox {} {} {} {} {} {} {} {} {}", false, static_cast<short>(9),
-           std::string("str1"), static_cast<unsigned short>(10), 6LL, true, 1, 3.0, std::string("str2"));
-  LOG_INFO(logger, "fox test lazy {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           std::string("str2"), 2, true, 3.0, static_cast<short>(9), std::string_view("view2"));
-  LOG_INFO(logger, "dog test over {} {} {}", std::string_view("view1"), 2, static_cast<short>(9));
-  LOG_INFO(logger, "fox example test {} {} {} {} {} {} {}", 5L, std::string_view("view1"),
-           "example3", 8ULL, std::string("str1"), true, 7UL);
-  LOG_INFO(logger, "dog over quick {} {} {} {}", "example3", 2, std::string_view("view1"),
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "lazy example over {} {}", 4.0f, true);
-  LOG_INFO(logger, "over brown jumps fox {} {} {} {} {} {} {} {}", "example1", std::string_view("view2"),
-           2, static_cast<short>(9), std::string("str2"), 5L, std::string("str1"), 1);
-  LOG_INFO(logger, "over dog fox quick {} {} {} {} {} {}", static_cast<short>(9), false,
-           std::string("str2"), 8ULL, "example2", "example3");
-  LOG_INFO(logger, "fox quick jumps example {} {} {} {} {}", 2, "example3", static_cast<short>(9),
-           std::string_view("view2"), std::string("str1"));
-  LOG_INFO(logger, "test fox logging {} {} {} {} {} {}", "example2", 4.0f,
-           static_cast<unsigned short>(10), 6LL, "example3", std::string("str1"));
-  LOG_INFO(logger, "quick logging lazy {} {} {} {} {} {} {} {} {}", 1, 8ULL, 4.0f, 6LL,
-           std::string("str2"), std::string_view("view1"), 2, true, false);
-  LOG_INFO(logger, "example lazy quick fox {} {} {} {} {} {} {} {} {} {}", false, 7UL, 3.0, true,
-           6LL, 5L, 8ULL, 1, "example1", std::string_view("view1"));
-  LOG_INFO(logger, "jumps example over {} {} {} {} {}", true, 2, std::string("str1"),
-           std::string_view("view2"), 3.0);
-  LOG_INFO(logger, "test dog jumps fox {} {} {} {} {}", "example2", "example1", 4.0f, 5L, 3.0);
-  LOG_INFO(logger, "brown over jumps {}", 8ULL);
-  LOG_INFO(logger, "test jumps quick {} {} {}", 1, 5L, "example1");
-  LOG_INFO(logger, "example test jumps brown {} {} {}", static_cast<unsigned short>(10), 5L,
-           "example2");
-  LOG_INFO(logger, "dog brown test lazy {} {} {} {} {} {} {}", std::string("str2"), 7UL, "example2",
-           5L, 2, false, "example3");
-  LOG_INFO(logger, "example fox dog over {} {} {} {} {} {} {} {}", true, 3.0, 8ULL, "example3", 1,
-           std::string("str2"), static_cast<short>(9), 7UL);
-  LOG_INFO(logger, "over dog jumps {} {}", std::string_view("view2"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "lazy quick jumps {} {} {} {} {} {} {}", static_cast<short>(9), 1, 2, false,
-           4.0f, std::string_view("view1"), 3.0);
-  LOG_INFO(logger, "over quick test logging {} {} {} {} {} {} {} {} {}", 2, std::string("str1"),
-           7UL, 5L, "example2", true, "example1", std::string("str2"), 4.0f);
-  LOG_INFO(logger, "over test logging {} {} {} {} {} {} {} {} {}", 5L, 4.0f, std::string_view("view1"),
-           std::string_view("view2"), 3.0, std::string("str1"), "example3", 8ULL, 1);
-  LOG_INFO(logger, "test lazy logging dog {} {}", 7UL, "example3");
-  LOG_INFO(logger, "example fox lazy logging {} {} {} {} {} {} {} {} {}", 1, 8ULL, 3.0,
-           std::string_view("view2"), "example3", std::string_view("view1"), true,
-           static_cast<unsigned short>(10), "example2");
-  LOG_INFO(logger, "dog over test {} {} {}", 1, 8ULL, std::string_view("view1"));
-  LOG_INFO(logger, "dog logging test brown {} {} {}", std::string_view("view1"), 5L,
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox quick over example {} {} {}", static_cast<unsigned short>(10), "example3", true);
-  LOG_INFO(logger, "lazy jumps example {} {} {}", 8ULL, 3.0, true);
-  LOG_INFO(logger, "quick logging test {} {} {} {} {} {} {} {}", 3.0, std::string_view("view1"), 1,
-           true, std::string_view("view2"), static_cast<short>(9), std::string("str2"), 4.0f);
-  LOG_INFO(logger, "quick dog fox example {}", 5L);
-  LOG_INFO(logger, "lazy fox brown {} {} {} {} {} {}", true, "example1", 3.0, "example3", 7UL,
-           std::string("str1"));
-  LOG_INFO(logger, "fox jumps quick test {} {} {} {} {}", std::string("str2"),
-           std::string_view("view2"), static_cast<short>(9), "example2", 6LL);
-  LOG_INFO(logger, "brown logging fox {} {} {} {} {} {} {} {} {} {}", 2, std::string_view("view2"),
-           "example2", std::string("str1"), "example1", 7UL, 6LL, false, 3.0, "example3");
-  LOG_INFO(logger, "dog lazy over logging {} {} {} {}", std::string("str2"), 1,
-           std::string_view("view1"), std::string_view("view2"));
-  LOG_INFO(logger, "dog test over {} {} {} {}", std::string_view("view2"), 5L, "example1",
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "dog example quick logging {} {} {}", 3.0, std::string_view("view1"), 8ULL);
-  LOG_INFO(logger, "dog lazy test {} {} {} {} {} {} {}", true, static_cast<short>(9),
-           std::string_view("view1"), 2, false, std::string("str2"), 5L);
-  LOG_INFO(logger, "test jumps quick {} {} {}", std::string("str1"), 1, std::string_view("view1"));
-  LOG_INFO(logger, "example lazy brown {} {} {} {} {} {} {}", std::string("str2"), std::string_view("view1"),
-           2, static_cast<unsigned short>(10), 1, std::string_view("view2"), 8ULL);
-  LOG_INFO(logger, "test example fox {} {} {} {} {} {} {}", "example1", "example3", true, 8ULL,
-           static_cast<unsigned short>(10), 6LL, false);
-  LOG_INFO(logger, "test brown over fox {} {} {} {} {} {}", "example1", std::string_view("view1"),
-           8ULL, static_cast<short>(9), 6LL, false);
-  LOG_INFO(logger, "jumps dog test logging {} {}", "example1", 4.0f);
-  LOG_INFO(logger, "fox quick lazy jumps {} {} {}", false, 6LL, 1);
-  LOG_INFO(logger, "fox brown test lazy {} {} {} {} {} {} {}", static_cast<short>(9),
-           std::string_view("view2"), "example3", std::string("str2"), std::string_view("view1"), false, true);
-  LOG_INFO(logger, "jumps fox brown lazy {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           2, "example1", true, static_cast<short>(9), std::string_view("view2"), "example3", 6LL);
-  LOG_INFO(logger, "logging lazy jumps test {} {} {} {} {}", 7UL, std::string_view("view2"), 8ULL,
-           "example1", static_cast<short>(9));
-  LOG_INFO(logger, "jumps logging test {} {} {} {} {} {} {} {}", 2, false, 5L, 6LL, 7UL, 8ULL, 4.0f,
-           std::string("str2"));
-  LOG_INFO(logger, "fox quick brown test {} {} {} {} {} {}", "example2", 7UL,
-           static_cast<unsigned short>(10), false, "example3", std::string_view("view2"));
-  LOG_INFO(logger, "brown logging lazy {} {} {} {} {} {}", false, std::string_view("view1"),
-           std::string("str1"), std::string_view("view2"), 3.0, "example1");
-  LOG_INFO(logger, "test fox dog {} {} {}", std::string_view("view2"), 6LL, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "dog over jumps {} {} {} {} {} {}", true, 3.0, "example1", "example3", 1, 2);
-  LOG_INFO(logger, "fox example over {} {} {}", "example3", 8ULL, 6LL);
-  LOG_INFO(logger, "logging test example {} {} {} {}", std::string_view("view1"), 7UL, 3.0, 2);
-  LOG_INFO(logger, "jumps test dog {} {} {}", 1, 3.0, 2);
-  LOG_INFO(logger, "brown test logging fox {} {} {} {} {} {} {} {}", 8ULL, 4.0f, 7UL,
-           std::string("str2"), std::string_view("view1"), "example3", false, 6LL);
-  LOG_INFO(logger, "quick dog over {} {} {} {} {} {} {} {}", true, 5L, 4.0f, "example1", false,
-           "example2", static_cast<unsigned short>(10), 3.0);
-  LOG_INFO(logger, "over quick logging {} {} {}", 6LL, static_cast<unsigned short>(10), 3.0);
-  LOG_INFO(logger, "brown over lazy logging {} {} {} {} {} {}", "example2", "example1", 7UL, 4.0f,
-           std::string_view("view2"), "example3");
-  LOG_INFO(logger, "lazy quick jumps {} {} {} {} {} {} {}", 3.0, 5L, false, 6LL,
-           std::string_view("view2"), "example1", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "over brown dog logging {} {}", "example3", "example1");
-  LOG_INFO(logger, "lazy example jumps {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           "example1", 6LL, "example3", false, static_cast<short>(9), "example2", std::string("str2"), 8ULL);
-  LOG_INFO(logger, "brown logging dog fox {} {} {}", std::string_view("view2"), 3.0, 2);
-  LOG_INFO(logger, "over test brown {} {} {} {} {} {} {} {}", std::string("str2"), 7UL, false, true,
-           1, 5L, std::string_view("view2"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox brown logging {} {} {} {} {} {} {} {}", 2, false, 6LL, 1, 4.0f,
-           std::string_view("view1"), "example1", static_cast<short>(9));
-  LOG_INFO(logger, "jumps dog quick {} {} {} {} {} {} {}", std::string("str1"), 7UL, true, 4.0f, 5L, 2, 3.0);
-  LOG_INFO(logger, "example over lazy quick {} {} {} {} {} {} {}", 6LL, 8ULL, true,
-           static_cast<unsigned short>(10), 4.0f, 2, std::string("str2"));
-  LOG_INFO(logger, "brown test quick {} {} {} {} {}", 3.0, "example1", 7UL, static_cast<short>(9), 5L);
-  LOG_INFO(logger, "test lazy jumps {} {} {} {} {} {} {} {} {} {}", 7UL, 1, std::string("str2"),
-           std::string_view("view1"), "example3", "example2", static_cast<unsigned short>(10), 6LL,
-           4.0f, std::string("str1"));
-  LOG_INFO(logger, "logging over quick test {} {} {} {} {} {} {} {} {} {}", true, std::string("str1"),
-           5L, 6LL, 3.0, std::string_view("view2"), 8ULL, static_cast<unsigned short>(10), false, 2);
-  LOG_INFO(logger, "jumps brown logging {} {} {} {}", "example1", std::string("str1"),
-           std::string_view("view1"), 7UL);
-  LOG_INFO(logger, "test fox dog quick {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           6LL, std::string("str1"), 2, true, "example1", std::string_view("view2"), false, 3.0);
-  LOG_INFO(logger, "fox dog logging {} {} {}", false, std::string("str1"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "lazy brown logging over {} {}", 7UL, std::string("str1"));
-  LOG_INFO(logger, "quick brown lazy over {}", "example3");
-  LOG_INFO(logger, "over logging test {} {} {} {} {} {}", std::string_view("view2"),
-           static_cast<short>(9), 2, std::string("str1"), 7UL, true);
-  LOG_INFO(logger, "over quick dog jumps {} {} {}", static_cast<short>(9), "example2",
-           std::string_view("view1"));
-  LOG_INFO(logger, "example test fox lazy {} {} {} {} {} {} {} {} {} {}", 6LL, 1, true,
-           std::string_view("view1"), static_cast<short>(9), std::string_view("view2"),
-           std::string("str1"), 8ULL, "example3", false);
-  LOG_INFO(logger, "example fox quick over {} {} {} {} {} {} {} {} {}", 7UL, static_cast<short>(9),
-           static_cast<unsigned short>(10), "example2", true, 5L, 4.0f, 2, 8ULL);
-  LOG_INFO(logger, "quick lazy test brown {} {} {} {} {} {} {} {} {}", 8ULL, 6LL, 3.0,
-           std::string("str1"), 2, 5L, "example3", false, 1);
-  LOG_INFO(logger, "example dog jumps lazy {}", std::string_view("view2"));
-  LOG_INFO(logger, "fox over quick {} {} {} {} {} {} {} {} {}", 7UL, static_cast<short>(9),
-           std::string_view("view1"), std::string("str2"), static_cast<unsigned short>(10),
-           "example1", 1, 8ULL, true);
-  LOG_INFO(logger, "over jumps brown example {} {} {} {} {} {}", std::string_view("view1"), 2,
-           "example1", 6LL, static_cast<unsigned short>(10), 5L);
-  LOG_INFO(logger, "fox test over jumps {} {} {} {} {} {} {} {} {} {}", "example2", "example1", 7UL,
-           "example3", 8ULL, std::string_view("view1"), 2, std::string("str2"), std::string("str1"), false);
-  LOG_INFO(logger, "logging jumps lazy {} {} {} {} {}", std::string("str2"), "example3", 6LL,
-           "example2", std::string("str1"));
-  LOG_INFO(logger, "example jumps logging {}", 8ULL);
-  LOG_INFO(logger, "logging test over {}", "example1");
-  LOG_INFO(logger, "logging lazy test {} {} {} {} {} {} {} {} {}", "example2", 1,
-           static_cast<unsigned short>(10), std::string_view("view2"), 3.0, static_cast<short>(9),
-           7UL, 5L, 8ULL);
-  LOG_INFO(logger, "logging dog test {} {} {}", std::string_view("view2"), 2, false);
-  LOG_INFO(logger, "jumps example test {} {} {} {} {}", 1, true, 2, std::string("str2"), "example3");
-  LOG_INFO(logger, "jumps example brown {}", "example2");
-  LOG_INFO(logger, "logging fox quick lazy {}", static_cast<short>(9));
-  LOG_INFO(logger, "logging over test jumps {} {} {} {}", std::string_view("view1"), 8ULL,
-           std::string_view("view2"), std::string("str2"));
-  LOG_INFO(logger, "quick test jumps {} {} {} {} {}", std::string("str2"), "example1", "example2", 8ULL, 1);
-  LOG_INFO(logger, "test lazy dog brown {} {} {}", 2, static_cast<short>(9), 8ULL);
-  LOG_INFO(logger, "test quick over {} {}", std::string("str2"), "example1");
-  LOG_INFO(logger, "quick dog fox {} {} {}", 5L, 8ULL, "example3");
-  LOG_INFO(logger, "test lazy fox {} {}", std::string("str1"), std::string("str2"));
-  LOG_INFO(logger, "example brown dog {} {} {} {} {} {} {} {} {} {}", 4.0f, std::string("str2"),
-           "example1", 1, 5L, "example2", std::string_view("view2"), static_cast<short>(9),
-           std::string("str1"), 7UL);
-  LOG_INFO(logger, "brown test example dog {} {} {} {} {}", "example3", false,
-           std::string_view("view2"), std::string_view("view1"), 3.0);
-  LOG_INFO(logger, "dog over lazy quick {} {} {} {} {} {} {} {} {} {}", 2, 6LL,
-           static_cast<short>(9), std::string_view("view2"), std::string_view("view1"),
-           std::string("str1"), true, "example2", false, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown lazy example {} {} {}", static_cast<short>(9), true, 7UL);
-  LOG_INFO(logger, "jumps quick dog {} {}", std::string("str1"), 3.0);
-  LOG_INFO(logger, "brown test over quick {} {} {} {} {} {} {}", 3.0, true, std::string("str2"),
-           std::string_view("view2"), 7UL, static_cast<short>(9), "example1");
-  LOG_INFO(logger, "brown over example logging {} {} {} {} {}", 7UL, true, "example1",
-           std::string_view("view2"), 8ULL);
-  LOG_INFO(logger, "quick example test brown {} {} {} {} {} {} {} {} {} {}", std::string("str1"),
-           std::string_view("view2"), 2, 5L, "example1", 1, 6LL, 8ULL, "example3", 7UL);
-  LOG_INFO(logger, "lazy over logging {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10), 1,
-           7UL, std::string_view("view1"), "example3", 8ULL, static_cast<short>(9), "example2", 3.0);
-  LOG_INFO(logger, "test quick lazy {} {} {} {} {} {}", false, "example3", 6LL, 5L, "example1",
-           std::string_view("view2"));
-  LOG_INFO(logger, "dog logging fox {} {} {}", 4.0f, std::string("str1"), 2);
-  LOG_INFO(logger, "lazy logging example jumps {} {} {}", static_cast<unsigned short>(10),
-           std::string("str1"), 3.0);
-  LOG_INFO(logger, "dog jumps test {} {} {} {} {} {}", "example2", std::string("str1"), 4.0f,
-           static_cast<short>(9), "example1", std::string_view("view1"));
-  LOG_INFO(logger, "example jumps logging over {} {} {} {}", 7UL, "example1", std::string("str2"),
-           "example2");
-  LOG_INFO(logger, "quick fox lazy {} {} {} {} {} {} {}", 1, 6LL, 3.0, 5L,
-           static_cast<unsigned short>(10), 2, std::string("str2"));
-  LOG_INFO(logger, "quick jumps test {} {} {} {} {} {} {} {} {}", std::string_view("view1"), 3.0,
-           6LL, "example2", 7UL, true, std::string_view("view2"), static_cast<short>(9), false);
-  LOG_INFO(logger, "jumps example quick lazy {} {}", false, std::string("str2"));
-  LOG_INFO(logger, "test brown quick {} {} {}", std::string("str2"), std::string("str1"), 4.0f);
-  LOG_INFO(logger, "lazy brown dog {} {} {} {} {} {}", std::string("str1"), 8ULL, "example2", 2, 7UL, false);
-  LOG_INFO(logger, "fox over dog lazy {} {} {}", 5L, 3.0, std::string("str1"));
-  LOG_INFO(logger, "over test quick jumps {} {} {} {} {} {}", std::string_view("view1"), "example3",
-           std::string("str2"), 8ULL, std::string("str1"), std::string_view("view2"));
-  LOG_INFO(logger, "quick test dog {} {} {} {} {} {} {} {} {} {}", 1,
-           static_cast<unsigned short>(10), "example3", false, true, static_cast<short>(9), 6LL,
-           std::string_view("view1"), "example1", 2);
-  LOG_INFO(logger, "over brown test jumps {} {} {} {} {} {} {} {}", std::string_view("view2"), 7UL,
-           std::string("str1"), static_cast<unsigned short>(10), 4.0f, std::string_view("view1"), false, true);
-  LOG_INFO(logger, "test lazy jumps over {} {}", 1, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown dog lazy {} {} {} {}", std::string_view("view1"),
-           static_cast<unsigned short>(10), 7UL, true);
-  LOG_INFO(logger, "logging example dog over {}", std::string("str1"));
-  LOG_INFO(logger, "fox brown lazy logging {} {} {} {} {} {} {} {} {} {}", 2, 6LL, 4.0f, "example3",
-           std::string_view("view1"), "example2", true, 1, false, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "over brown dog lazy {} {} {} {}", 6LL, 8ULL, std::string_view("view1"), 2);
-  LOG_INFO(logger, "lazy logging test {} {}", 2, "example1");
-  LOG_INFO(logger, "quick fox jumps test {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           true, std::string_view("view1"), false, "example1", std::string_view("view2"), 1);
-  LOG_INFO(logger, "jumps test dog brown {} {} {} {} {} {} {}", 1, std::string("str2"), "example3",
-           std::string_view("view1"), static_cast<unsigned short>(10), std::string("str1"), false);
-  LOG_INFO(logger, "example quick logging {} {} {} {} {}", 5L, static_cast<short>(9), false, 2,
-           "example1");
-  LOG_INFO(logger, "dog example fox test {} {} {} {} {} {} {}", 3.0, "example3",
-           std::string_view("view2"), false, 5L, 4.0f, "example2");
-  LOG_INFO(logger, "dog lazy jumps {} {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           3.0, "example2", "example1", 1, 6LL, 5L, 8ULL, 2, std::string_view("view2"));
-  LOG_INFO(logger, "fox over jumps quick {} {} {} {} {}", true, 3.0, static_cast<short>(9),
-           std::string_view("view2"), 8ULL);
-  LOG_INFO(logger, "lazy jumps logging {} {}", std::string_view("view2"), 1);
-  LOG_INFO(logger, "quick logging over {} {} {} {} {} {}", 5L, std::string_view("view1"), 1,
-           std::string_view("view2"), false, 2);
-  LOG_INFO(logger, "logging over jumps example {}", std::string("str1"));
-  LOG_INFO(logger, "jumps example fox {} {}", 3.0, "example1");
-  LOG_INFO(logger, "brown dog lazy {} {} {} {} {} {} {}", 5L, false, 7UL, "example2",
-           std::string_view("view1"), static_cast<short>(9), "example3");
-  LOG_INFO(logger, "lazy example over test {} {} {} {} {} {} {} {}", std::string("str1"),
-           std::string_view("view2"), "example1", std::string_view("view1"), "example3", 6LL,
-           "example2", 2);
-  LOG_INFO(logger, "quick logging fox brown {} {} {} {} {} {} {} {} {}", 3.0, 4.0f,
-           static_cast<short>(9), 5L, false, 6LL, std::string("str1"), 1, std::string_view("view1"));
-  LOG_INFO(logger, "over example quick fox {} {} {} {} {}", false, 7UL,
-           static_cast<unsigned short>(10), "example1", static_cast<short>(9));
-  LOG_INFO(logger, "jumps dog lazy {} {} {} {}", std::string("str1"), "example3", 1, std::string_view("view1"));
-  LOG_INFO(logger, "brown dog quick {} {} {} {} {} {} {} {}", std::string("str2"), 1, static_cast<short>(9),
-           "example3", static_cast<unsigned short>(10), 3.0, std::string_view("view2"), 4.0f);
-  LOG_INFO(logger, "jumps lazy quick {} {}", false, 1);
-  LOG_INFO(logger, "quick logging lazy {} {} {} {} {} {} {} {} {} {}", std::string("str1"), 8ULL,
-           4.0f, 6LL, false, 1, static_cast<short>(9), true, std::string_view("view2"), "example1");
-  LOG_INFO(logger, "brown example fox {} {} {} {}", "example2", 8ULL, 3.0, 6LL);
-  LOG_INFO(logger, "dog over test {} {} {} {} {} {} {} {} {}", 5L, false, "example1", 1, 7UL,
-           static_cast<unsigned short>(10), 8ULL, static_cast<short>(9), 4.0f);
-  LOG_INFO(logger, "test fox logging quick {}", "example2");
-  LOG_INFO(logger, "lazy brown example quick {} {} {} {} {}", std::string_view("view1"), true, 5L,
-           std::string("str1"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "example dog jumps logging {} {} {} {} {} {} {} {}", 5L, 8ULL, 4.0f,
-           static_cast<unsigned short>(10), std::string("str2"), static_cast<short>(9), 6LL, false);
-  LOG_INFO(logger, "over test brown {} {} {}", 2, 4.0f, 3.0);
-  LOG_INFO(logger, "over example brown quick {}", 5L);
-  LOG_INFO(logger, "over example jumps lazy {} {}", std::string_view("view1"),
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox lazy over logging {} {} {} {} {} {}", 3.0, std::string_view("view1"), true,
-           5L, 1, std::string("str1"));
-  LOG_INFO(logger, "test jumps example logging {} {} {} {} {} {} {} {}", "example2", 5L, 7UL, 6LL,
-           std::string_view("view1"), "example3", "example1", std::string("str2"));
-  LOG_INFO(logger, "brown dog fox {} {} {}", true, std::string("str1"), 5L);
-  LOG_INFO(logger, "example brown over {} {} {} {} {}", std::string_view("view1"), "example2", 2,
-           std::string_view("view2"), 6LL);
-  LOG_INFO(logger, "fox dog test {} {} {} {}", static_cast<unsigned short>(10), std::string("str1"), 8ULL, true);
-  LOG_INFO(logger, "example quick lazy {} {}", 2, 1);
-  LOG_INFO(logger, "jumps fox over {} {}", static_cast<short>(9), true);
-  LOG_INFO(logger, "dog logging over lazy {} {} {}", "example1", std::string("str1"), 4.0f);
-  LOG_INFO(logger, "quick dog lazy example {} {} {}", 3.0, 5L, 7UL);
-  LOG_INFO(logger, "over fox quick {} {} {} {} {} {} {} {} {}", 4.0f, static_cast<unsigned short>(10),
-           std::string_view("view1"), "example1", false, std::string("str1"), 6LL, 3.0, 1);
-  LOG_INFO(logger, "lazy example logging quick {} {}", std::string("str2"), 1);
-  LOG_INFO(logger, "jumps fox dog test {} {} {} {}", 3.0, "example2", 8ULL, 5L);
-  LOG_INFO(logger, "quick example logging {} {} {} {} {}", std::string_view("view2"), 3.0, 8ULL,
-           std::string("str2"), 5L);
-  LOG_INFO(logger, "lazy example test over {} {} {} {} {} {}", 8ULL, 3.0, 1,
-           std::string_view("view2"), std::string("str2"), "example1");
-  LOG_INFO(logger, "dog example jumps {} {} {} {} {} {} {} {}", static_cast<short>(9), 7UL, 8ULL,
-           "example1", 5L, "example3", 6LL, std::string("str1"));
-  LOG_INFO(logger, "test jumps logging quick {} {} {}", std::string_view("view1"), 5L, false);
-  LOG_INFO(logger, "fox jumps over {} {} {} {} {} {} {} {} {} {}", std::string("str2"),
-           static_cast<short>(9), std::string_view("view2"), 1, "example1", "example3",
-           static_cast<unsigned short>(10), 3.0, 5L, "example2");
-  LOG_INFO(logger, "dog logging jumps test {} {} {} {} {} {} {} {} {}", "example3", 8ULL,
-           "example1", 6LL, std::string("str2"), static_cast<unsigned short>(10), 2, 1, false);
-  LOG_INFO(logger, "quick fox jumps {} {} {} {} {} {} {} {}", true, 6LL, std::string_view("view1"),
-           8ULL, static_cast<unsigned short>(10), "example2", 1, 2);
-  LOG_INFO(logger, "jumps over test logging {} {} {} {} {} {}", std::string("str2"), static_cast<short>(9),
-           std::string_view("view1"), "example3", "example2", std::string_view("view2"));
-  LOG_INFO(logger, "example brown fox dog {} {} {} {} {}", 2, true, 1, 6LL, std::string("str2"));
-  LOG_INFO(logger, "jumps dog example {} {} {} {} {} {} {} {} {}", 8ULL, 2, std::string_view("view2"),
-           1, std::string("str1"), "example3", "example2", static_cast<unsigned short>(10), true);
-  LOG_INFO(logger, "example over brown {} {} {} {} {} {} {} {} {} {}", "example3",
-           std::string_view("view1"), 5L, 4.0f, std::string("str1"), 6LL, true, "example2", 2, 8ULL);
-  LOG_INFO(logger, "dog brown quick example {} {} {} {} {} {} {} {} {} {}", 7UL, "example3", true,
-           8ULL, 1, 4.0f, false, 3.0, std::string("str1"), "example1");
-  LOG_INFO(logger, "jumps lazy logging {} {} {} {} {}", 6LL, 8ULL, 7UL, std::string("str1"),
-           std::string("str2"));
-  LOG_INFO(logger, "example quick jumps {} {} {} {} {} {} {} {}", 1, 6LL, std::string_view("view2"),
-           "example1", std::string("str2"), std::string("str1"), 5L, false);
-  LOG_INFO(logger, "test dog jumps over {} {} {} {} {} {} {} {} {}", "example1",
-           std::string_view("view2"), 6LL, 8ULL, true, "example3", 2, 1, std::string("str1"));
-  LOG_INFO(logger, "brown dog fox {} {} {} {} {} {} {} {}", 2, 5L, static_cast<short>(9),
-           "example1", 3.0, "example3", false, std::string("str1"));
-  LOG_INFO(logger, "over jumps lazy {} {} {} {} {} {} {} {}", static_cast<short>(9), 2, 1, true,
-           3.0, 8ULL, 4.0f, std::string_view("view1"));
-  LOG_INFO(logger, "example brown test {} {} {} {} {} {}", 7UL, 6LL, std::string("str1"),
-           "example2", std::string_view("view1"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "jumps brown over fox {} {}", 7UL, 1);
-  LOG_INFO(logger, "lazy example over {} {} {} {} {} {} {} {}", true, false, 6LL,
-           std::string_view("view1"), std::string("str2"), std::string_view("view2"), "example2", 3.0);
-  LOG_INFO(logger, "logging example dog fox {} {} {} {}", 1, std::string_view("view1"),
-           std::string("str2"), 4.0f);
-  LOG_INFO(logger, "fox lazy brown quick {} {} {} {} {}", 3.0, false, std::string_view("view1"),
-           "example2", true);
-  LOG_INFO(logger, "test fox dog quick {} {} {} {}", "example2", "example3", 3.0, static_cast<short>(9));
-  LOG_INFO(logger, "jumps dog test {} {} {} {} {}", 5L, 7UL, true, 1, std::string("str1"));
-  LOG_INFO(logger, "quick jumps fox lazy {} {} {} {}", false, true, std::string("str1"), "example2");
-  LOG_INFO(logger, "jumps lazy over fox {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           "example1", 1, 3.0, std::string("str1"), true, "example2", "example3", static_cast<short>(9));
-  LOG_INFO(logger, "brown fox lazy {} {} {} {} {} {}", true, static_cast<unsigned short>(10), 6LL,
-           "example3", static_cast<short>(9), std::string_view("view1"));
-  LOG_INFO(logger, "brown fox over {} {} {} {} {} {} {} {}", static_cast<short>(9), std::string("str1"),
-           std::string("str2"), 5L, 1, 6LL, std::string_view("view1"), "example1");
-  LOG_INFO(logger, "logging dog over brown {} {} {} {} {} {} {}", "example1", 2, "example2",
-           std::string("str2"), 3.0, 4.0f, 8ULL);
-  LOG_INFO(logger, "lazy fox logging {}", 7UL);
-  LOG_INFO(logger, "quick example logging {} {} {}", false, std::string("str1"), std::string_view("view1"));
-  LOG_INFO(logger, "quick dog test {} {} {} {}", "example3", 1, 3.0, 7UL);
-  LOG_INFO(logger, "example lazy logging {} {} {} {} {} {} {} {}", 1, static_cast<short>(9),
-           "example2", static_cast<unsigned short>(10), 3.0, 2, "example3", 8ULL);
-  LOG_INFO(logger, "dog fox example {} {}", static_cast<unsigned short>(10), "example1");
-  LOG_INFO(logger, "lazy example jumps brown {} {} {} {}", 5L, "example2", 6LL, 3.0);
-  LOG_INFO(logger, "jumps lazy quick {} {} {} {} {} {} {} {} {}", 5L, 6LL, 8ULL,
-           std::string("str1"), static_cast<unsigned short>(10), std::string_view("view2"),
-           std::string("str2"), "example3", 4.0f);
-  LOG_INFO(logger, "over test quick {} {} {}", std::string("str1"), std::string_view("view2"),
-           "example3");
-  LOG_INFO(logger, "example test brown over {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           8ULL, std::string_view("view1"), 6LL, static_cast<short>(9), "example1", 5L, true);
-  LOG_INFO(logger, "dog logging example {}", 4.0f);
-  LOG_INFO(logger, "example jumps dog over {} {} {} {} {} {} {} {}", "example1", "example2", true,
-           6LL, std::string_view("view2"), 2, false, std::string("str1"));
-  LOG_INFO(logger, "test example dog jumps {} {} {} {} {} {} {}", 1, std::string_view("view1"), 2,
-           "example1", static_cast<short>(9), 3.0, 6LL);
-  LOG_INFO(logger, "jumps fox dog {} {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           std::string_view("view1"), "example3", 6LL, 5L, 2, true, 4.0f, 1, "example2");
-  LOG_INFO(logger, "fox quick over jumps {} {} {} {} {} {} {} {}", 7UL, 2, "example3", "example1",
-           true, std::string_view("view1"), 5L, 1);
-  LOG_INFO(logger, "test quick logging brown {} {}", true, "example2");
-  LOG_INFO(logger, "quick jumps logging {} {} {} {} {}", 1, 7UL, 6LL, 3.0, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "test logging fox quick {} {} {} {} {} {} {}", 3.0, std::string_view("view2"),
-           std::string("str1"), 4.0f, 8ULL, false, 2);
-  LOG_INFO(logger, "example quick logging brown {} {} {} {} {} {} {} {} {} {}", 3.0, 8ULL, std::string("str2"),
-           4.0f, false, true, 6LL, static_cast<unsigned short>(10), "example1", std::string("str1"));
-  LOG_INFO(logger, "jumps logging quick {} {}", std::string("str1"), 8ULL);
-  LOG_INFO(logger, "fox example lazy {} {} {} {} {} {}", std::string_view("view2"), 8ULL, 6LL, 4.0f,
-           true, "example2");
-  LOG_INFO(logger, "over example logging {} {} {}", std::string("str1"), "example1", "example3");
-  LOG_INFO(logger, "fox brown lazy over {} {} {} {} {} {} {}", 1, static_cast<short>(9), 4.0f,
-           std::string("str2"), 6LL, 5L, "example1");
-  LOG_INFO(logger, "jumps logging quick {} {} {} {} {} {} {} {} {} {}",
-           static_cast<unsigned short>(10), std::string_view("view1"), std::string_view("view2"),
-           5L, true, std::string("str2"), 4.0f, 8ULL, 3.0, "example2");
-  LOG_INFO(logger, "over logging example {} {} {} {} {} {} {} {} {} {}", std::string("str1"), 3.0,
-           2, false, 8ULL, 4.0f, 1, 6LL, std::string_view("view2"), std::string("str2"));
-  LOG_INFO(logger, "logging brown test fox {} {} {} {}", std::string("str2"), 3.0, std::string("str1"), 1);
-  LOG_INFO(logger, "example dog brown jumps {} {} {} {}", 1, "example2", 5L, false);
-  LOG_INFO(logger, "logging jumps example fox {} {} {} {} {} {} {}", 3.0, std::string_view("view2"),
-           true, static_cast<unsigned short>(10), 5L, std::string_view("view1"), std::string("str1"));
-  LOG_INFO(logger, "fox brown lazy test {} {}", 2, 8ULL);
-  LOG_INFO(logger, "dog brown lazy fox {} {} {} {} {} {} {} {}", std::string_view("view2"), 1, 4.0f,
-           true, 7UL, "example3", 6LL, 5L);
-  LOG_INFO(logger, "lazy test dog {}", 3.0);
-  LOG_INFO(logger, "brown example jumps {}", 4.0f);
-  LOG_INFO(logger, "quick logging fox jumps {} {} {} {} {} {} {} {} {} {}", 1,
-           static_cast<short>(9), std::string_view("view1"), std::string_view("view2"), true, 6LL,
-           false, std::string("str1"), 2, 7UL);
-  LOG_INFO(logger, "brown jumps test {}", 3.0);
-  LOG_INFO(logger, "jumps lazy quick {} {} {} {} {} {} {}", 8ULL, true, std::string_view("view1"),
-           false, std::string("str1"), "example1", std::string("str2"));
-  LOG_INFO(logger, "example logging quick over {} {} {} {}", std::string("str1"), 1, "example1", true);
-  LOG_INFO(logger, "example logging lazy over {} {} {} {} {} {} {} {} {}", "example2", 3.0,
-           std::string_view("view2"), static_cast<short>(9), "example3", 2, std::string("str1"),
-           false, std::string_view("view1"));
-  LOG_INFO(logger, "dog fox example quick {} {} {}", std::string("str2"), true, static_cast<short>(9));
-  LOG_INFO(logger, "test quick example fox {} {} {} {} {}", true, 2, 5L, "example3", 1);
-  LOG_INFO(logger, "quick over jumps fox {} {} {} {} {}", 6LL, 8ULL, 4.0f, true, 5L);
-  LOG_INFO(logger, "example fox logging jumps {} {}", 6LL, 3.0);
-  LOG_INFO(logger, "quick jumps dog {} {} {}", 6LL, std::string_view("view2"), false);
-  LOG_INFO(logger, "lazy example quick {} {} {} {} {} {}", std::string("str2"),
-           static_cast<short>(9), std::string("str1"), 6LL, true, 8ULL);
-  LOG_INFO(logger, "example logging over {} {} {} {} {}", std::string("str1"), 2,
-           static_cast<short>(9), std::string_view("view2"), false);
-  LOG_INFO(logger, "test quick example {} {} {} {} {} {} {}", static_cast<unsigned short>(10), 6LL,
-           static_cast<short>(9), false, std::string_view("view2"), 8ULL, "example1");
-  LOG_INFO(logger, "quick brown logging dog {} {} {} {} {} {} {}", 4.0f, 1, 2,
-           std::string_view("view2"), 8ULL, static_cast<short>(9), 7UL);
-  LOG_INFO(logger, "logging lazy jumps {} {} {} {} {} {} {} {}", "example1", 5L,
-           static_cast<unsigned short>(10), std::string("str2"), true, std::string_view("view2"), 4.0f, false);
-  LOG_INFO(logger, "over quick fox dog {} {} {} {} {} {} {} {} {}", 3.0, 1, false, 5L, 4.0f, 6LL,
-           static_cast<short>(9), std::string_view("view2"), std::string_view("view1"));
-  LOG_INFO(logger, "brown fox test example {} {} {} {} {} {} {} {} {} {}", std::string("str2"),
-           true, static_cast<unsigned short>(10), std::string_view("view1"), 5L, "example2", false,
-           3.0, 1, std::string_view("view2"));
-  LOG_INFO(logger, "example lazy jumps fox {} {} {} {} {} {}", 7UL, false,
-           std::string_view("view1"), 6LL, "example2", 5L);
-  LOG_INFO(logger, "fox jumps over test {} {}", "example2", "example1");
-  LOG_INFO(logger, "jumps dog logging {}", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox test jumps {} {} {} {} {} {} {} {}", true, std::string_view("view2"),
-           std::string("str1"), 4.0f, 2, 6LL, std::string_view("view1"), std::string("str2"));
-  LOG_INFO(logger, "over quick brown {} {} {} {} {} {} {} {} {} {}", false, 8ULL, "example2",
-           "example3", "example1", std::string("str2"), static_cast<unsigned short>(10), 4.0f, 5L,
-           std::string("str1"));
-  LOG_INFO(logger, "quick brown fox example {} {} {} {} {} {}", "example1", false,
-           static_cast<short>(9), std::string("str1"), "example2", 4.0f);
-  LOG_INFO(logger, "test logging jumps quick {} {} {} {} {} {}", 4.0f, true,
-           std::string_view("view1"), "example1", 5L, 7UL);
-  LOG_INFO(logger, "test lazy example {} {}", 2, std::string("str2"));
-  LOG_INFO(logger, "quick over dog logging {} {} {} {} {} {} {} {} {} {}", 8ULL, std::string_view("view1"),
-           true, 6LL, "example2", 4.0f, "example1", static_cast<unsigned short>(10), "example3", 7UL);
-  LOG_INFO(logger, "lazy jumps quick dog {} {} {}", std::string("str1"), "example2", false);
-  LOG_INFO(logger, "test brown logging example {} {}", std::string_view("view2"), 6LL);
-  LOG_INFO(logger, "over lazy dog jumps {} {} {} {} {} {}", std::string("str1"), 1, 4.0f, 6LL, 2,
-           "example3");
-  LOG_INFO(logger, "lazy over fox {} {}", std::string_view("view2"), std::string_view("view1"));
-  LOG_INFO(logger, "brown dog lazy over {} {} {} {} {} {} {} {} {} {}", "example1", "example2", 7UL,
-           static_cast<unsigned short>(10), 4.0f, false, 1, "example3", 2, std::string_view("view1"));
-  LOG_INFO(logger, "jumps example over {} {} {} {}", 8ULL, static_cast<unsigned short>(10),
-           "example1", std::string_view("view1"));
-  LOG_INFO(logger, "test jumps over lazy {} {} {} {}", std::string("str2"), 2, 8ULL, std::string("str1"));
-  LOG_INFO(logger, "logging example over {} {}", std::string("str2"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "jumps lazy fox {} {} {} {} {} {}", 3.0, false, 5L, static_cast<short>(9),
-           "example1", std::string("str2"));
-  LOG_INFO(logger, "dog example quick brown {} {} {} {} {} {} {} {}", 5L, static_cast<short>(9),
-           "example3", true, false, std::string_view("view2"), 7UL, 8ULL);
-  LOG_INFO(logger, "dog over quick {} {} {} {} {} {}", static_cast<short>(9),
-           static_cast<unsigned short>(10), "example2", 5L, "example3", 2);
-  LOG_INFO(logger, "example test jumps {} {} {} {} {} {} {} {} {}", 8ULL, false,
-           std::string_view("view2"), true, "example3", "example1", static_cast<unsigned short>(10),
-           std::string_view("view1"), "example2");
-  LOG_INFO(logger, "example brown jumps quick {} {} {} {}", "example1", std::string("str1"),
-           static_cast<short>(9), 8ULL);
-  LOG_INFO(logger, "jumps lazy dog {} {} {} {}", std::string_view("view2"), "example3",
-           std::string("str2"), 3.0);
-  LOG_INFO(logger, "dog lazy brown {} {}", 6LL, std::string("str1"));
-  LOG_INFO(logger, "test quick dog {} {} {} {} {} {} {}", "example2", std::string_view("view2"),
-           6LL, static_cast<short>(9), 1, std::string("str2"), 3.0);
-  LOG_INFO(logger, "quick fox lazy over {} {} {} {} {} {} {} {}", 4.0f, false,
-           std::string_view("view1"), 3.0, 8ULL, "example3", 6LL, "example2");
-  LOG_INFO(logger, "brown fox jumps {}", "example3");
-  LOG_INFO(logger, "logging quick fox {} {} {} {} {} {}", 1, std::string_view("view1"),
-           std::string("str2"), 5L, false, 6LL);
-  LOG_INFO(logger, "test dog over {}", 7UL);
-  LOG_INFO(logger, "fox test lazy {} {} {} {} {} {} {} {} {}", 3.0, true, 6LL, std::string_view("view2"),
-           "example2", static_cast<short>(9), std::string_view("view1"), "example1", 4.0f);
-  LOG_INFO(logger, "example fox quick {} {} {} {} {} {} {}", 5L, 7UL, std::string_view("view1"),
-           "example3", "example2", "example1", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "dog lazy jumps {} {} {} {} {} {} {} {} {}", true, std::string_view("view1"),
-           7UL, 8ULL, static_cast<unsigned short>(10), 1, 4.0f, 6LL, std::string("str2"));
-  LOG_INFO(logger, "logging example lazy test {}", true);
-  LOG_INFO(logger, "over quick test jumps {} {} {} {}", std::string("str2"), true, std::string("str1"), 3.0);
-  LOG_INFO(logger, "quick example over brown {} {} {} {} {} {} {} {}", "example3", false,
-           std::string_view("view2"), static_cast<unsigned short>(10), 2, static_cast<short>(9), 5L, 7UL);
-  LOG_INFO(logger, "example test dog {} {}", 3.0, "example2");
-  LOG_INFO(logger, "jumps dog brown logging {} {} {} {}", std::string("str2"), std::string("str1"),
-           "example3", "example1");
-  LOG_INFO(logger, "over logging lazy test {} {} {} {} {} {} {}", 6LL, true, std::string("str1"),
-           "example2", std::string_view("view2"), 4.0f, "example1");
-  LOG_INFO(logger, "dog quick lazy test {} {} {} {} {} {} {} {} {}", 2, "example2", "example3",
-           std::string("str1"), static_cast<short>(9), 4.0f, "example1", 6LL, 5L);
-  LOG_INFO(logger, "example test brown {} {} {}", 4.0f, "example1", 8ULL);
-  LOG_INFO(logger, "lazy over brown jumps {} {} {} {} {} {} {}", std::string("str1"), 8ULL, 5L, 3.0,
-           "example3", "example2", "example1");
-  LOG_INFO(logger, "fox quick jumps dog {} {} {} {} {} {}", 4.0f, "example1", true,
-           std::string("str1"), std::string_view("view1"), 3.0);
-  LOG_INFO(logger, "dog test jumps over {} {} {} {} {} {} {}", std::string_view("view1"), 4.0f,
-           static_cast<short>(9), 1, std::string_view("view2"), static_cast<unsigned short>(10), false);
-  LOG_INFO(logger, "lazy quick test {} {} {} {}", 1, static_cast<short>(9), 3.0, std::string("str2"));
-  LOG_INFO(logger, "jumps brown fox {} {} {} {} {} {}", std::string("str1"),
-           static_cast<unsigned short>(10), 8ULL, "example1", std::string("str2"), 1);
-  LOG_INFO(logger, "test jumps quick {} {} {} {} {} {}", "example2", 1, 2, std::string_view("view2"), 8ULL, true);
-  LOG_INFO(logger, "fox over example quick {}", std::string("str2"));
-  LOG_INFO(logger, "over dog test {} {} {} {} {} {} {} {} {} {}", false, 3.0, "example1",
-           std::string("str1"), std::string("str2"), 2, "example2", "example3", static_cast<short>(9), 1);
-  LOG_INFO(logger, "example logging dog {}", "example1");
-  LOG_INFO(logger, "test logging jumps {} {} {} {} {} {} {} {}", 1, "example3", std::string("str1"),
-           6LL, 3.0, "example1", 7UL, 5L);
-  LOG_INFO(logger, "fox example jumps quick {} {} {} {} {} {} {} {} {} {}", 5L, std::string("str1"),
-           false, 3.0, 2, 6LL, 7UL, true, "example3", std::string_view("view2"));
-  LOG_INFO(logger, "fox lazy example test {} {}", true, 5L);
-  LOG_INFO(logger, "example brown dog jumps {}", 4.0f);
-  LOG_INFO(logger, "dog jumps fox {} {} {} {} {} {}", 8ULL, "example2", std::string_view("view2"),
-           "example3", std::string("str2"), 3.0);
-  LOG_INFO(logger, "quick lazy example logging {}", std::string_view("view2"));
-  LOG_INFO(logger, "dog brown over {} {}", std::string_view("view2"), "example3");
-  LOG_INFO(logger, "jumps brown over {} {}", "example2", "example3");
-  LOG_INFO(logger, "test over quick {} {} {} {}", 4.0f, std::string("str2"), 8ULL, 5L);
-  LOG_INFO(logger, "quick jumps brown example {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           std::string("str1"), 1, 8ULL, "example2", 4.0f, static_cast<short>(9));
-  LOG_INFO(logger, "over jumps dog {} {} {} {} {} {} {} {} {} {}", "example2",
-           static_cast<unsigned short>(10), "example1", 4.0f, std::string_view("view1"), 3.0,
-           std::string("str2"), 5L, false, "example3");
-  LOG_INFO(logger, "fox jumps quick {} {} {} {} {} {} {} {}", true, 1, std::string_view("view2"),
-           std::string_view("view1"), std::string("str1"), 5L, static_cast<unsigned short>(10),
-           "example1");
-  LOG_INFO(logger, "fox logging lazy {} {} {} {} {}", 2, 4.0f, std::string("str2"),
-           std::string_view("view2"), 3.0);
-  LOG_INFO(logger, "logging fox jumps {} {} {} {}", std::string_view("view2"), 4.0f,
-           std::string_view("view1"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox brown dog test {} {}", 2, 7UL);
-  LOG_INFO(logger, "lazy dog jumps brown {} {} {}", std::string_view("view2"), 3.0, "example1");
-  LOG_INFO(logger, "fox dog test jumps {} {} {} {}", 6LL, static_cast<short>(9),
-           static_cast<unsigned short>(10), 8ULL);
-  LOG_INFO(logger, "quick brown logging over {}", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "logging dog jumps {}", "example2");
-  LOG_INFO(logger, "quick jumps example {} {} {} {} {} {} {} {} {} {}", 8ULL, 2, static_cast<short>(9),
-           "example2", 6LL, std::string_view("view1"), "example3", true, 5L, 4.0f);
-  LOG_INFO(logger, "brown over quick logging {} {} {} {} {}", false, 7UL, "example3", true,
-           std::string_view("view1"));
-  LOG_INFO(logger, "jumps example fox {}", 1);
-  LOG_INFO(logger, "over example jumps quick {} {} {}", 1, 2, std::string("str1"));
-  LOG_INFO(logger, "test over dog quick {}", "example3");
-  LOG_INFO(logger, "over quick logging {} {} {}", false, 4.0f, 3.0);
-  LOG_INFO(logger, "fox test example jumps {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           8ULL, 2, "example2", std::string_view("view1"), std::string("str1"), static_cast<short>(9));
-  LOG_INFO(logger, "brown jumps example logging {} {} {} {}", static_cast<short>(9),
-           static_cast<unsigned short>(10), 3.0, "example3");
-  LOG_INFO(logger, "over fox lazy {}", 6LL);
-  LOG_INFO(logger, "test fox example {} {} {} {} {} {} {} {}", 2, true, std::string_view("view2"),
-           static_cast<short>(9), std::string("str1"), 4.0f, "example1", std::string_view("view1"));
-  LOG_INFO(logger, "dog over test {} {} {} {} {}", 5L, false, 3.0, 7UL, 8ULL);
-  LOG_INFO(logger, "over jumps logging example {} {} {} {} {} {} {} {} {} {}",
-           static_cast<unsigned short>(10), "example3", std::string("str2"), true,
-           std::string("str1"), "example1", false, 6LL, 1, "example2");
-  LOG_INFO(logger, "logging test fox over {} {} {} {} {} {} {} {} {}", false, true,
-           static_cast<short>(9), 3.0, 4.0f, 5L, 8ULL, 6LL, 1);
-  LOG_INFO(logger, "logging lazy example {} {} {} {} {} {} {} {} {} {}", 8ULL, "example2",
-           std::string_view("view1"), 7UL, 6LL, static_cast<unsigned short>(10), "example3", false,
-           3.0, "example1");
-  LOG_INFO(logger, "dog brown example {}", "example1");
-  LOG_INFO(logger, "logging dog example fox {} {} {} {} {} {} {} {} {}", "example2", 4.0f,
-           "example1", true, 5L, static_cast<short>(9), 7UL, "example3", std::string_view("view1"));
-  LOG_INFO(logger, "fox dog test {} {} {} {} {} {}", false, static_cast<unsigned short>(10),
-           std::string_view("view1"), static_cast<short>(9), 7UL, "example1");
-  LOG_INFO(logger, "fox brown example {} {} {} {} {}", static_cast<short>(9), "example3", 6LL,
-           std::string("str1"), "example1");
-  LOG_INFO(logger, "fox dog example {}", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox quick lazy {} {} {} {} {} {} {}", std::string_view("view2"), 1,
-           std::string("str2"), "example2", 3.0, static_cast<short>(9), 6LL);
-  LOG_INFO(logger, "dog test example logging {} {}", std::string_view("view1"), 8ULL);
-  LOG_INFO(logger, "lazy quick over {}", true);
-  LOG_INFO(logger, "over fox test {} {} {}", std::string_view("view2"), false, 1);
-  LOG_INFO(logger, "lazy jumps over dog {}", 2);
-  LOG_INFO(logger, "example fox brown over {} {} {} {} {}", "example1", 8ULL, "example2", 5L, 3.0);
-  LOG_INFO(logger, "dog brown over fox {} {} {} {}", static_cast<unsigned short>(10), "example2",
-           6LL, "example3");
-  LOG_INFO(logger, "quick lazy over {} {} {} {} {} {}", 6LL, "example3",
-           static_cast<unsigned short>(10), 5L, std::string_view("view1"), 7UL);
-  LOG_INFO(logger, "over example fox quick {} {}", true, 4.0f);
-  LOG_INFO(logger, "logging over jumps brown {} {} {} {} {} {} {} {} {} {}", "example3", 5L,
-           std::string_view("view1"), 8ULL, static_cast<unsigned short>(10), 7UL,
-           std::string("str1"), 1, static_cast<short>(9), true);
-  LOG_INFO(logger, "lazy quick dog {} {} {} {} {} {} {}", 4.0f, "example2", "example1", 2,
-           std::string("str1"), true, 3.0);
-  LOG_INFO(logger, "dog example brown {} {} {} {} {} {} {}", 2, 7UL,
-           static_cast<unsigned short>(10), 4.0f, std::string_view("view2"), "example3", "example1");
-  LOG_INFO(logger, "jumps dog fox test {}", std::string_view("view2"));
-  LOG_INFO(logger, "jumps dog quick fox {} {} {} {} {} {}", false, std::string_view("view1"),
-           static_cast<short>(9), 8ULL, 4.0f, 5L);
-  LOG_INFO(logger, "fox lazy test jumps {} {} {} {} {} {} {} {} {}", 7UL, std::string("str2"),
-           std::string_view("view1"), std::string("str1"), 4.0f, static_cast<short>(9), "example2", 3.0, 2);
-  LOG_INFO(logger, "test logging over fox {} {} {}", "example2", false, 8ULL);
-  LOG_INFO(logger, "example quick brown lazy {} {} {} {} {} {} {} {}", 7UL, std::string("str2"), 5L,
-           true, std::string_view("view1"), "example2", 2, 6LL);
-  LOG_INFO(logger, "dog quick jumps {} {} {} {}", 5L, "example3", 1, std::string("str2"));
-  LOG_INFO(logger, "dog fox lazy {}", false);
-  LOG_INFO(logger, "logging fox quick {} {} {} {} {} {} {} {} {} {}", 1, std::string("str2"), 4.0f,
-           7UL, static_cast<unsigned short>(10), std::string_view("view1"), static_cast<short>(9),
-           std::string("str1"), "example2", 5L);
-  LOG_INFO(logger, "lazy quick example test {} {} {} {} {} {} {} {}", 5L, "example3", false,
-           std::string_view("view2"), static_cast<unsigned short>(10), 4.0f, "example1", 2);
-  LOG_INFO(logger, "jumps quick dog {} {} {} {} {}", 5L, "example3", std::string("str1"), true, 7UL);
-  LOG_INFO(logger, "example jumps logging {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           3.0, false, 2, std::string_view("view1"), "example1", std::string_view("view2"), 8ULL, 6LL);
-  LOG_INFO(logger, "brown example test {} {} {} {} {} {}", 6LL, static_cast<unsigned short>(10),
-           3.0, "example1", 4.0f, 7UL);
-  LOG_INFO(logger, "brown jumps dog lazy {}", 2);
-  LOG_INFO(logger, "test quick logging brown {} {} {} {} {}", 5L, "example3", 8ULL, true, 4.0f);
-  LOG_INFO(logger, "fox logging brown {} {} {} {} {} {}", std::string_view("view1"), "example2",
-           true, std::string("str2"), 2, 5L);
-  LOG_INFO(logger, "test lazy quick over {} {} {} {}", 7UL, 5L, static_cast<unsigned short>(10),
-           std::string_view("view1"));
-  LOG_INFO(logger, "test over brown {} {} {} {} {} {} {} {}", std::string("str2"), false, 8ULL, 2,
-           true, "example3", 1, std::string_view("view1"));
-  LOG_INFO(logger, "jumps brown fox logging {} {} {} {} {} {} {} {} {}", false, true, 6LL,
-           static_cast<short>(9), 2, 4.0f, std::string("str1"), 7UL, "example2");
-  LOG_INFO(logger, "logging test over {} {} {} {}", std::string("str2"), "example1", 5L, 3.0);
-  LOG_INFO(logger, "lazy test jumps {} {} {}", 2, "example1", std::string("str2"));
-  LOG_INFO(logger, "quick jumps fox test {} {}", 1, std::string("str2"));
-  LOG_INFO(logger, "example logging over jumps {} {}", 7UL, 6LL);
-  LOG_INFO(logger, "over fox test {} {} {} {} {} {} {} {} {}", 8ULL, static_cast<short>(9), 1,
-           std::string_view("view1"), "example1", 7UL, "example3", 3.0, 6LL);
-  LOG_INFO(logger, "test lazy dog {} {} {}", 2, 3.0, std::string_view("view2"));
-  LOG_INFO(logger, "quick test logging lazy {} {}", std::string_view("view2"), "example3");
-  LOG_INFO(logger, "quick fox test brown {} {} {} {} {} {} {} {} {}", 7UL, 1,
-           static_cast<unsigned short>(10), 8ULL, false, std::string_view("view2"), 3.0, "example2",
-           std::string_view("view1"));
-  LOG_INFO(logger, "lazy over jumps {}", std::string("str2"));
-  LOG_INFO(logger, "test dog lazy {} {}", std::string_view("view1"), false);
-  LOG_INFO(logger, "jumps over quick {} {} {} {} {} {} {} {}", 7UL, 1, std::string_view("view2"),
-           "example2", 4.0f, true, static_cast<short>(9), "example3");
-  LOG_INFO(logger, "logging brown jumps {} {} {} {} {} {} {} {}", std::string("str2"), false,
-           std::string("str1"), "example3", 4.0f, 6LL, 8ULL, 5L);
-  LOG_INFO(logger, "brown jumps quick over {} {} {} {} {}", 8ULL, 5L, "example2",
-           static_cast<unsigned short>(10), std::string_view("view1"));
-  LOG_INFO(logger, "brown fox example logging {} {} {} {} {} {}", 3.0, std::string_view("view1"),
-           6LL, "example2", 8ULL, 7UL);
-  LOG_INFO(logger, "dog test fox {} {} {} {} {} {}", 1, static_cast<unsigned short>(10),
-           static_cast<short>(9), 2, 5L, true);
-  LOG_INFO(logger, "dog logging quick {} {}", std::string("str2"), 7UL);
-  LOG_INFO(logger, "jumps brown quick logging {} {} {} {} {} {}", std::string("str2"), 7UL,
-           static_cast<unsigned short>(10), 4.0f, 5L, false);
-  LOG_INFO(logger, "dog logging jumps {} {} {} {} {} {} {} {} {} {}", std::string("str2"), 2,
-           "example1", "example3", std::string("str1"), false, static_cast<short>(9),
-           std::string_view("view2"), std::string_view("view1"), 5L);
-  LOG_INFO(logger, "fox over lazy {} {} {} {} {} {}", 1, std::string_view("view2"), 3.0, "example1",
-           std::string_view("view1"), "example3");
-  LOG_INFO(logger, "dog lazy quick fox {} {} {} {}", std::string_view("view2"), 4.0f, "example3", 2);
-  LOG_INFO(logger, "fox lazy dog {} {} {} {} {} {} {} {} {} {}", "example1", 6LL, 3.0, false,
-           "example2", std::string("str2"), std::string_view("view1"), true, 8ULL,
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox over jumps {} {}", 6LL, std::string("str2"));
-  LOG_INFO(logger, "test logging jumps {} {} {} {} {} {} {} {}", "example1", static_cast<short>(9), 7UL,
-           std::string("str2"), std::string_view("view2"), false, static_cast<unsigned short>(10), 3.0);
-  LOG_INFO(logger, "test logging lazy example {} {} {} {}", 7UL, 5L, 2, false);
-  LOG_INFO(logger, "logging dog lazy {} {} {} {} {} {} {} {} {} {}", "example2", 2, true,
-           "example1", static_cast<short>(9), 4.0f, 5L, 1, "example3", 6LL);
-  LOG_INFO(logger, "brown over fox {} {} {} {}", std::string_view("view1"),
-           std::string_view("view2"), 8ULL, std::string("str2"));
-  LOG_INFO(logger, "jumps logging lazy {} {} {} {} {} {} {}", std::string("str2"),
-           std::string_view("view1"), 7UL, 1, 8ULL, 3.0, std::string("str1"));
-  LOG_INFO(logger, "fox brown dog logging {}", false);
-  LOG_INFO(logger, "brown over fox {} {} {} {} {} {} {} {} {}", 8ULL, static_cast<short>(9), 2, 6LL,
-           std::string_view("view1"), false, 7UL, 3.0, 1);
-  LOG_INFO(logger, "test over dog {} {} {} {}", 5L, std::string_view("view1"), 7UL, std::string_view("view2"));
-  LOG_INFO(logger, "dog brown jumps {} {} {}", static_cast<short>(9), static_cast<unsigned short>(10), 8ULL);
-  LOG_INFO(logger, "logging brown fox over {} {} {}", false, 8ULL, std::string_view("view1"));
-  LOG_INFO(logger, "logging over brown example {} {} {} {} {} {} {} {}", 2, 1, std::string_view("view1"),
-           3.0, std::string_view("view2"), static_cast<short>(9), std::string("str1"), 5L);
-  LOG_INFO(logger, "lazy jumps logging test {} {} {} {} {}", "example2", false, std::string("str1"),
-           "example3", 2);
-  LOG_INFO(logger, "brown example lazy {} {}", std::string_view("view1"), static_cast<short>(9));
-  LOG_INFO(logger, "example brown quick logging {} {} {} {} {} {}", 4.0f, "example2", 3.0, 1, false,
-           std::string("str1"));
-  LOG_INFO(logger, "over dog test {} {} {} {} {} {} {}", 4.0f, "example1", 7UL, 5L,
-           std::string("str2"), std::string_view("view1"), false);
-  LOG_INFO(logger, "quick lazy jumps {} {} {} {} {} {} {} {}", 6LL, 5L, "example1", 2, "example2",
-           7UL, std::string_view("view1"), static_cast<short>(9));
-  LOG_INFO(logger, "brown logging quick {} {} {} {} {} {} {} {} {}", std::string("str2"),
-           std::string_view("view1"), std::string_view("view2"), "example3", false, 6LL, 4.0f, true, 5L);
-  LOG_INFO(logger, "quick logging jumps {} {} {} {} {} {} {} {} {} {}", "example2", std::string_view("view2"),
-           true, 6LL, 8ULL, static_cast<short>(9), 4.0f, 3.0, std::string("str1"), "example1");
-  LOG_INFO(logger, "lazy jumps quick fox {} {}", 8ULL, std::string_view("view2"));
-  LOG_INFO(logger, "over fox jumps {} {} {} {} {}", std::string_view("view1"),
-           static_cast<unsigned short>(10), static_cast<short>(9), "example1", true);
-  LOG_INFO(logger, "dog over lazy {} {} {} {} {}", 1, static_cast<short>(9), std::string("str1"), true, 3.0);
-  LOG_INFO(logger, "jumps quick fox example {} {} {} {} {} {}", std::string("str1"), 8ULL, true,
-           false, "example3", static_cast<short>(9));
-  LOG_INFO(logger, "quick lazy test brown {} {} {} {}", "example2", true, 1, "example1");
-  LOG_INFO(logger, "dog logging jumps {} {} {} {} {} {} {} {} {}", std::string("str1"),
-           static_cast<short>(9), std::string("str2"), std::string_view("view2"), 4.0f, false,
-           "example2", static_cast<unsigned short>(10), 1);
-  LOG_INFO(logger, "lazy dog fox example {} {} {} {} {} {} {} {} {}", 2, "example1",
-           static_cast<short>(9), true, "example2", false, std::string_view("view1"), 8ULL, 4.0f);
-  LOG_INFO(logger, "quick test lazy {} {} {} {} {} {} {} {} {}", false, std::string("str2"), 1, 2,
-           std::string_view("view1"), 8ULL, "example2", "example3", 5L);
-  LOG_INFO(logger, "brown lazy test over {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           5L, static_cast<short>(9), 8ULL, 7UL, 1, 6LL, "example3", 2);
-  LOG_INFO(logger, "dog jumps fox {} {} {} {} {} {} {} {}", 7UL, 8ULL, false, std::string("str2"),
-           std::string_view("view2"), true, "example2", std::string("str1"));
-  LOG_INFO(logger, "lazy jumps over {} {} {} {} {} {} {}", "example1", std::string_view("view1"),
-           5L, static_cast<unsigned short>(10), 2, std::string("str1"), true);
-  LOG_INFO(logger, "dog brown test {} {} {} {} {} {} {} {} {}", 2, std::string("str2"),
-           std::string_view("view2"), 6LL, static_cast<short>(9), std::string("str1"), "example3", 5L, true);
-  LOG_INFO(logger, "test jumps logging brown {} {} {} {} {} {} {} {}", "example2", 3.0, 6LL, true,
-           5L, 2, 4.0f, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown lazy logging {} {} {} {} {} {}", "example3", 2, false, true, 4.0f,
-           "example2");
-  LOG_INFO(logger, "logging example lazy brown {} {}", 5L, std::string("str1"));
-  LOG_INFO(logger, "jumps example lazy logging {}", 8ULL);
-  LOG_INFO(logger, "logging test brown {} {} {} {} {} {} {} {} {} {}", std::string("str2"), 6LL,
-           "example1", 8ULL, 1, 3.0, std::string_view("view1"), std::string_view("view2"),
-           "example3", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "example lazy jumps {} {} {}", "example1", static_cast<unsigned short>(10),
-           static_cast<short>(9));
-  LOG_INFO(logger, "dog test fox logging {} {} {} {} {} {}", 6LL, std::string_view("view1"), true,
-           5L, 8ULL, 7UL);
-  LOG_INFO(logger, "brown over fox dog {} {} {} {} {} {} {}", 6LL, "example3", 4.0f, "example1", 3.0, true, 1);
-  LOG_INFO(logger, "dog logging brown {} {} {} {} {} {} {} {} {}", 3.0, true, std::string("str1"),
-           static_cast<short>(9), 1, 2, 6LL, 5L, "example2");
-  LOG_INFO(logger, "logging fox dog lazy {} {} {} {} {} {}", 3.0, static_cast<short>(9),
-           std::string_view("view1"), "example1", 5L, 1);
-  LOG_INFO(logger, "fox lazy dog brown {} {} {} {} {} {} {} {}", false, 1, 8ULL, 3.0,
-           static_cast<unsigned short>(10), true, "example2", 4.0f);
-  LOG_INFO(logger, "quick test dog brown {} {} {}", true, std::string("str2"),
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "jumps logging brown {} {} {} {} {} {}", false, 4.0f, std::string_view("view1"),
-           std::string("str1"), 5L, "example1");
-  LOG_INFO(logger, "dog fox brown jumps {} {} {} {} {} {} {} {}", std::string_view("view2"), 5L,
-           static_cast<short>(9), std::string("str1"), 8ULL, 4.0f, std::string_view("view1"),
-           std::string("str2"));
-  LOG_INFO(logger, "lazy over fox logging {} {} {} {} {} {}", std::string_view("view2"), 5L, 1, 4.0f, 8ULL, true);
-  LOG_INFO(logger, "over quick example {} {} {} {} {} {} {}", static_cast<unsigned short>(10), 1,
-           "example1", 7UL, "example2", true, 5L);
-  LOG_INFO(logger, "dog example over {} {} {} {}", 5L, 3.0, 7UL, 1);
-  LOG_INFO(logger, "dog example fox {} {} {} {}", "example1", 3.0, static_cast<unsigned short>(10), 1);
-  LOG_INFO(logger, "quick fox dog {}", 2);
-  LOG_INFO(logger, "fox logging example {} {} {} {}", std::string("str1"), "example1", true, false);
-  LOG_INFO(logger, "brown fox example {} {} {} {} {} {} {}", static_cast<short>(9), 7UL, "example3",
-           8ULL, 6LL, false, std::string_view("view1"));
-  LOG_INFO(logger, "jumps logging dog {} {} {}", std::string("str2"), std::string_view("view1"),
-           std::string("str1"));
-  LOG_INFO(logger, "logging lazy dog {} {} {} {} {}", 6LL, 5L, static_cast<unsigned short>(10),
-           std::string("str1"), "example2");
-  LOG_INFO(logger, "test fox logging {}", 7UL);
-  LOG_INFO(logger, "logging lazy quick {} {}", 2, static_cast<short>(9));
-  LOG_INFO(logger, "brown over example test {} {} {} {} {} {} {} {} {}", std::string("str2"), 6LL,
-           "example1", 4.0f, std::string("str1"), false, 1, 3.0, 2);
-  LOG_INFO(logger, "brown over example {} {} {} {} {} {} {} {} {} {}", 1, 5L,
-           std::string_view("view1"), std::string("str1"), static_cast<short>(9), 3.0, "example2",
-           static_cast<unsigned short>(10), "example1", 4.0f);
-  LOG_INFO(logger, "test quick fox lazy {} {} {} {} {} {} {}", false,
-           static_cast<unsigned short>(10), std::string("str2"), 3.0, 2, true, 1);
-  LOG_INFO(logger, "brown logging dog example {} {} {} {} {} {}", 8ULL, 5L,
-           std::string_view("view1"), 4.0f, static_cast<short>(9), std::string("str2"));
-  LOG_INFO(logger, "logging brown dog {} {} {} {} {} {}", std::string("str1"),
-           std::string_view("view1"), std::string_view("view2"), "example3", true, 2);
-  LOG_INFO(logger, "quick fox lazy {}", 8ULL);
-  LOG_INFO(logger, "test logging example brown {} {} {} {} {}", "example2", false,
-           static_cast<unsigned short>(10), 2, true);
-  LOG_INFO(logger, "brown jumps fox {} {} {} {} {} {} {} {} {} {}", 4.0f, 8ULL, 2, std::string_view("view2"),
-           std::string("str2"), 1, "example2", "example3", std::string("str1"), 3.0);
-  LOG_INFO(logger, "over dog quick {} {} {} {} {} {} {} {}", std::string("str1"), 5L, true,
-           static_cast<unsigned short>(10), 7UL, std::string("str2"), std::string_view("view1"), 4.0f);
-  LOG_INFO(logger, "test dog brown lazy {} {} {} {} {} {} {} {}", true, std::string_view("view2"),
-           6LL, std::string_view("view1"), false, 8ULL, "example3", 3.0);
-  LOG_INFO(logger, "example fox lazy {} {}", 5L, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "example logging over {} {} {} {} {} {} {} {}", 8ULL, 2, 6LL, "example2",
-           "example1", std::string("str2"), 5L, 7UL);
-  LOG_INFO(logger, "jumps test example {} {}", 1, 7UL);
-  LOG_INFO(logger, "over dog test example {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           2, "example3", std::string_view("view2"), 8ULL, 5L, 3.0, static_cast<short>(9), 6LL);
-  LOG_INFO(logger, "quick dog brown {} {} {} {} {} {} {} {} {}", static_cast<short>(9), 4.0f,
-           std::string("str1"), true, 6LL, 7UL, 8ULL, "example1", std::string("str2"));
-  LOG_INFO(logger, "logging dog fox brown {} {} {} {}", std::string("str1"), 3.0, "example3", 6LL);
-  LOG_INFO(logger, "quick test over {} {} {} {} {} {} {}", 6LL, 8ULL, std::string_view("view1"), 1,
-           std::string_view("view2"), 7UL, true);
-  LOG_INFO(logger, "test over fox {} {} {} {}", 5L, static_cast<short>(9), 8ULL, 7UL);
-  LOG_INFO(logger, "fox logging test {} {} {}", 1, 7UL, std::string_view("view1"));
-  LOG_INFO(logger, "fox over quick {} {} {} {} {} {} {} {}", "example2", std::string_view("view2"),
-           static_cast<short>(9), false, 7UL, "example3", "example1", 4.0f);
-  LOG_INFO(logger, "fox quick test example {}", std::string("str2"));
-  LOG_INFO(logger, "quick over dog {}", "example2");
-  LOG_INFO(logger, "example quick fox {} {} {} {}", 7UL, std::string("str1"), "example3", 4.0f);
-  LOG_INFO(logger, "example fox brown dog {} {} {} {} {} {} {} {} {}", 5L, static_cast<short>(9),
-           3.0, "example1", 1, true, 7UL, false, std::string("str2"));
-  LOG_INFO(logger, "lazy dog jumps quick {} {} {} {} {}", std::string_view("view1"), 1,
-           static_cast<short>(9), false, 6LL);
-  LOG_INFO(logger, "logging dog test {}", 6LL);
-  LOG_INFO(logger, "fox jumps quick logging {} {} {} {} {} {} {} {} {} {}", true, 8ULL, 1, 5L,
-           "example1", std::string("str1"), 6LL, static_cast<unsigned short>(10), 2, "example3");
-  LOG_INFO(logger, "jumps over example {} {} {} {} {} {} {} {} {} {}",
-           static_cast<unsigned short>(10), std::string_view("view1"), std::string_view("view2"),
-           8ULL, 4.0f, 3.0, std::string("str1"), true, 1, "example1");
-  LOG_INFO(logger, "over jumps logging {} {} {} {} {} {} {} {} {} {}", 4.0f, 5L, false,
-           std::string_view("view1"), static_cast<short>(9), 2, 7UL, 6LL, "example2",
-           std::string_view("view2"));
-  LOG_INFO(logger, "quick example jumps {}", 5L);
-  LOG_INFO(logger, "logging brown lazy {} {} {} {} {} {} {}", std::string_view("view1"), false,
-           static_cast<unsigned short>(10), true, "example3", std::string("str2"), 3.0);
-  LOG_INFO(logger, "lazy dog quick brown {} {} {} {} {} {} {} {} {} {}", 2, "example3", 7UL, 3.0,
-           std::string("str1"), std::string_view("view2"), true, 6LL, std::string_view("view1"), false);
-  LOG_INFO(logger, "fox logging example test {}", 1);
-  LOG_INFO(logger, "test quick brown fox {} {} {} {} {} {}", "example1", static_cast<short>(9),
-           4.0f, 1, 5L, std::string_view("view1"));
-  LOG_INFO(logger, "dog logging test {} {} {} {}", std::string("str1"), "example1", true,
-           std::string_view("view1"));
-  LOG_INFO(logger, "test lazy quick example {} {} {} {} {}", 8ULL, std::string("str1"), 4.0f, 2,
-           std::string_view("view1"));
-  LOG_INFO(logger, "brown logging jumps dog {} {}", false, 8ULL);
-  LOG_INFO(logger, "test lazy logging example {} {} {} {} {} {} {} {}", std::string("str2"), false,
-           "example2", 7UL, "example3", 4.0f, std::string_view("view1"), static_cast<short>(9));
-  LOG_INFO(logger, "lazy example jumps brown {} {} {}", 6LL, std::string_view("view2"), std::string("str1"));
-  LOG_INFO(logger, "brown fox test over {} {} {} {} {} {} {} {} {} {}",
-           static_cast<unsigned short>(10), 1, false, 6LL, static_cast<short>(9), 7UL,
-           std::string_view("view2"), "example2", std::string("str2"), true);
-  LOG_INFO(logger, "over example test {} {} {} {} {} {}", static_cast<short>(9), 1,
-           std::string_view("view2"), 8ULL, static_cast<unsigned short>(10), 5L);
-  LOG_INFO(logger, "dog fox test example {} {} {}", "example3", std::string_view("view1"), std::string("str2"));
-  LOG_INFO(logger, "jumps test over logging {} {} {} {} {} {} {}", 4.0f, 6LL, 5L, 2, "example1", 1,
-           std::string_view("view2"));
-  LOG_INFO(logger, "brown test lazy {} {} {} {} {} {} {}", false, std::string("str1"), 4.0f,
-           "example3", std::string("str2"), 8ULL, true);
-  LOG_INFO(logger, "example jumps brown {} {} {} {} {} {} {} {} {} {}", 2, "example3", 4.0f, 7UL,
-           8ULL, 3.0, static_cast<unsigned short>(10), 1, "example1", std::string("str2"));
-  LOG_INFO(logger, "dog fox jumps {} {}", std::string("str1"), "example2");
-  LOG_INFO(logger, "dog brown example {} {} {} {} {} {}", 1, std::string("str1"), 7UL, 6LL,
-           std::string("str2"), 4.0f);
-  LOG_INFO(logger, "jumps brown quick {} {}", static_cast<short>(9), true);
-  LOG_INFO(logger, "brown example jumps {} {} {}", false, 5L, std::string_view("view1"));
-  LOG_INFO(logger, "logging quick test {} {}", std::string_view("view2"), "example3");
-  LOG_INFO(logger, "test over quick fox {} {} {} {} {}", 2, 5L, 3.0, true, "example2");
-  LOG_INFO(logger, "over lazy dog brown {} {} {} {} {}", "example2", 3.0, 2, static_cast<short>(9), false);
-  LOG_INFO(logger, "fox dog logging {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           std::string_view("view2"), static_cast<short>(9), 6LL, 5L, 1);
-  LOG_INFO(logger, "over logging brown quick {} {} {} {} {} {} {} {} {} {}", static_cast<short>(9),
-           "example2", std::string_view("view1"), 8ULL, 2, std::string("str1"),
-           static_cast<unsigned short>(10), 7UL, 6LL, "example3");
-  LOG_INFO(logger, "brown logging lazy quick {} {} {} {} {} {}", 5L,
-           static_cast<unsigned short>(10), static_cast<short>(9), std::string("str2"), 8ULL, true);
-  LOG_INFO(logger, "example test quick {} {}", std::string("str1"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown over jumps {} {} {}", true, 1, std::string_view("view1"));
-  LOG_INFO(logger, "dog over lazy example {} {} {} {}", "example1", "example3", 2, 7UL);
-  LOG_INFO(logger, "fox test quick {} {} {} {} {} {} {} {} {} {}", 1, "example2", 7UL,
-           static_cast<unsigned short>(10), 3.0, 2, 5L, std::string_view("view1"), 4.0f, 6LL);
-  LOG_INFO(logger, "lazy test brown {} {} {}", 2, false, 5L);
-  LOG_INFO(logger, "lazy example fox quick {} {} {} {} {} {} {}", false, 4.0f, 5L,
-           std::string("str1"), "example3", 7UL, std::string_view("view1"));
-  LOG_INFO(logger, "quick brown test dog {} {} {} {} {} {} {} {} {} {}", 7UL, "example2", false,
-           8ULL, std::string("str2"), 6LL, 2, std::string("str1"), "example1", true);
-  LOG_INFO(logger, "quick logging test over {} {} {} {}", std::string_view("view1"), "example1",
-           static_cast<short>(9), 2);
-  LOG_INFO(logger, "jumps logging dog {} {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           std::string("str2"), 6LL, 3.0, 2, static_cast<unsigned short>(10), false, 8ULL, true, 4.0f);
-  LOG_INFO(logger, "quick logging over dog {} {} {} {} {} {} {} {}", 5L, true, 3.0, "example2", 2,
-           7UL, "example1", std::string_view("view1"));
-  LOG_INFO(logger, "example over lazy fox {} {} {} {}", std::string_view("view1"), 6LL, "example1",
-           std::string_view("view2"));
-  LOG_INFO(logger, "jumps brown quick {} {} {} {}", "example1", 3.0, 5L, std::string("str1"));
-  LOG_INFO(logger, "lazy quick over jumps {} {} {}", 2, true, static_cast<short>(9));
-  LOG_INFO(logger, "brown example dog {}", 5L);
-  LOG_INFO(logger, "over brown logging dog {} {}", static_cast<unsigned short>(10), 6LL);
-  LOG_INFO(logger, "test lazy over dog {} {} {} {} {}", 6LL, static_cast<short>(9), 3.0, false, 1);
-  LOG_INFO(logger, "over lazy jumps brown {} {} {} {}", static_cast<short>(9), std::string("str2"), 8ULL, 5L);
-  LOG_INFO(logger, "lazy fox example {} {} {}", 8ULL, std::string_view("view1"), static_cast<short>(9));
-  LOG_INFO(logger, "logging jumps dog test {} {} {}", static_cast<short>(9), true, 7UL);
-  LOG_INFO(logger, "test example over lazy {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           6LL, 7UL, static_cast<short>(9), "example1", true, std::string("str1"), false);
-  LOG_INFO(logger, "lazy over test {} {} {} {} {} {} {} {} {}", std::string("str1"), 7UL,
-           "example2", true, std::string_view("view1"), 6LL, "example1", 4.0f, std::string("str2"));
-  LOG_INFO(logger, "jumps example lazy {} {}", "example3", std::string_view("view2"));
-  LOG_INFO(logger, "fox logging lazy test {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           5L, "example2", 4.0f, 3.0, std::string_view("view2"), 2, "example1");
-  LOG_INFO(logger, "fox over quick test {} {} {} {} {} {} {} {} {}", "example1",
-           static_cast<unsigned short>(10), static_cast<short>(9), "example2", false,
-           std::string_view("view2"), 6LL, "example3", 5L);
-  LOG_INFO(logger, "test quick over logging {} {}", std::string_view("view2"), 6LL);
-  LOG_INFO(logger, "logging test quick over {} {}", true, 6LL);
-  LOG_INFO(logger, "lazy quick fox {} {} {} {} {} {} {} {}", 4.0f, false, 8ULL, std::string_view("view1"),
-           6LL, 3.0, std::string_view("view2"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "dog lazy test jumps {} {} {} {} {} {} {}", 2, 8ULL, 1,
-           static_cast<unsigned short>(10), "example1", true, static_cast<short>(9));
-  LOG_INFO(logger, "lazy dog test fox {}", std::string("str1"));
-  LOG_INFO(logger, "test jumps example brown {} {} {} {} {} {} {}", false, 4.0f, 2,
-           std::string_view("view1"), "example1", 6LL, std::string("str2"));
-  LOG_INFO(logger, "fox dog lazy logging {} {} {} {} {} {} {} {} {}", "example3",
-           std::string("str2"), 8ULL, "example1", false, "example2", 4.0f, 3.0, std::string("str1"));
-  LOG_INFO(logger, "fox test example brown {} {}", std::string("str1"), "example2");
-  LOG_INFO(logger, "test quick logging {}", std::string("str1"));
-  LOG_INFO(logger, "brown fox example jumps {} {} {} {} {} {} {} {}", std::string_view("view1"),
-           7UL, false, 6LL, std::string("str1"), 8ULL, std::string_view("view2"), "example3");
-  LOG_INFO(logger, "lazy logging fox jumps {} {} {} {} {}", std::string_view("view1"), "example2",
-           "example3", false, static_cast<short>(9));
-  LOG_INFO(logger, "dog jumps example over {}", true);
-  LOG_INFO(logger, "brown lazy quick {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           std::string("str1"), true, std::string("str2"), std::string_view("view2"), 4.0f,
-           "example3", false);
-  LOG_INFO(logger, "dog fox jumps logging {} {} {}", 6LL, 5L, 1);
-  LOG_INFO(logger, "jumps brown example quick {} {} {} {} {} {}", std::string_view("view1"), 7UL,
-           "example3", 8ULL, 6LL, 3.0);
-  LOG_INFO(logger, "quick example jumps lazy {} {} {} {} {}", static_cast<unsigned short>(10),
-           false, std::string_view("view1"), 1, 7UL);
-  LOG_INFO(logger, "dog lazy quick over {}", "example3");
-  LOG_INFO(logger, "over dog brown {} {} {} {} {} {}", 8ULL, 7UL, std::string("str2"), "example3",
-           1, std::string_view("view1"));
-  LOG_INFO(logger, "test quick dog lazy {} {} {}", "example3", "example1", "example2");
-  LOG_INFO(logger, "dog fox jumps over {} {}", static_cast<unsigned short>(10), "example3");
-  LOG_INFO(logger, "jumps fox lazy dog {} {} {} {} {} {} {} {} {}", 5L, 2, "example3", "example2",
-           static_cast<unsigned short>(10), 3.0, std::string("str2"), 6LL, 8ULL);
-  LOG_INFO(logger, "over quick fox {} {} {} {} {} {} {}", std::string_view("view2"),
-           static_cast<unsigned short>(10), 4.0f, 8ULL, 2, 1, std::string("str2"));
-  LOG_INFO(logger, "dog test lazy {} {} {} {}", 8ULL, std::string_view("view1"), "example3", 3.0);
-  LOG_INFO(logger, "fox jumps example dog {} {}", "example2", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "logging lazy jumps example {} {} {} {} {} {} {}", std::string_view("view2"),
-           static_cast<unsigned short>(10), std::string_view("view1"), 7UL, true, 5L, 4.0f);
-  LOG_INFO(logger, "dog example fox {} {}", 6LL, std::string("str2"));
-  LOG_INFO(logger, "logging dog quick {} {} {} {} {}", static_cast<short>(9), true, false,
-           std::string_view("view1"), std::string("str1"));
-  LOG_INFO(logger, "jumps example over {} {} {} {} {} {} {}", 3.0, false, std::string_view("view1"),
-           4.0f, std::string("str2"), 5L, std::string_view("view2"));
-  LOG_INFO(logger, "example jumps test brown {} {} {} {} {} {}", std::string("str2"), 6LL, 7UL,
-           static_cast<short>(9), "example2", 8ULL);
-  LOG_INFO(logger, "dog logging quick {} {} {} {} {} {} {}", "example1", std::string("str2"), 8ULL,
-           "example2", "example3", static_cast<unsigned short>(10), 3.0);
-  LOG_INFO(logger, "quick logging brown {} {} {} {} {}", true, 3.0, static_cast<unsigned short>(10),
-           5L, std::string("str1"));
-  LOG_INFO(logger, "quick lazy dog brown {} {} {} {} {} {} {} {} {}", 7UL, static_cast<unsigned short>(10),
-           3.0, 1, "example2", "example1", 6LL, false, static_cast<short>(9));
-  LOG_INFO(logger, "jumps quick over {} {} {} {} {} {}", std::string("str2"), 4.0f, "example3", 1,
-           true, "example2");
-  LOG_INFO(logger, "quick dog example jumps {} {} {} {} {} {} {} {}", "example1", 2, 6LL, false,
-           static_cast<unsigned short>(10), 5L, 1, std::string_view("view1"));
-  LOG_INFO(logger, "jumps dog quick test {}", 2);
-  LOG_INFO(logger, "logging fox example {} {} {} {} {} {} {} {} {}", true, 2,
-           static_cast<unsigned short>(10), std::string("str1"), std::string("str2"),
-           std::string_view("view1"), "example1", 1, static_cast<short>(9));
-  LOG_INFO(logger, "brown test dog {} {} {} {} {}", "example3", std::string_view("view1"), false,
-           6LL, std::string("str1"));
-  LOG_INFO(logger, "over example logging brown {} {} {} {}", "example1", 1, 6LL, 7UL);
-  LOG_INFO(logger, "logging jumps test example {} {} {}", 1, 8ULL, 6LL);
-  LOG_INFO(logger, "logging brown lazy example {} {}", 6LL, static_cast<short>(9));
-  LOG_INFO(logger, "quick jumps lazy example {} {}", 7UL, 2);
-  LOG_INFO(logger, "brown over logging lazy {} {}", std::string("str2"), 7UL);
-  LOG_INFO(logger, "logging brown fox {}", std::string_view("view2"));
-  LOG_INFO(logger, "quick fox test {} {} {}", "example2", 5L, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "quick test over brown {} {} {}", std::string_view("view1"), true, 2);
-  LOG_INFO(logger, "brown lazy jumps {} {} {} {} {} {} {}", 5L, "example2", 3.0, true, 4.0f,
-           std::string("str1"), static_cast<short>(9));
-  LOG_INFO(logger, "test jumps lazy logging {} {} {}", std::string_view("view2"), static_cast<short>(9), 7UL);
-  LOG_INFO(logger, "brown quick dog jumps {}", false);
-  LOG_INFO(logger, "fox example test brown {} {} {} {} {} {}", 1, std::string_view("view2"), 3.0,
-           false, 8ULL, "example1");
-  LOG_INFO(logger, "dog quick brown test {} {} {} {}", std::string_view("view2"), "example1",
-           std::string_view("view1"), 5L);
-  LOG_INFO(logger, "quick lazy example fox {} {} {} {} {} {} {} {} {} {}", 1, 2, 8ULL, false, 6LL,
-           true, "example2", "example1", 4.0f, static_cast<short>(9));
-  LOG_INFO(logger, "lazy dog brown fox {} {} {} {}", 6LL, true, std::string("str2"), 3.0);
-  LOG_INFO(logger, "quick test brown fox {} {} {} {} {}", std::string("str2"),
-           std::string_view("view2"), false, "example3", 5L);
-  LOG_INFO(logger, "dog jumps brown {}", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "dog test example jumps {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           true, 8ULL, std::string("str1"), std::string_view("view1"), 2);
-  LOG_INFO(logger, "brown logging fox {} {} {} {} {} {} {} {}", "example1", static_cast<short>(9),
-           "example3", "example2", true, static_cast<unsigned short>(10), std::string("str2"), 5L);
-  LOG_INFO(logger, "lazy dog jumps {} {} {} {} {} {} {} {} {} {}", 7UL, 5L, std::string_view("view2"),
-           std::string("str1"), true, 3.0, std::string("str2"), "example1", 8ULL, static_cast<short>(9));
-  LOG_INFO(logger, "dog lazy quick {} {} {} {} {} {} {}", 8ULL, 6LL, true, 2, 1, 4.0f, "example2");
-  LOG_INFO(logger, "logging over brown example {} {} {} {} {} {} {} {} {}", true, 3.0, 8ULL,
-           "example1", std::string_view("view2"), 5L, "example2", 6LL, std::string_view("view1"));
-  LOG_INFO(logger, "logging example test {} {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           5L, "example3", 8ULL, 2, "example2", 7UL, std::string_view("view1"),
-           static_cast<short>(9), std::string("str2"));
-  LOG_INFO(logger, "jumps over example test {} {} {} {} {} {} {} {} {}", 7UL, std::string("str2"), true,
-           1, "example2", "example1", static_cast<unsigned short>(10), std::string_view("view1"), 6LL);
-  LOG_INFO(logger, "brown lazy over {} {} {} {} {} {}", static_cast<short>(9), "example1",
-           "example2", 8ULL, 3.0, std::string("str1"));
-  LOG_INFO(logger, "logging jumps test {} {}", 1, "example1");
-  LOG_INFO(logger, "quick brown logging {} {} {} {} {} {} {}", 1, 4.0f, 7UL, "example3",
-           std::string_view("view2"), static_cast<short>(9), 3.0);
-  LOG_INFO(logger, "jumps dog over test {} {} {} {} {} {} {} {} {}", std::string_view("view2"), false,
-           std::string_view("view1"), 7UL, "example1", "example2", static_cast<short>(9), 4.0f, 6LL);
-  LOG_INFO(logger, "over dog quick fox {} {} {} {} {} {}", std::string("str2"),
-           std::string_view("view1"), "example3", std::string("str1"), "example2", 5L);
-  LOG_INFO(logger, "quick test fox brown {} {}", 8ULL, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "example brown jumps quick {} {} {} {} {} {}", std::string_view("view2"), false,
-           1, 6LL, 8ULL, 3.0);
-  LOG_INFO(logger, "brown example test quick {} {}", static_cast<short>(9), 4.0f);
-  LOG_INFO(logger, "example dog lazy {} {} {} {} {} {} {} {} {} {}", 5L, 2, std::string("str2"),
-           static_cast<unsigned short>(10), 1, std::string_view("view2"), false, 4.0f, 6LL,
-           std::string_view("view1"));
-  LOG_INFO(logger, "over logging dog {} {} {} {} {} {} {} {} {} {}", 7UL, 5L, 8ULL, 3.0,
-           static_cast<unsigned short>(10), "example1", std::string_view("view1"),
-           std::string_view("view2"), true, std::string("str1"));
-  LOG_INFO(logger, "quick test example {} {} {} {} {} {} {} {}", 8ULL, 7UL, false, "example1",
-           "example3", std::string("str2"), 2, 6LL);
-  LOG_INFO(logger, "brown test lazy fox {} {} {} {} {} {} {} {} {} {}", "example3", 6LL, "example2",
-           std::string_view("view1"), 8ULL, static_cast<short>(9), 4.0f, 3.0, 5L, false);
-  LOG_INFO(logger, "over test fox quick {} {} {} {} {} {} {}", 3.0, 2, std::string("str2"),
-           static_cast<short>(9), 1, std::string_view("view1"), 8ULL);
-  LOG_INFO(logger, "test brown jumps {} {} {} {} {} {} {} {}", 7UL, "example2", std::string("str1"),
-           true, 6LL, false, 8ULL, "example3");
-  LOG_INFO(logger, "over brown quick {} {} {} {} {} {} {} {}", 2, 7UL, "example1",
-           static_cast<unsigned short>(10), std::string_view("view2"), std::string("str1"), 1, 3.0);
-  LOG_INFO(logger, "quick jumps over logging {} {} {} {} {} {} {} {} {}", 5L, false, 3.0,
-           std::string("str1"), "example1", 7UL, static_cast<unsigned short>(10),
-           std::string("str2"), static_cast<short>(9));
-  LOG_INFO(logger, "dog over jumps {} {} {} {} {} {} {} {}", "example2", "example3", 6LL, false,
-           std::string_view("view1"), 2, 3.0, "example1");
-  LOG_INFO(logger, "lazy quick test logging {} {} {}", false, std::string_view("view1"), 8ULL);
-  LOG_INFO(logger, "fox quick over {} {} {} {} {} {} {} {} {} {}", "example1", 6LL, 4.0f,
-           std::string_view("view1"), false, 1, 3.0, 7UL, std::string_view("view2"), 5L);
-  LOG_INFO(logger, "jumps lazy over logging {} {} {} {} {} {} {} {} {}", std::string("str1"),
-           "example1", 3.0, "example2", "example3", true, 4.0f, std::string_view("view1"), 6LL);
-  LOG_INFO(logger, "fox example quick {} {} {} {} {} {} {} {} {} {}", static_cast<short>(9),
-           "example3", false, 5L, 7UL, 3.0, 8ULL, std::string_view("view1"),
-           static_cast<unsigned short>(10), 4.0f);
-  LOG_INFO(logger, "jumps over dog brown {} {} {}", 3.0, 8ULL, "example1");
-  LOG_INFO(logger, "jumps quick test {} {} {} {} {} {} {} {}", 7UL, 4.0f, "example2",
-           std::string("str2"), 3.0, false, 8ULL, 5L);
-  LOG_INFO(logger, "brown logging over fox {} {}", 5L, 6LL);
-  LOG_INFO(logger, "jumps dog over quick {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           std::string("str1"), "example2", "example1", std::string_view("view2"), "example3", 1);
-  LOG_INFO(logger, "over quick brown {} {} {} {} {} {} {} {}", 8ULL, 6LL, std::string("str2"), true,
-           "example2", 1, std::string_view("view2"), std::string_view("view1"));
-  LOG_INFO(logger, "logging quick brown fox {} {} {} {} {} {} {}", std::string_view("view1"), 1,
-           false, std::string("str1"), 6LL, "example2", std::string_view("view2"));
-  LOG_INFO(logger, "jumps fox logging {} {}", static_cast<unsigned short>(10), static_cast<short>(9));
-  LOG_INFO(logger, "fox example dog {} {} {} {}", static_cast<unsigned short>(10),
-           std::string("str2"), true, "example3");
-  LOG_INFO(logger, "brown quick logging fox {} {} {} {} {} {} {} {} {}", 8ULL, 5L, static_cast<short>(9),
-           "example1", 6LL, std::string("str1"), std::string_view("view2"), "example2", true);
-  LOG_INFO(logger, "lazy dog test {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           static_cast<unsigned short>(10), std::string_view("view1"), false, 8ULL, "example3", 3.0,
-           2, std::string("str1"));
-  LOG_INFO(logger, "lazy test example over {}", "example1");
-  LOG_INFO(logger, "test brown fox example {} {} {} {} {} {} {} {} {} {}", 3.0, true, std::string("str2"),
-           8ULL, 1, "example1", false, static_cast<short>(9), "example3", "example2");
-  LOG_INFO(logger, "example lazy jumps {} {} {} {} {} {} {} {} {} {}", 2, 5L, "example2", 4.0f,
-           static_cast<short>(9), 6LL, static_cast<unsigned short>(10), true, 1, 7UL);
-  LOG_INFO(logger, "fox test jumps {} {} {} {} {} {} {} {} {}", std::string("str1"), "example2", 4.0f,
-           std::string_view("view1"), 6LL, 1, static_cast<short>(9), 5L, std::string_view("view2"));
-  LOG_INFO(logger, "brown lazy example {} {} {} {} {} {} {} {} {}", "example2",
-           std::string_view("view1"), "example1", true, static_cast<short>(9), 5L, 2, 1, 8ULL);
-  LOG_INFO(logger, "fox brown dog test {} {} {}", std::string_view("view2"), false, 4.0f);
-  LOG_INFO(logger, "example test brown {} {} {} {}", 6LL, 8ULL, true, 1);
-  LOG_INFO(logger, "over example logging brown {} {}", 5L, std::string("str1"));
-  LOG_INFO(logger, "example dog test {} {} {} {} {} {}", false, "example2", 4.0f,
-           std::string("str1"), "example3", 2);
-  LOG_INFO(logger, "over quick logging {} {} {}", 1, std::string_view("view2"), 8ULL);
-  LOG_INFO(logger, "logging jumps example {} {} {} {} {} {} {} {}", 7UL, std::string("str2"), 6LL,
-           "example2", 5L, 8ULL, false, std::string("str1"));
-  LOG_INFO(logger, "jumps dog quick {} {}", 8ULL, 5L);
-  LOG_INFO(logger, "logging fox test {} {} {} {}", 7UL, false, 2, std::string_view("view2"));
-  LOG_INFO(logger, "fox over dog quick {} {} {} {} {} {} {} {}", 7UL, "example1",
-           std::string_view("view1"), true, 2, 4.0f, 6LL, false);
-  LOG_INFO(logger, "test jumps quick {} {} {} {} {} {} {}", 2, false, "example1", 8ULL, 6LL,
-           static_cast<unsigned short>(10), 4.0f);
-  LOG_INFO(logger, "jumps logging dog fox {}", std::string_view("view1"));
-  LOG_INFO(logger, "fox lazy test {} {} {} {} {} {} {} {}", std::string_view("view1"), 3.0,
-           "example1", true, std::string("str2"), 5L, 4.0f, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox brown jumps {} {} {} {} {} {} {}", std::string("str1"), 7UL,
-           static_cast<short>(9), std::string_view("view1"), false, 1, "example3");
-  LOG_INFO(logger, "over example fox {} {} {} {}", std::string_view("view1"), "example1", 8ULL,
-           std::string_view("view2"));
-  LOG_INFO(logger, "example lazy quick {} {} {} {} {} {} {}", 8ULL, 2,
-           static_cast<unsigned short>(10), 3.0, std::string("str2"), 4.0f, 7UL);
-  LOG_INFO(logger, "logging fox brown jumps {} {} {} {} {} {} {} {} {}", std::string_view("view1"),
-           8ULL, std::string("str2"), true, std::string_view("view2"), 7UL, 3.0, false, "example2");
-  LOG_INFO(logger, "over brown quick {} {}", true, 1);
-  LOG_INFO(logger, "brown dog jumps {} {} {}", false, 8ULL, 2);
-  LOG_INFO(logger, "dog brown quick lazy {} {} {} {} {}", "example3", "example1", 8ULL, 3.0,
-           "example2");
-  LOG_INFO(logger, "fox quick brown over {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           "example2", 2, 8ULL, "example1", std::string("str1"), 4.0f, false, 3.0);
-  LOG_INFO(logger, "over fox lazy {} {} {} {} {} {}", 5L, 4.0f, std::string("str1"), 8ULL,
-           std::string_view("view2"), 3.0);
-  LOG_INFO(logger, "lazy dog test {} {} {} {} {} {} {} {}", 2, "example2", false, 6LL,
-           std::string("str1"), 8ULL, static_cast<short>(9), 1);
-  LOG_INFO(logger, "lazy quick brown logging {} {}", 1, 4.0f);
-  LOG_INFO(logger, "over quick fox {} {} {} {} {} {}", std::string_view("view2"),
-           static_cast<unsigned short>(10), 2, std::string("str2"), std::string("str1"), 3.0);
-  LOG_INFO(logger, "test dog jumps lazy {} {} {}", 6LL, "example2", 7UL);
-  LOG_INFO(logger, "lazy dog jumps over {}", 7UL);
-  LOG_INFO(logger, "logging jumps fox lazy {} {} {}", false, 6LL, 4.0f);
-  LOG_INFO(logger, "jumps fox example {} {}", "example2", std::string_view("view2"));
-  LOG_INFO(logger, "quick jumps test dog {} {} {} {} {} {}", 7UL, 8ULL, 1, 6LL, 4.0f, std::string_view("view1"));
-  LOG_INFO(logger, "brown example dog {} {} {} {} {} {}", 4.0f, false, std::string("str1"),
-           static_cast<short>(9), 6LL, true);
-  LOG_INFO(logger, "brown logging example {} {} {} {}", static_cast<unsigned short>(10), 7UL, false, 3.0);
-  LOG_INFO(logger, "quick fox test {} {} {} {} {} {}", 3.0, std::string_view("view2"), true, false,
-           std::string("str1"), std::string("str2"));
-  LOG_INFO(logger, "lazy quick over {} {} {} {} {} {} {}", 6LL, false, static_cast<short>(9), true,
-           7UL, 5L, std::string_view("view2"));
-  LOG_INFO(logger, "jumps lazy over {} {}", "example3", 2);
-  LOG_INFO(logger, "test dog jumps logging {} {} {} {} {} {} {} {} {} {}", false, 8ULL,
-           static_cast<short>(9), 7UL, std::string_view("view2"), "example1", 1, 5L, "example3", 2);
-  LOG_INFO(logger, "brown logging quick example {} {} {} {} {} {} {} {}", 2, "example3",
-           static_cast<unsigned short>(10), std::string_view("view1"), true, std::string("str2"), false, 5L);
-  LOG_INFO(logger, "over dog jumps quick {} {} {}", 3.0, 4.0f, 8ULL);
-  LOG_INFO(logger, "fox lazy test quick {} {} {} {} {} {} {} {}", 5L, 4.0f, "example2",
-           std::string("str2"), 6LL, static_cast<unsigned short>(10), 7UL, std::string_view("view1"));
-  LOG_INFO(logger, "jumps over logging lazy {} {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           6LL, 7UL, 1, 5L, 4.0f, std::string_view("view2"), false, "example1", 3.0);
-  LOG_INFO(logger, "lazy over test {} {}", std::string("str1"), 3.0);
-  LOG_INFO(logger, "fox brown over {} {} {} {} {} {} {} {}", 6LL, std::string("str1"),
-           static_cast<short>(9), 2, "example1", 5L, false, std::string_view("view2"));
-  LOG_INFO(logger, "brown lazy fox {}", static_cast<short>(9));
-  LOG_INFO(logger, "fox dog brown {} {} {} {} {}", true, 8ULL, std::string_view("view2"),
-           std::string("str1"), 6LL);
-  LOG_INFO(logger, "dog example over {} {} {} {}", static_cast<unsigned short>(10), 6LL, 1, 3.0);
-  LOG_INFO(logger, "jumps dog brown {} {} {} {} {} {} {} {}", std::string_view("view1"),
-           static_cast<short>(9), true, std::string("str2"), 8ULL, 2, 4.0f, "example3");
-  LOG_INFO(logger, "jumps test logging {} {}", "example3", std::string_view("view1"));
-  LOG_INFO(logger, "example dog logging over {} {} {} {} {} {} {} {} {} {}", 2,
-           static_cast<short>(9), 5L, "example1", 6LL, true, std::string("str2"), 4.0f, 8ULL, 1);
-  LOG_INFO(logger, "dog logging lazy example {} {} {} {} {} {} {} {} {} {}", std::string("str2"), 1,
-           5L, 3.0, std::string("str1"), static_cast<unsigned short>(10), std::string_view("view1"),
-           6LL, 7UL, static_cast<short>(9));
-  LOG_INFO(logger, "jumps logging fox brown {} {} {} {} {} {}", false, 4.0f, std::string("str1"),
-           std::string_view("view1"), "example2", 3.0);
-  LOG_INFO(logger, "fox brown example {} {} {} {} {}", 1, 5L, "example2",
-           static_cast<unsigned short>(10), std::string("str1"));
-  LOG_INFO(logger, "test fox example brown {} {} {} {} {} {} {} {} {} {}", std::string("str1"),
-           "example2", 7UL, 2, 8ULL, std::string_view("view1"), static_cast<unsigned short>(10),
-           true, false, 4.0f);
-  LOG_INFO(logger, "lazy brown jumps {} {} {} {} {} {} {} {} {} {}", 2, std::string("str1"),
-           std::string("str2"), 4.0f, 1, "example3", static_cast<unsigned short>(10), true, false,
-           "example1");
-  LOG_INFO(logger, "quick jumps test lazy {} {} {} {} {}", 1, static_cast<short>(9), 7UL,
-           std::string("str1"), 4.0f);
-  LOG_INFO(logger, "example jumps over lazy {} {} {} {} {} {} {}", 8ULL, true,
-           std::string_view("view2"), 4.0f, static_cast<short>(9), std::string_view("view1"), 6LL);
-  LOG_INFO(logger, "brown fox dog logging {} {} {} {} {} {} {} {} {} {}", 2, std::string("str2"),
-           "example1", 4.0f, 5L, false, 7UL, 1, 6LL, 8ULL);
-  LOG_INFO(logger, "lazy quick fox over {} {}", std::string_view("view2"), 4.0f);
-  LOG_INFO(logger, "jumps over example dog {} {}", std::string_view("view2"), static_cast<short>(9));
-  LOG_INFO(logger, "brown example over {} {}", std::string_view("view1"), std::string("str1"));
-  LOG_INFO(logger, "test example fox logging {} {} {} {}", 4.0f, std::string("str1"), "example1",
-           "example3");
-  LOG_INFO(logger, "fox over lazy test {} {} {}", "example1", 3.0, static_cast<short>(9));
-  LOG_INFO(logger, "example dog lazy {} {} {} {} {}", "example1", 6LL, 7UL, 4.0f, 5L);
-  LOG_INFO(logger, "lazy logging over {} {} {} {} {} {} {} {} {}", false, static_cast<short>(9),
-           static_cast<unsigned short>(10), 8ULL, std::string("str2"), 2, 5L, "example1", std::string("str1"));
-  LOG_INFO(logger, "test quick jumps {} {} {} {} {}", true, "example2", std::string_view("view1"),
-           std::string("str1"), "example3");
-  LOG_INFO(logger, "test brown dog {} {} {} {} {}", 8ULL, 2, 6LL, static_cast<unsigned short>(10),
-           "example1");
-  LOG_INFO(logger, "logging test brown {} {} {} {} {} {} {} {}", 1, "example2",
-           static_cast<unsigned short>(10), std::string("str2"), 3.0, 6LL, static_cast<short>(9),
-           std::string("str1"));
-  LOG_INFO(logger, "test jumps lazy {} {} {} {} {} {} {}", 4.0f, "example1", 6LL, "example2", 2, 3.0, 8ULL);
-  LOG_INFO(logger, "brown over dog {} {} {} {} {} {} {} {} {}", 1, 6LL, 3.0, std::string("str1"),
-           std::string_view("view2"), 5L, static_cast<unsigned short>(10), false, static_cast<short>(9));
-  LOG_INFO(logger, "logging brown over example {} {} {} {} {} {} {} {} {}", "example3", 3.0, true,
-           false, std::string_view("view1"), 7UL, 6LL, std::string("str2"), "example2");
-  LOG_INFO(logger, "jumps test quick {} {} {} {} {} {} {}", false, 4.0f, static_cast<short>(9),
-           std::string_view("view2"), "example3", 3.0, std::string("str2"));
-  LOG_INFO(logger, "dog jumps test example {} {} {} {} {} {}", 5L, static_cast<unsigned short>(10),
-           4.0f, 8ULL, std::string_view("view1"), std::string("str1"));
-  LOG_INFO(logger, "brown over lazy example {} {} {} {} {} {} {} {}", std::string("str1"),
-           "example3", std::string_view("view1"), 5L, std::string_view("view2"), "example2", 2, true);
-  LOG_INFO(logger, "lazy dog test {} {} {}", true, 1, 2);
-  LOG_INFO(logger, "fox brown example {} {} {}", std::string("str1"), static_cast<unsigned short>(10), 2);
-  LOG_INFO(logger, "example dog quick brown {} {} {} {} {} {} {} {}", 8ULL, 4.0f, 7UL, true,
-           std::string("str2"), std::string("str1"), std::string_view("view2"), 2);
-  LOG_INFO(logger, "example dog quick {}", true);
-  LOG_INFO(logger, "test dog quick {} {} {} {} {}", std::string_view("view2"), 5L, 8ULL, 7UL, 6LL);
-  LOG_INFO(logger, "brown lazy jumps {} {} {} {} {} {} {}", 1, 2, 3.0, std::string("str1"),
-           "example1", std::string_view("view1"), true);
-  LOG_INFO(logger, "fox over dog {} {} {} {} {} {} {} {}", "example3", std::string_view("view2"), 1,
-           true, "example1", std::string("str2"), "example2", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "over brown quick {} {} {}", false, 8ULL, 4.0f);
-  LOG_INFO(logger, "quick example jumps fox {}", 6LL);
-  LOG_INFO(logger, "logging jumps quick {} {}", std::string("str2"), "example1");
-  LOG_INFO(logger, "dog logging lazy {} {} {} {}", std::string_view("view2"), true, std::string("str1"), 8ULL);
-  LOG_INFO(logger, "example fox jumps dog {} {} {} {} {} {}", true, 3.0, 1, 7UL, "example3", false);
-  LOG_INFO(logger, "test example lazy {} {} {} {} {} {} {} {} {}", std::string_view("view1"), 3.0,
-           1, 4.0f, 2, static_cast<unsigned short>(10), std::string("str1"), true, "example1");
-  LOG_INFO(logger, "logging dog test example {} {} {} {} {}", "example2", 4.0f, 8ULL, true,
-           std::string_view("view1"));
-  LOG_INFO(logger, "lazy example quick {} {} {} {} {} {} {} {} {} {}", false, 8ULL, 3.0, 6LL,
-           "example1", true, std::string_view("view1"), static_cast<unsigned short>(10), "example3",
-           std::string("str1"));
-  LOG_INFO(logger, "fox quick lazy {} {} {}", 7UL, 3.0, 1);
-  LOG_INFO(logger, "brown quick fox test {} {} {} {} {} {} {}", std::string_view("view2"), 1, 6LL,
-           5L, std::string("str2"), static_cast<unsigned short>(10), true);
-  LOG_INFO(logger, "fox test logging {} {} {} {} {} {} {} {} {} {}", 5L, 1, 8ULL, std::string("str1"),
-           "example3", std::string_view("view1"), 4.0f, std::string("str2"), "example2", false);
-  LOG_INFO(logger, "brown fox jumps over {} {} {} {} {} {} {}", std::string("str1"), 5L, 3.0,
-           std::string_view("view2"), static_cast<unsigned short>(10), false, std::string_view("view1"));
-  LOG_INFO(logger, "test lazy example {} {} {} {}", 6LL, 1, 5L, "example1");
-  LOG_INFO(logger, "over dog brown {} {} {}", std::string("str2"), 4.0f, static_cast<short>(9));
-  LOG_INFO(logger, "example brown test {} {} {}", 4.0f, true, 3.0);
-  LOG_INFO(logger, "lazy test logging fox {} {}", 5L, 3.0);
-  LOG_INFO(logger, "example fox lazy quick {} {} {} {} {} {} {} {}", 6LL, 7UL, true,
-           static_cast<unsigned short>(10), 3.0, std::string("str2"), "example1", std::string_view("view2"));
-  LOG_INFO(logger, "brown over test fox {} {} {} {} {} {} {} {} {}", 6LL, "example2", 3.0, 4.0f, 1,
-           std::string_view("view1"), std::string("str2"), false, true);
-  LOG_INFO(logger, "lazy over example {}", 4.0f);
-  LOG_INFO(logger, "lazy example fox {} {} {} {} {} {} {} {} {}", "example2", "example3", 3.0, 8ULL,
-           1, std::string("str1"), 7UL, std::string_view("view2"), std::string("str2"));
-  LOG_INFO(logger, "brown test lazy quick {} {} {} {} {} {} {} {}", std::string("str2"),
-           static_cast<short>(9), "example3", "example1", 8ULL, 4.0f, static_cast<unsigned short>(10), 7UL);
-  LOG_INFO(logger, "fox example logging {} {} {} {} {} {} {}", 3.0, 5L, 8ULL,
-           std::string_view("view2"), 2, std::string("str2"), 4.0f);
-  LOG_INFO(logger, "brown fox over lazy {} {} {} {} {} {}", false, static_cast<short>(9),
-           std::string_view("view1"), "example2", true, 6LL);
-  LOG_INFO(logger, "quick logging over {} {} {} {} {} {} {}", 5L, 4.0f, std::string("str2"),
-           "example1", 2, std::string_view("view1"), 7UL);
-  LOG_INFO(logger, "example lazy brown dog {} {} {} {} {} {} {} {} {}", "example1", false, 3.0,
-           4.0f, "example3", std::string("str1"), "example2", 7UL, true);
-  LOG_INFO(logger, "over dog test lazy {} {}", static_cast<unsigned short>(10), 6LL);
-  LOG_INFO(logger, "quick over dog example {} {} {} {}", 3.0, false, "example3", 7UL);
-  LOG_INFO(logger, "example test quick {} {} {} {} {} {} {} {} {} {}", true,
-           std::string_view("view1"), 4.0f, std::string("str2"), 2, static_cast<unsigned short>(10),
-           3.0, 7UL, 1, std::string_view("view2"));
-  LOG_INFO(logger, "over dog quick {} {} {} {} {} {} {} {} {} {}", 4.0f, std::string("str1"), 7UL,
-           2, 6LL, static_cast<unsigned short>(10), 8ULL, std::string_view("view1"), true, 3.0);
-  LOG_INFO(logger, "lazy test fox {} {}", 5L, 1);
-  LOG_INFO(logger, "test over dog {} {} {} {} {} {}", std::string("str2"), "example2", 7UL,
-           std::string_view("view2"), 8ULL, false);
-  LOG_INFO(logger, "brown fox test jumps {} {} {} {} {} {}", std::string_view("view2"),
-           static_cast<unsigned short>(10), 4.0f, 2, std::string("str1"), 1);
-  LOG_INFO(logger, "over fox lazy {} {} {} {} {} {} {} {} {}", false, 2, static_cast<short>(9),
-           4.0f, std::string("str2"), "example3", 1, std::string("str1"), std::string_view("view1"));
-  LOG_INFO(logger, "fox example quick logging {} {}", "example2", 6LL);
-  LOG_INFO(logger, "jumps dog fox {} {}", 6LL, 4.0f);
-  LOG_INFO(logger, "dog brown test logging {} {} {} {}", std::string("str2"),
-           std::string_view("view2"), 1, std::string_view("view1"));
-  LOG_INFO(logger, "over brown dog test {} {} {} {} {} {} {}", 3.0, std::string("str1"), "example1",
-           "example2", 6LL, 7UL, static_cast<short>(9));
-  LOG_INFO(logger, "jumps example lazy brown {} {} {} {}", "example3", 4.0f,
-           std::string_view("view1"), "example1");
-  LOG_INFO(logger, "over example dog {} {} {} {}", true, 1, false, std::string_view("view1"));
-  LOG_INFO(logger, "test over logging {} {} {} {} {} {} {} {} {}", 5L, std::string_view("view2"),
-           6LL, std::string_view("view1"), 1, true, "example1", std::string("str2"), "example2");
-  LOG_INFO(logger, "lazy example jumps quick {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           std::string_view("view1"), static_cast<unsigned short>(10), std::string("str2"),
-           "example1", static_cast<short>(9), 7UL, 6LL);
-  LOG_INFO(logger, "jumps quick over brown {} {} {} {} {}", static_cast<short>(9), true, 2,
-           std::string_view("view2"), "example3");
-  LOG_INFO(logger, "lazy dog logging {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           static_cast<unsigned short>(10), 5L, std::string_view("view1"), "example2", 8ULL, 6LL,
-           static_cast<short>(9), 3.0);
-  LOG_INFO(logger, "quick jumps brown {} {} {} {} {} {} {} {} {} {}", 1, true,
-           std::string_view("view1"), 3.0, "example2", 4.0f, std::string("str2"), "example1",
-           std::string_view("view2"), std::string("str1"));
-  LOG_INFO(logger, "over brown logging dog {} {} {} {} {}", std::string("str1"), 3.0, 8ULL,
-           static_cast<short>(9), false);
-  LOG_INFO(logger, "jumps brown over {}", "example1");
-  LOG_INFO(logger, "lazy test quick {} {} {} {} {}", 2, false, true, static_cast<unsigned short>(10), 1);
-  LOG_INFO(logger, "dog fox lazy brown {} {} {}", 6LL, std::string("str1"), "example3");
-  LOG_INFO(logger, "test jumps logging {} {} {} {} {} {} {} {}", 3.0, static_cast<short>(9), 7UL,
-           std::string("str2"), 1, "example1", 8ULL, true);
-  LOG_INFO(logger, "quick lazy jumps fox {} {} {} {}", "example2", std::string_view("view2"),
-           "example1", 4.0f);
-  LOG_INFO(logger, "logging jumps brown {} {}", "example1", 5L);
-  LOG_INFO(logger, "brown example over {} {} {} {} {} {} {}", std::string("str1"),
-           std::string("str2"), 8ULL, 3.0, static_cast<short>(9), true, std::string_view("view1"));
-  LOG_INFO(logger, "over jumps brown {} {} {} {} {} {}", std::string_view("view1"), 4.0f, 2,
-           std::string("str2"), 3.0, 6LL);
-  LOG_INFO(logger, "quick jumps logging test {} {} {} {}", false, std::string("str1"),
-           std::string_view("view1"), 8ULL);
-  LOG_INFO(logger, "jumps fox lazy dog {} {} {} {} {} {} {} {} {}", true, static_cast<unsigned short>(10),
-           std::string_view("view1"), "example1", 7UL, static_cast<short>(9), "example2", 8ULL, 1);
-  LOG_INFO(logger, "logging over test dog {}", std::string("str1"));
-  LOG_INFO(logger, "quick logging test lazy {} {} {} {} {} {} {} {} {} {}", std::string("str2"), 8ULL, 1, 3.0,
-           std::string_view("view2"), 6LL, true, 7UL, static_cast<unsigned short>(10), "example1");
-  LOG_INFO(logger, "lazy over example brown {} {}", 2, 8ULL);
-  LOG_INFO(logger, "dog logging quick test {} {} {} {} {}", true, false, 2, 6LL, "example1");
-  LOG_INFO(logger, "example test jumps {} {} {} {} {} {} {} {} {}", false, "example1",
-           std::string_view("view2"), 6LL, std::string("str1"), 3.0, 7UL, 4.0f, "example3");
-  LOG_INFO(logger, "dog logging jumps {} {} {} {} {} {}", 3.0, 2, "example2", true, false,
-           static_cast<short>(9));
-  LOG_INFO(logger, "example test fox {}", 4.0f);
-  LOG_INFO(logger, "brown logging example {} {} {} {}", std::string("str1"), 1, "example3", 3.0);
-  LOG_INFO(logger, "dog jumps fox quick {} {} {} {} {} {} {} {} {} {}", static_cast<short>(9),
-           "example1", "example2", static_cast<unsigned short>(10), 2, true, 8ULL,
-           std::string_view("view1"), 1, 7UL);
-  LOG_INFO(logger, "over dog fox lazy {} {} {} {} {} {} {} {} {} {}", 8ULL, 6LL,
-           std::string_view("view2"), 3.0, std::string("str2"), 2, static_cast<short>(9),
-           "example3", static_cast<unsigned short>(10), "example1");
-  LOG_INFO(logger, "brown test logging {} {} {} {} {} {} {} {} {}", 3.0, std::string("str2"), 2,
-           std::string_view("view1"), "example1", 6LL, true, std::string_view("view2"), false);
-  LOG_INFO(logger, "lazy fox brown {} {} {}", static_cast<short>(9), std::string_view("view2"),
-           "example1");
-  LOG_INFO(logger, "jumps lazy fox quick {} {} {} {} {} {} {} {}", false, 4.0f, 2, "example3",
-           std::string("str1"), true, "example1", 3.0);
-  LOG_INFO(logger, "lazy logging over {} {} {} {} {} {}", "example2", "example1",
-           std::string("str1"), false, 2, std::string_view("view2"));
-  LOG_INFO(logger, "test dog jumps example {} {} {}", static_cast<short>(9),
-           static_cast<unsigned short>(10), 8ULL);
-  LOG_INFO(logger, "example dog over quick {} {} {} {} {} {} {} {} {} {}", true, 1,
-           std::string("str1"), std::string_view("view1"), "example1", 3.0, false, 2, "example3",
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown test example over {} {} {} {} {} {}", 8ULL, 3.0, std::string("str1"),
-           "example2", 5L, true);
-  LOG_INFO(logger, "brown example jumps {} {} {} {} {} {} {}", 7UL, false, 6LL, 3.0, "example1",
-           static_cast<short>(9), 8ULL);
-  LOG_INFO(logger, "dog fox jumps {} {} {} {} {} {} {} {}", 6LL, 5L, 8ULL, 1, true, 2,
-           std::string("str2"), std::string_view("view1"));
-  LOG_INFO(logger, "brown quick test {} {}", static_cast<unsigned short>(10), 6LL);
-  LOG_INFO(logger, "logging brown fox {} {} {} {}", true, 5L, 7UL, 3.0);
-  LOG_INFO(logger, "test jumps lazy brown {}", "example2");
-  LOG_INFO(logger, "logging test lazy {}", true);
-  LOG_INFO(logger, "lazy fox dog example {} {} {} {} {} {} {} {} {} {}", std::string("str2"),
-           std::string_view("view1"), std::string("str1"), 5L, 7UL, static_cast<short>(9),
-           "example1", 3.0, "example2", 6LL);
-  LOG_INFO(logger, "lazy test example logging {} {} {} {} {} {} {} {} {} {}", 6LL, "example3",
-           false, 8ULL, std::string("str1"), "example1", 3.0, true, 4.0f, 7UL);
-  LOG_INFO(logger, "dog logging over quick {} {}", 4.0f, false);
-  LOG_INFO(logger, "logging brown fox {}", "example3");
-  LOG_INFO(logger, "dog logging brown {} {} {} {} {} {} {} {}", "example3",
-           std::string_view("view1"), static_cast<unsigned short>(10), "example2",
-           std::string_view("view2"), 2, 8ULL, "example1");
-  LOG_INFO(logger, "brown over dog {} {} {} {} {} {} {} {} {} {}", "example1", 6LL, 4.0f, true,
-           std::string_view("view1"), 1, 3.0, static_cast<short>(9), "example3", 5L);
-  LOG_INFO(logger, "logging example test quick {} {} {} {} {} {} {} {} {}", std::string("str1"),
-           std::string_view("view2"), "example3", "example2", 8ULL, static_cast<short>(9), 1,
-           static_cast<unsigned short>(10), false);
-  LOG_INFO(logger, "fox over lazy jumps {} {} {} {} {} {} {} {} {}", 1, false,
-           std::string_view("view1"), 6LL, 4.0f, 5L, 3.0, static_cast<short>(9), 7UL);
-  LOG_INFO(logger, "lazy test example over {} {} {} {} {} {} {} {} {}", static_cast<short>(9),
-           "example3", "example1", "example2", 8ULL, std::string("str1"), false, 6LL, 3.0);
-  LOG_INFO(logger, "over logging fox brown {} {} {} {} {} {} {} {} {}", "example3", 3.0, 4.0f,
-           std::string_view("view1"), 7UL, true, 6LL, std::string("str2"), 2);
-  LOG_INFO(logger, "jumps lazy brown logging {} {} {}", "example3", std::string_view("view1"), 6LL);
-  LOG_INFO(logger, "brown jumps lazy {}", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "test quick brown {} {} {}", "example1", false, std::string_view("view1"));
-  LOG_INFO(logger, "fox brown over {} {} {} {} {} {} {} {} {}", 2, "example3", 3.0, 4.0f,
-           std::string_view("view2"), "example2", 1, std::string("str1"), 7UL);
-  LOG_INFO(logger, "fox logging jumps example {} {} {} {} {}", "example1", 4.0f,
-           static_cast<unsigned short>(10), "example2", true);
-  LOG_INFO(logger, "quick over jumps fox {} {} {} {} {} {} {} {}", 8ULL, 1, 4.0f, std::string_view("view2"),
-           2, static_cast<unsigned short>(10), std::string_view("view1"), std::string("str1"));
-  LOG_INFO(logger, "logging dog brown {} {}", 5L, std::string_view("view1"));
-  LOG_INFO(logger, "fox example brown dog {} {} {}", 2, "example1", 4.0f);
-  LOG_INFO(logger, "brown logging dog fox {} {} {} {} {} {} {} {} {} {}", false, 5L, 8ULL,
-           std::string("str1"), 2, "example2", 3.0, static_cast<unsigned short>(10), 1, "example3");
-  LOG_INFO(logger, "over jumps fox {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           std::string_view("view2"), static_cast<short>(9), 2, 4.0f, std::string_view("view1"),
-           "example3");
-  LOG_INFO(logger, "example fox logging {} {} {} {} {} {} {} {} {} {}", std::string("str2"), 4.0f,
-           std::string("str1"), 5L, static_cast<short>(9), 8ULL, 7UL,
-           static_cast<unsigned short>(10), 3.0, 6LL);
-  LOG_INFO(logger, "fox jumps dog {} {}", 4.0f, true);
-  LOG_INFO(logger, "quick over example {} {} {} {} {} {}", 7UL, std::string("str2"), 5L, "example1", false, 1);
-  LOG_INFO(logger, "brown lazy over logging {} {} {} {} {} {} {} {}", std::string("str2"), 1, 8ULL,
-           static_cast<unsigned short>(10), 5L, 4.0f, true, 3.0);
-  LOG_INFO(logger, "over jumps example {} {} {} {} {} {} {}", 5L, "example3", 4.0f, 7UL, "example2",
-           static_cast<unsigned short>(10), true);
-  LOG_INFO(logger, "jumps brown example {} {} {} {} {} {} {}", 2, 8ULL, 1, std::string("str1"),
-           std::string_view("view1"), false, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "jumps quick brown lazy {} {}", false, 8ULL);
-  LOG_INFO(logger, "example quick lazy {} {} {} {} {} {} {} {} {} {}", 3.0, 2,
-           static_cast<unsigned short>(10), 7UL, 6LL, std::string("str1"), 1, std::string("str2"),
-           "example3", std::string_view("view1"));
-  LOG_INFO(logger, "lazy logging quick {} {} {} {} {} {} {} {}", 4.0f, true, 1, 5L, 3.0, 2,
-           std::string_view("view1"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "lazy brown dog fox {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           false, static_cast<short>(9), "example1", 4.0f, 7UL, static_cast<unsigned short>(10),
-           3.0, "example3");
-  LOG_INFO(logger, "quick logging brown over {} {} {} {} {} {}", std::string_view("view2"),
-           "example2", 6LL, static_cast<short>(9), static_cast<unsigned short>(10), 4.0f);
-  LOG_INFO(logger, "logging fox example {} {} {} {} {} {} {}", 5L, std::string_view("view2"), 6LL,
-           "example3", 7UL, std::string("str1"), 2);
-  LOG_INFO(logger, "jumps lazy quick dog {} {} {} {}", 7UL, 5L, 6LL, std::string("str1"));
-  LOG_INFO(logger, "jumps over lazy {} {} {} {} {} {}", "example2", static_cast<short>(9), 8ULL, 5L,
-           1, "example3");
-  LOG_INFO(logger, "dog jumps fox {} {} {} {} {}", 3.0, std::string_view("view2"), 8ULL,
-           static_cast<short>(9), 2);
-  LOG_INFO(logger, "quick example fox {} {} {} {} {}", 8ULL, true, 7UL, static_cast<short>(9),
-           "example2");
-  LOG_INFO(logger, "test quick fox logging {} {} {} {} {} {}", "example1", false,
-           std::string("str2"), static_cast<short>(9), 3.0, "example2");
-  LOG_INFO(logger, "jumps logging example quick {} {} {}", 4.0f, std::string("str1"), 8ULL);
-  LOG_INFO(logger, "dog brown logging {} {}", false, "example2");
-  LOG_INFO(logger, "dog fox brown quick {} {} {} {} {}", "example3", 1, std::string_view("view1"),
-           static_cast<short>(9), 8ULL);
-  LOG_INFO(logger, "quick jumps test dog {} {}", 7UL, 8ULL);
-  LOG_INFO(logger, "fox example quick {} {} {} {} {} {} {} {} {} {}", 2, 4.0f, 1, 6LL, std::string("str1"),
-           "example2", std::string_view("view1"), 7UL, false, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "test quick logging {} {} {} {} {} {} {}", std::string("str2"), false, 2, 7UL,
-           8ULL, 4.0f, static_cast<short>(9));
-  LOG_INFO(logger, "over test brown {} {} {} {} {} {} {} {} {} {}", 8ULL, 6LL, false, true,
-           "example1", "example2", 7UL, std::string("str1"), 5L, std::string_view("view1"));
-  LOG_INFO(logger, "test example over lazy {}", 8ULL);
-  LOG_INFO(logger, "quick dog over {}", 4.0f);
-  LOG_INFO(logger, "example quick jumps {} {} {}", 8ULL, std::string("str2"), 4.0f);
-  LOG_INFO(logger, "fox brown lazy {} {} {} {} {}", 3.0, false, static_cast<unsigned short>(10),
-           "example1", 1);
-  LOG_INFO(logger, "quick lazy jumps brown {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           7UL, true, std::string("str1"), 1, "example1", std::string_view("view1"));
-  LOG_INFO(logger, "over jumps logging quick {} {} {} {} {}", "example3", std::string("str2"), true, 5L, 2);
-  LOG_INFO(logger, "quick fox logging {} {} {} {}", 6LL, 2, 7UL, 1);
-  LOG_INFO(logger, "dog fox quick jumps {} {}", 6LL, static_cast<short>(9));
-  LOG_INFO(logger, "dog over jumps fox {} {}", true, 5L);
-  LOG_INFO(logger, "logging example dog jumps {} {} {} {}", 4.0f, "example2", static_cast<short>(9),
-           std::string_view("view1"));
-  LOG_INFO(logger, "logging fox test {} {} {} {} {} {} {} {} {} {}", "example1", 7UL, "example2", 2,
-           1, 3.0, std::string("str2"), 5L, 4.0f, "example3");
-  LOG_INFO(logger, "logging fox quick brown {} {} {}", "example1", 3.0, 6LL);
-  LOG_INFO(logger, "quick lazy brown test {} {} {} {}", "example1", std::string_view("view1"),
-           std::string("str1"), std::string_view("view2"));
-  LOG_INFO(logger, "over fox dog {} {} {} {} {} {} {} {}", "example1", static_cast<unsigned short>(10),
-           true, 5L, std::string_view("view2"), 3.0, std::string("str1"), 2);
-  LOG_INFO(logger, "jumps logging over {} {} {} {} {} {} {} {} {} {}", 8ULL, std::string("str2"), 7UL,
-           "example3", 4.0f, static_cast<unsigned short>(10), std::string_view("view1"), 2, 3.0, 6LL);
-  LOG_INFO(logger, "jumps fox over {} {} {} {}", std::string_view("view2"), 5L, 7UL, std::string_view("view1"));
-  LOG_INFO(logger, "example brown over jumps {}", 7UL);
-  LOG_INFO(logger, "fox example jumps test {}", true);
-  LOG_INFO(logger, "fox test over {} {} {}", std::string_view("view1"), "example3", std::string("str1"));
-  LOG_INFO(logger, "logging dog brown over {} {} {} {} {}", 6LL, std::string_view("view2"),
-           std::string("str2"), 5L, "example1");
-  LOG_INFO(logger, "fox example dog {} {} {} {} {} {}", 2, 1, static_cast<unsigned short>(10), 4.0f,
-           std::string("str2"), std::string_view("view2"));
-  LOG_INFO(logger, "fox dog jumps {} {} {} {} {} {} {} {} {}", "example2", std::string("str1"),
-           std::string_view("view2"), std::string_view("view1"), 8ULL, 4.0f, 2, "example3",
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox logging dog {} {} {} {} {} {} {} {}", "example1", 1, std::string("str1"),
-           static_cast<unsigned short>(10), "example2", false, 6LL, "example3");
-  LOG_INFO(logger, "quick test jumps {} {} {} {}", std::string("str2"), 6LL,
-           static_cast<unsigned short>(10), false);
-  LOG_INFO(logger, "over fox quick dog {} {} {} {} {} {}", std::string("str1"), true,
-           std::string("str2"), 4.0f, 7UL, 2);
-  LOG_INFO(logger, "fox dog test {} {} {} {} {}", "example1", std::string("str1"), 6LL,
-           static_cast<unsigned short>(10), false);
-  LOG_INFO(logger, "brown jumps example over {} {} {} {} {} {} {} {} {}", std::string("str2"),
-           static_cast<short>(9), 5L, "example2", std::string("str1"), "example3",
-           std::string_view("view2"), 4.0f, 3.0);
-  LOG_INFO(logger, "quick logging dog {} {} {} {} {} {} {} {} {} {}", std::string("str2"), false,
-           8ULL, std::string("str1"), 3.0, 5L, 4.0f, 6LL, 7UL, "example2");
-  LOG_INFO(logger, "fox dog quick {} {} {} {} {}", 3.0, true, 4.0f, 2, "example1");
-  LOG_INFO(logger, "quick brown over logging {}", 2);
-  LOG_INFO(logger, "dog logging example {} {} {}", "example3", 1, "example1");
-  LOG_INFO(logger, "logging over jumps {} {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           4.0f, static_cast<unsigned short>(10), std::string_view("view1"), "example3", "example1",
-           std::string("str2"), "example2", 3.0, 6LL);
-  LOG_INFO(logger, "jumps quick over {} {} {} {} {} {} {}", "example1", false, true, "example3", 5L,
-           std::string("str2"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "logging lazy brown fox {}", 6LL);
-  LOG_INFO(logger, "over quick brown dog {} {} {} {}", "example3", std::string("str2"), 1, 4.0f);
-  LOG_INFO(logger, "brown logging fox jumps {} {} {}", true, 5L, 2);
-  LOG_INFO(logger, "example test fox {} {}", true, 1);
-  LOG_INFO(logger, "quick test fox logging {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           8ULL, 4.0f, std::string("str1"), 7UL, false);
-  LOG_INFO(logger, "dog logging fox test {} {} {} {} {} {} {}", false, "example3",
-           static_cast<unsigned short>(10), 5L, 2, 6LL, std::string("str1"));
-  LOG_INFO(logger, "dog example jumps {} {}", std::string("str1"), 7UL);
-  LOG_INFO(logger, "dog over jumps test {} {} {} {} {} {} {}", std::string("str2"), false, 4.0f,
-           std::string_view("view1"), static_cast<unsigned short>(10), true, 7UL);
-  LOG_INFO(logger, "lazy fox brown dog {} {}", std::string_view("view2"), 5L);
-  LOG_INFO(logger, "over quick test example {} {} {} {} {} {} {}", 7UL, 5L, 8ULL, 1,
-           static_cast<short>(9), std::string_view("view2"), std::string("str2"));
-  LOG_INFO(logger, "brown over fox example {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10), 5L,
-           std::string_view("view1"), std::string("str2"), static_cast<short>(9), 8ULL, "example3", 3.0);
-  LOG_INFO(logger, "logging jumps brown {} {} {} {}", 7UL, 3.0, true, "example1");
-  LOG_INFO(logger, "brown quick logging example {} {} {} {} {}", "example2",
-           static_cast<unsigned short>(10), 5L, static_cast<short>(9), 6LL);
-  LOG_INFO(logger, "jumps logging fox over {} {} {} {} {} {} {} {}", 3.0, 2, "example2", "example1",
-           4.0f, std::string("str1"), std::string_view("view2"), true);
-  LOG_INFO(logger, "over logging lazy dog {}", 6LL);
-  LOG_INFO(logger, "dog lazy over {}", std::string("str1"));
-  LOG_INFO(logger, "jumps over logging dog {} {} {} {} {} {} {} {}", 4.0f, "example1", 8ULL, false,
-           2, 5L, static_cast<short>(9), std::string_view("view1"));
-  LOG_INFO(logger, "brown quick jumps {} {} {} {} {} {} {} {}", std::string_view("view2"), true,
-           "example1", 8ULL, static_cast<unsigned short>(10), std::string("str2"), "example2",
-           std::string_view("view1"));
-  LOG_INFO(logger, "logging dog lazy {} {} {}", "example3", std::string_view("view1"), std::string("str1"));
-  LOG_INFO(logger, "test logging fox {} {}", 7UL, 8ULL);
-  LOG_INFO(logger, "fox brown lazy {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           static_cast<short>(9), 1, 8ULL, false, "example2", std::string("str1"), 7UL);
-  LOG_INFO(logger, "example fox dog {} {}", "example3", std::string_view("view2"));
-  LOG_INFO(logger, "logging dog jumps {} {} {} {} {} {} {} {} {}", "example3",
-           std::string_view("view2"), static_cast<unsigned short>(10), static_cast<short>(9), 7UL,
-           1, "example2", std::string("str1"), true);
-  LOG_INFO(logger, "example fox brown {} {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           static_cast<unsigned short>(10), 4.0f, 5L, 6LL, "example2", true, 2, "example1",
-           std::string("str2"));
-  LOG_INFO(logger, "fox over example {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10), 2,
-           3.0, std::string("str1"), std::string("str2"), true, 1, "example3");
-  LOG_INFO(logger, "example jumps brown fox {} {}", false, std::string_view("view2"));
-  LOG_INFO(logger, "brown jumps dog logging {} {} {} {} {} {} {} {}", 7UL, "example2", 6LL,
-           std::string_view("view1"), 1, static_cast<short>(9), std::string("str2"), 5L);
-  LOG_INFO(logger, "example test quick logging {} {} {} {} {} {} {}", std::string_view("view1"),
-           true, std::string("str2"), 7UL, std::string_view("view2"), "example3", 3.0);
-  LOG_INFO(logger, "over lazy example jumps {} {} {} {} {} {} {}", std::string_view("view2"),
-           "example2", std::string_view("view1"), 8ULL, 6LL, false, 3.0);
-  LOG_INFO(logger, "jumps dog quick logging {} {}", "example2", std::string_view("view2"));
-  LOG_INFO(logger, "lazy example fox test {} {}", std::string("str2"), "example1");
-  LOG_INFO(logger, "example quick jumps {}", "example2");
-  LOG_INFO(logger, "quick fox example {} {} {} {} {} {} {}", "example2", std::string("str2"), 1,
-           8ULL, true, "example1", 3.0);
-  LOG_INFO(logger, "lazy jumps dog {} {} {} {} {} {} {} {}", std::string_view("view1"),
-           static_cast<unsigned short>(10), std::string_view("view2"), 7UL, std::string("str2"),
-           false, 1, 6LL);
-  LOG_INFO(logger, "fox lazy over {} {} {}", static_cast<short>(9), 4.0f, "example1");
-  LOG_INFO(logger, "brown quick jumps test {} {} {} {} {} {} {} {}", 5L, 4.0f,
-           std::string_view("view2"), "example2", "example1", true, false, 2);
-  LOG_INFO(logger, "brown fox quick {} {} {}", "example3", static_cast<short>(9), std::string("str2"));
-  LOG_INFO(logger, "lazy dog quick {} {} {} {} {} {}", 8ULL, "example1", 7UL, "example3", 3.0, 4.0f);
-  LOG_INFO(logger, "over dog test {} {} {} {} {}", static_cast<short>(9), std::string("str2"),
-           std::string_view("view1"), std::string("str1"), true);
-  LOG_INFO(logger, "quick brown logging {} {} {} {} {} {} {} {} {} {}", 1, 2, "example2",
-           std::string("str2"), 5L, false, static_cast<unsigned short>(10), std::string("str1"),
-           std::string_view("view2"), "example1");
-  LOG_INFO(logger, "dog over test {}", std::string("str2"));
-  LOG_INFO(logger, "example logging fox test {} {} {}", true, 2, std::string_view("view1"));
-  LOG_INFO(logger, "logging fox quick {} {} {} {} {}", "example3", 6LL, true, 4.0f, 7UL);
-  LOG_INFO(logger, "logging brown test jumps {} {} {} {} {}", 2, 3.0, "example2", 5L, static_cast<short>(9));
-  LOG_INFO(logger, "dog example logging lazy {} {} {}", "example2", "example1", 2);
-  LOG_INFO(logger, "logging fox lazy jumps {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           false, "example2", 8ULL, "example1", "example3", 6LL);
-  LOG_INFO(logger, "test logging quick over {}", "example1");
-  LOG_INFO(logger, "test quick example {} {}", "example1", 1);
-  LOG_INFO(logger, "dog lazy test brown {} {} {} {} {} {} {} {} {} {}", 5L, 2, true, std::string("str1"),
-           "example2", std::string_view("view2"), 1, static_cast<unsigned short>(10), 3.0, 6LL);
-  LOG_INFO(logger, "over brown jumps fox {} {} {} {} {} {} {} {} {} {}",
-           static_cast<unsigned short>(10), 2, "example1", 6LL, "example3", 7UL,
-           std::string_view("view2"), 3.0, "example2", std::string_view("view1"));
-  LOG_INFO(logger, "dog quick test brown {} {} {} {}", std::string("str1"), "example2",
-           std::string("str2"), 8ULL);
-  LOG_INFO(logger, "logging fox brown {} {} {} {} {} {}", std::string("str1"), 6LL, 1, "example1", 4.0f, true);
-  LOG_INFO(logger, "jumps over test quick {} {} {} {} {} {} {}", std::string("str2"), 6LL, true,
-           "example2", 7UL, 5L, 3.0);
-  LOG_INFO(logger, "example logging over {} {} {} {} {}", std::string("str1"), 5L, "example2", false, 7UL);
-  LOG_INFO(logger, "example quick fox dog {} {} {} {} {} {}", std::string_view("view2"),
-           static_cast<short>(9), std::string("str1"), std::string("str2"), false, 1);
-  LOG_INFO(logger, "example dog lazy {} {} {}", 2, 6LL, 8ULL);
-  LOG_INFO(logger, "dog lazy example {} {} {} {} {} {}", 5L, "example2", "example3", 7UL,
-           std::string("str1"), 1);
-  LOG_INFO(logger, "brown lazy logging quick {}", static_cast<short>(9));
-  LOG_INFO(logger, "jumps test dog fox {} {} {} {} {} {} {} {}", 7UL, "example1", 5L, 6LL, 8ULL,
-           false, true, 4.0f);
-  LOG_INFO(logger, "dog quick logging test {} {} {} {} {}", 3.0, 2, true, 5L, std::string_view("view1"));
-  LOG_INFO(logger, "dog over lazy {} {} {} {} {} {} {}", 5L, "example3", std::string("str1"),
-           "example2", 6LL, 8ULL, std::string("str2"));
-  LOG_INFO(logger, "example quick jumps {} {} {} {}", "example2", static_cast<unsigned short>(10), false, 7UL);
-  LOG_INFO(logger, "quick fox brown {}", true);
-  LOG_INFO(logger, "jumps over lazy dog {} {} {} {} {} {} {}", 7UL, 6LL, 8ULL, false, 5L, 3.0, 2);
-  LOG_INFO(logger, "brown quick logging {} {} {}", 1, static_cast<unsigned short>(10), std::string("str1"));
-  LOG_INFO(logger, "jumps lazy example {} {} {} {} {}", 1, static_cast<unsigned short>(10), 6LL, 5L,
-           "example1");
-  LOG_INFO(logger, "example jumps quick {} {} {} {} {} {}", std::string_view("view1"),
-           std::string_view("view2"), 7UL, 3.0, 6LL, "example1");
-  LOG_INFO(logger, "over jumps logging {} {} {} {} {} {} {} {} {} {}", 2, "example1", 4.0f, 6LL,
-           7UL, 3.0, std::string_view("view2"), 1, static_cast<short>(9), 8ULL);
-  LOG_INFO(logger, "lazy jumps dog {} {} {} {}", static_cast<short>(9), 5L, 2, 4.0f);
-  LOG_INFO(logger, "fox dog jumps example {} {} {} {} {} {} {} {} {}", 5L, "example1", 4.0f, 2,
-           8ULL, static_cast<short>(9), "example2", 6LL, 7UL);
-  LOG_INFO(logger, "logging fox lazy jumps {} {} {} {} {} {} {} {} {}", 2, std::string("str1"),
-           std::string_view("view2"), std::string_view("view1"), 4.0f, false, "example2", 5L,
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "test quick brown example {} {} {} {} {} {} {}", 3.0, false, std::string("str1"),
-           true, 7UL, "example1", 2);
-  LOG_INFO(logger, "dog fox jumps {} {} {} {} {} {} {} {} {}", 4.0f, 1, 2, "example1",
-           static_cast<short>(9), "example3", 5L, 3.0, std::string("str2"));
-  LOG_INFO(logger, "dog fox brown {} {} {} {}", 2, 1, std::string_view("view1"), std::string("str2"));
-  LOG_INFO(logger, "lazy test brown example {} {} {} {} {} {}", "example1", true, "example2",
-           std::string("str2"), static_cast<short>(9), 3.0);
-  LOG_INFO(logger, "logging brown quick example {} {}", 5L, std::string("str1"));
-  LOG_INFO(logger, "example fox lazy dog {} {} {} {} {} {} {}", true, 1,
-           static_cast<unsigned short>(10), false, 5L, "example2", 6LL);
-  LOG_INFO(logger, "logging dog brown quick {} {} {} {} {}", static_cast<short>(9), 1,
-           std::string("str1"), 7UL, 4.0f);
-  LOG_INFO(logger, "logging lazy quick {}", false);
-  LOG_INFO(logger, "over lazy jumps {} {} {} {}", "example3", "example2", "example1", 2);
-  LOG_INFO(logger, "lazy dog fox {} {} {} {} {}", "example1", true, 3.0, std::string("str1"),
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "over logging example dog {} {} {} {} {} {}", true,
-           static_cast<unsigned short>(10), 1, "example1", std::string_view("view2"), "example3");
-  LOG_INFO(logger, "brown lazy example {} {} {} {} {} {} {}", 1, 6LL, 7UL, "example2", "example1",
-           std::string_view("view2"), false);
-  LOG_INFO(logger, "example over test {} {} {} {}", true, std::string_view("view1"),
-           static_cast<short>(9), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "test dog fox {} {} {} {} {} {} {} {}", "example3", std::string("str2"),
-           "example2", 3.0, 7UL, true, std::string_view("view1"), 6LL);
-  LOG_INFO(logger, "dog test fox {}", std::string_view("view1"));
-  LOG_INFO(logger, "jumps over lazy {} {} {} {} {}", std::string_view("view2"), false, "example3", 3.0, 4.0f);
-  LOG_INFO(logger, "example test over logging {} {} {} {} {} {} {} {} {}", 3.0, std::string("str2"),
-           std::string("str1"), 4.0f, 8ULL, 1, std::string_view("view1"),
-           static_cast<unsigned short>(10), 7UL);
-  LOG_INFO(logger, "quick dog logging {} {} {} {} {} {} {} {}", static_cast<short>(9), 8ULL, true,
-           2, std::string("str1"), "example1", 1, 3.0);
-  LOG_INFO(logger, "quick logging jumps {} {}", "example3", "example1");
-  LOG_INFO(logger, "example brown quick {}", "example1");
-  LOG_INFO(logger, "jumps fox logging test {} {}", static_cast<short>(9), 4.0f);
-  LOG_INFO(logger, "jumps fox lazy over {} {} {} {}", "example3", std::string("str2"), "example2", 5L);
-  LOG_INFO(logger, "example test logging {}", 7UL);
-  LOG_INFO(logger, "quick example dog {} {} {} {} {} {} {}", 4.0f, 6LL, 8ULL,
-           static_cast<unsigned short>(10), true, "example3", 2);
-  LOG_INFO(logger, "lazy test fox {} {}", static_cast<short>(9), "example1");
-  LOG_INFO(logger, "logging lazy dog jumps {}", false);
-  LOG_INFO(logger, "brown jumps lazy fox {} {} {} {} {} {} {}", 8ULL, "example3", "example1",
-           std::string_view("view2"), 3.0, std::string("str1"), 2);
-  LOG_INFO(logger, "lazy quick dog {} {} {} {} {}", 8ULL, std::string_view("view2"), 7UL, false,
-           std::string_view("view1"));
-  LOG_INFO(logger, "fox logging brown jumps {} {}", 8ULL, std::string("str1"));
-  LOG_INFO(logger, "lazy quick brown example {} {} {} {}", 4.0f, "example3", true, false);
-  LOG_INFO(logger, "dog example brown fox {} {} {} {} {} {} {} {} {}", false, 1, "example2", 4.0f,
-           8ULL, true, "example3", 2, std::string_view("view2"));
-  LOG_INFO(logger, "test quick over example {} {} {} {} {} {} {} {} {} {}", 2,
-           std::string_view("view2"), 3.0, 4.0f, false, "example2", 6LL, "example3", 5L, 7UL);
-  LOG_INFO(logger, "over dog fox {} {}", "example3", 8ULL);
-  LOG_INFO(logger, "fox over jumps {} {}", 3.0, 2);
-  LOG_INFO(logger, "jumps quick lazy over {} {}", static_cast<short>(9), 1);
-  LOG_INFO(logger, "logging fox jumps {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           std::string_view("view1"), "example2", 2, 4.0f, 6LL);
-  LOG_INFO(logger, "lazy jumps example test {} {} {}", static_cast<unsigned short>(10), 3.0, true);
-  LOG_INFO(logger, "lazy quick dog over {} {} {} {} {} {} {} {}", "example2",
-           static_cast<unsigned short>(10), std::string("str2"), false, true,
-           std::string_view("view1"), 8ULL, "example3");
-  LOG_INFO(logger, "logging test fox {} {} {} {}", static_cast<unsigned short>(10),
-           std::string_view("view2"), false, "example2");
-  LOG_INFO(logger, "example quick over {} {} {} {} {} {} {} {}", "example3", std::string_view("view1"),
-           4.0f, std::string("str1"), true, static_cast<short>(9), "example2", 1);
-  LOG_INFO(logger, "fox jumps quick lazy {} {}", 6LL, 1);
-  LOG_INFO(logger, "fox jumps logging brown {} {} {} {} {} {} {} {} {} {}", static_cast<short>(9), 1,
-           std::string("str1"), "example2", 5L, "example3", std::string_view("view2"), 8ULL, 4.0f, 2);
-  LOG_INFO(logger, "test over fox lazy {} {} {}", false, std::string("str2"), "example3");
-  LOG_INFO(logger, "jumps brown fox dog {} {} {} {}", true, 8ULL, std::string("str2"), "example3");
-  LOG_INFO(logger, "quick fox lazy dog {} {} {} {} {} {} {}", 7UL, "example1", 3.0, 4.0f,
-           static_cast<short>(9), static_cast<unsigned short>(10), 5L);
-  LOG_INFO(logger, "lazy example logging {} {} {} {} {} {} {} {} {} {}", true, 1, 7UL, 8ULL,
-           std::string("str2"), std::string_view("view1"), 2, false, 6LL, "example3");
-  LOG_INFO(logger, "dog brown logging {} {} {}", static_cast<unsigned short>(10), 8ULL, 7UL);
-  LOG_INFO(logger, "test example lazy logging {} {} {} {} {} {} {} {}", 8ULL, 3.0, 5L, 4.0f,
-           std::string_view("view1"), std::string("str2"), static_cast<unsigned short>(10),
-           "example1");
-  LOG_INFO(logger, "dog logging over {} {} {} {} {} {}", 2, std::string("str2"),
-           static_cast<short>(9), 8ULL, "example3", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "test fox over {} {} {} {} {} {}", true, static_cast<short>(9), 5L, 1,
-           std::string_view("view2"), "example2");
-  LOG_INFO(logger, "lazy fox logging {} {} {}", 3.0, std::string_view("view1"), std::string_view("view2"));
-  LOG_INFO(logger, "logging over example test {} {} {} {} {} {} {}", std::string_view("view1"),
-           std::string("str2"), 2, "example3", 4.0f, 5L, "example1");
-  LOG_INFO(logger, "fox example lazy over {} {} {} {} {} {} {} {}", "example1", false, true, 2, 5L,
-           static_cast<unsigned short>(10), "example2", 7UL);
-  LOG_INFO(logger, "example fox lazy test {} {} {} {} {} {} {}", std::string_view("view2"),
-           std::string("str2"), static_cast<short>(9), std::string_view("view1"), 7UL, "example2", 6LL);
-  LOG_INFO(logger, "quick test jumps example {} {} {} {}", "example3", 6LL, std::string_view("view1"), 3.0);
-  LOG_INFO(logger, "jumps over brown example {} {}", 4.0f, 8ULL);
-  LOG_INFO(logger, "jumps quick dog {} {} {} {} {} {}", 3.0, 8ULL, 7UL, 5L, "example1", std::string("str1"));
-  LOG_INFO(logger, "quick dog brown lazy {} {} {} {}", 2, true, 8ULL, static_cast<short>(9));
-  LOG_INFO(logger, "quick fox jumps {} {} {} {} {} {} {} {} {}", 8ULL, 7UL, static_cast<short>(9),
-           2, 4.0f, 1, std::string_view("view2"), std::string_view("view1"), std::string("str2"));
-  LOG_INFO(logger, "lazy example test logging {} {} {} {} {} {} {} {} {} {}", 5L, 2, 3.0, std::string("str1"),
-           "example2", std::string_view("view2"), 1, std::string("str2"), true, "example1");
-  LOG_INFO(logger, "fox lazy jumps {} {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           "example1", std::string_view("view1"), 2, 6LL, 4.0f, "example2",
-           static_cast<unsigned short>(10), 1, true);
-  LOG_INFO(logger, "dog test quick jumps {} {} {}", static_cast<unsigned short>(10), 1, 6LL);
-  LOG_INFO(logger, "logging brown dog quick {} {} {} {}", true, 6LL, 4.0f, static_cast<short>(9));
-  LOG_INFO(logger, "lazy over dog logging {} {} {} {} {} {} {}", "example2", "example3", 4.0f, 5L,
-           true, static_cast<unsigned short>(10), std::string("str1"));
-  LOG_INFO(logger, "lazy quick logging {} {} {} {}", 3.0, std::string("str1"), 2, std::string("str2"));
-  LOG_INFO(logger, "dog jumps logging lazy {} {}", 6LL, 4.0f);
-  LOG_INFO(logger, "logging fox dog quick {} {} {} {} {} {} {} {}", std::string_view("view1"),
-           "example2", true, "example1", 1, std::string_view("view2"), 7UL, 2);
-  LOG_INFO(logger, "brown logging over {} {} {} {} {} {} {}", std::string("str1"), 5L,
-           std::string("str2"), static_cast<unsigned short>(10), "example3", 8ULL, "example1");
-  LOG_INFO(logger, "test fox dog {} {} {}", std::string("str2"), static_cast<unsigned short>(10), 2);
-  LOG_INFO(logger, "jumps fox brown {} {} {} {} {} {} {} {} {} {}", "example3",
-           static_cast<short>(9), 5L, 8ULL, 3.0, std::string_view("view2"), 2, "example1", 4.0f, 1);
-  LOG_INFO(logger, "jumps lazy test dog {} {} {} {} {} {} {}", 3.0, true, 7UL, 4.0f, 6LL,
-           std::string("str1"), 2);
-  LOG_INFO(logger, "logging quick brown lazy {} {} {} {} {}", false, std::string_view("view2"),
-           std::string_view("view1"), 1, "example1");
-  LOG_INFO(logger, "over brown fox logging {} {} {} {} {} {}", 5L, static_cast<short>(9),
-           std::string("str2"), "example3", std::string("str1"), 8ULL);
-  LOG_INFO(logger, "quick brown logging {} {} {} {} {} {} {} {} {} {}", std::string("str1"),
-           "example3", "example1", 5L, static_cast<short>(9), 1, "example2", 7UL, 2, 8ULL);
-  LOG_INFO(logger, "quick brown logging {} {} {} {} {} {} {} {} {} {}",
-           static_cast<unsigned short>(10), static_cast<short>(9), std::string_view("view2"), 6LL,
-           "example1", 7UL, 4.0f, false, std::string("str2"), 8ULL);
-  LOG_INFO(logger, "fox dog lazy test {} {} {}", std::string("str2"), static_cast<short>(9), 5L);
-  LOG_INFO(logger, "quick example over {} {} {} {} {} {} {} {} {} {}", 6LL,
-           std::string_view("view2"), static_cast<unsigned short>(10), true, 2,
-           static_cast<short>(9), "example1", std::string("str1"), std::string("str2"), "example2");
-  LOG_INFO(logger, "over example fox {} {} {}", std::string("str2"), "example3", std::string_view("view1"));
-  LOG_INFO(logger, "brown logging test {} {} {} {} {}", std::string("str1"),
-           std::string_view("view1"), std::string("str2"), false, 1);
-  LOG_INFO(logger, "logging quick test dog {} {} {} {} {}", 8ULL, std::string_view("view2"),
-           std::string_view("view1"), "example1", true);
-  LOG_INFO(logger, "dog example brown lazy {} {} {} {} {} {} {}", "example3",
-           std::string_view("view1"), static_cast<unsigned short>(10), 2, 5L, "example2", true);
-  LOG_INFO(logger, "jumps brown fox {} {} {} {} {} {} {} {} {}", "example1", 4.0f, std::string("str1"), 8ULL,
-           std::string_view("view1"), static_cast<short>(9), "example3", true, std::string_view("view2"));
-  LOG_INFO(logger, "logging over lazy {} {} {} {}", 2, false, 1, std::string_view("view2"));
-  LOG_INFO(logger, "example quick brown fox {} {} {} {} {}", 6LL, false, 3.0, 2, static_cast<short>(9));
-  LOG_INFO(logger, "test fox over logging {} {} {} {} {} {} {} {} {}", 2, 4.0f, 8ULL, 7UL,
-           "example1", std::string_view("view2"), false, "example2", 5L);
-  LOG_INFO(logger, "test lazy fox {} {} {} {} {} {}", 7UL, static_cast<short>(9), 4.0f,
-           std::string_view("view1"), "example2", "example3");
-  LOG_INFO(logger, "brown logging lazy {} {} {} {} {} {} {}", 4.0f, 7UL, std::string_view("view2"),
-           8ULL, static_cast<unsigned short>(10), "example2", "example1");
-  LOG_INFO(logger, "test lazy over {} {} {} {} {} {} {} {} {} {}", 7UL, std::string_view("view2"),
-           2, true, "example1", 4.0f, false, std::string("str1"), "example2", "example3");
-  LOG_INFO(logger, "logging over test {} {} {} {}", 5L, "example1", static_cast<unsigned short>(10), 7UL);
-  LOG_INFO(logger, "over dog lazy quick {} {}", 8ULL, 6LL);
-  LOG_INFO(logger, "brown example quick {}", "example1");
-  LOG_INFO(logger, "test logging example fox {} {} {} {} {} {} {} {} {}", static_cast<short>(9),
-           "example1", "example2", 4.0f, 3.0, std::string_view("view2"), 7UL, 5L, 8ULL);
-  LOG_INFO(logger, "quick example fox {}", true);
-  LOG_INFO(logger, "test dog fox {}", std::string_view("view1"));
-  LOG_INFO(logger, "quick lazy over test {} {} {} {} {} {} {} {}", 8ULL, 2, std::string("str1"),
-           "example2", "example1", 3.0, std::string_view("view1"), std::string_view("view2"));
-  LOG_INFO(logger, "fox dog jumps {} {} {} {} {} {} {} {} {} {}", std::string("str1"), 7UL,
-           "example1", 8ULL, 1, "example2", static_cast<short>(9), std::string_view("view1"), 2, false);
-  LOG_INFO(logger, "example logging quick dog {} {} {} {} {} {}", static_cast<short>(9), "example2",
-           std::string("str2"), 5L, 8ULL, std::string_view("view2"));
-  LOG_INFO(logger, "logging dog quick fox {} {} {} {} {} {} {} {} {}", std::string("str1"), 4.0f,
-           std::string("str2"), static_cast<short>(9), 3.0, static_cast<unsigned short>(10),
-           std::string_view("view2"), "example1", 5L);
-  LOG_INFO(logger, "over dog jumps {} {} {} {}", std::string_view("view2"), static_cast<short>(9),
-           4.0f, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "logging example fox jumps {} {} {} {} {} {} {}", true, false,
-           static_cast<short>(9), 5L, 7UL, 6LL, std::string_view("view2"));
-  LOG_INFO(logger, "over quick brown {} {} {} {} {} {} {} {}", 1, 2, false, true, 4.0f,
-           std::string_view("view2"), static_cast<unsigned short>(10), std::string("str2"));
-  LOG_INFO(logger, "brown lazy logging {} {} {} {} {} {}", "example3", 3.0,
-           static_cast<unsigned short>(10), 8ULL, 6LL, std::string("str1"));
-  LOG_INFO(logger, "example over dog {} {} {} {} {} {} {} {} {}", "example2", 2, 7UL, true, 8ULL,
-           "example3", 4.0f, 1, false);
-  LOG_INFO(logger, "example over fox {}", "example1");
-  LOG_INFO(logger, "over example brown {}", "example1");
-  LOG_INFO(logger, "over jumps fox lazy {} {} {} {} {} {} {} {} {} {}", 2, 4.0f, 8ULL,
-           std::string_view("view1"), static_cast<short>(9), true, std::string("str1"), "example2",
-           std::string_view("view2"), 6LL);
-  LOG_INFO(logger, "brown logging example {} {}", "example3", std::string_view("view2"));
-  LOG_INFO(logger, "brown over fox {} {} {} {} {} {} {} {}", 1, "example1", std::string("str2"),
-           true, std::string_view("view1"), std::string_view("view2"), 3.0, static_cast<short>(9));
-  LOG_INFO(logger, "dog over quick {} {} {} {} {}", std::string("str2"), 8ULL, 4.0f, 5L,
-           static_cast<short>(9));
-  LOG_INFO(logger, "brown dog quick lazy {} {} {} {} {}", "example3", 3.0, 7UL, "example1", std::string("str1"));
-  LOG_INFO(logger, "dog lazy logging quick {} {} {} {} {}", std::string_view("view1"), 6LL, 2,
-           "example1", "example2");
-  LOG_INFO(logger, "over quick test {} {} {} {}", std::string("str1"), 3.0, 6LL, std::string_view("view1"));
-  LOG_INFO(logger, "fox brown quick lazy {} {} {} {}", 3.0, "example3", 5L, std::string("str2"));
-  LOG_INFO(logger, "example over lazy {} {} {}", 7UL, 5L, 6LL);
-  LOG_INFO(logger, "quick example dog {} {} {} {}", "example1", std::string("str2"),
-           std::string_view("view2"), 5L);
-  LOG_INFO(logger, "example brown over logging {} {} {} {} {} {} {} {} {}", std::string("str2"),
-           6LL, "example3", "example2", 4.0f, false, static_cast<unsigned short>(10), 1, 2);
-  LOG_INFO(logger, "test brown quick {} {} {} {} {} {} {} {} {} {}", std::string("str2"), 7UL,
-           std::string_view("view1"), true, "example1", 6LL, static_cast<short>(9), 1,
-           std::string("str1"), 5L);
-  LOG_INFO(logger, "brown dog jumps {} {} {} {} {} {} {} {} {} {}", 7UL, static_cast<unsigned short>(10),
-           false, true, 8ULL, 1, 4.0f, std::string("str1"), "example3", std::string_view("view2"));
-  LOG_INFO(logger, "example lazy over test {} {} {} {} {}", 1, 3.0, 2, static_cast<unsigned short>(10), 7UL);
-  LOG_INFO(logger, "lazy quick fox example {} {} {} {} {} {}", "example3", "example2", 2,
-           std::string("str1"), static_cast<unsigned short>(10), 4.0f);
-  LOG_INFO(logger, "quick fox dog lazy {} {} {} {} {} {} {} {} {} {}", 5L, std::string_view("view2"),
-           4.0f, 3.0, 2, std::string("str2"), "example1", 7UL, "example2", 6LL);
-  LOG_INFO(logger, "quick jumps over {} {} {} {} {} {} {}", 3.0, true, 2, "example2",
-           std::string("str2"), std::string_view("view2"), 7UL);
-  LOG_INFO(logger, "over jumps fox {} {} {} {} {}", "example3", std::string("str1"),
-           static_cast<short>(9), std::string_view("view2"), 2);
-  LOG_INFO(logger, "quick brown example {} {} {} {} {} {} {}", "example1",
-           std::string_view("view2"), true, "example2", false, 3.0, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "test dog lazy {} {} {} {} {} {} {}", 5L, std::string("str1"), 8ULL, 2,
-           "example2", true, false);
-  LOG_INFO(logger, "brown lazy example {} {} {}", "example3", "example1", std::string_view("view2"));
-  LOG_INFO(logger, "test logging brown {} {} {} {} {} {} {} {}", 5L, 8ULL, false, "example1",
-           "example3", 1, static_cast<short>(9), std::string_view("view1"));
-  LOG_INFO(logger, "fox lazy over {} {} {} {} {} {} {}", 3.0, 5L, std::string_view("view2"), 2,
-           static_cast<unsigned short>(10), static_cast<short>(9), 7UL);
-  LOG_INFO(logger, "logging jumps over {} {} {} {}", "example2", 4.0f, 5L, std::string_view("view2"));
-  LOG_INFO(logger, "jumps lazy quick brown {} {} {} {} {} {} {} {} {}", "example2", 4.0f, "example3",
-           static_cast<short>(9), 2, 7UL, 5L, std::string("str1"), std::string_view("view1"));
-  LOG_INFO(logger, "jumps example lazy dog {} {} {} {} {}", static_cast<short>(9),
-           std::string("str2"), 3.0, static_cast<unsigned short>(10), false);
-  LOG_INFO(logger, "lazy over example {} {} {} {} {}", 2, "example1",
-           static_cast<unsigned short>(10), std::string("str2"), "example2");
-  LOG_INFO(logger, "quick logging brown fox {} {}", std::string("str1"), 7UL);
-  LOG_INFO(logger, "over test brown quick {}", true);
-  LOG_INFO(logger, "lazy over dog brown {} {} {} {} {}", 2, 1, "example2", true, "example1");
-  LOG_INFO(logger, "dog test fox {} {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           false, std::string_view("view2"), std::string_view("view1"), 2, "example1",
-           static_cast<short>(9), "example3", "example2", std::string("str2"));
-  LOG_INFO(logger, "over dog quick {} {} {} {} {} {}", "example2", 5L, static_cast<short>(9), 1, true, 3.0);
-  LOG_INFO(logger, "logging jumps example fox {} {} {} {} {} {}", std::string("str2"), 2, false,
-           "example3", "example1", static_cast<short>(9));
-  LOG_INFO(logger, "jumps dog example {}", std::string("str1"));
-  LOG_INFO(logger, "over logging fox {} {} {} {} {} {} {} {}", "example3", std::string_view("view2"),
-           4.0f, false, 1, std::string("str2"), 5L, std::string_view("view1"));
-  LOG_INFO(logger, "over brown fox lazy {} {} {} {} {}", true, 8ULL, "example2",
-           std::string_view("view2"), static_cast<short>(9));
-  LOG_INFO(logger, "fox lazy over {} {} {} {} {} {} {} {} {} {}", "example3", std::string("str1"), false,
-           "example1", 1, "example2", 5L, std::string_view("view1"), static_cast<unsigned short>(10), 6LL);
-  LOG_INFO(logger, "example dog brown {} {} {} {} {} {} {} {}", true, "example1", std::string_view("view1"),
-           std::string_view("view2"), "example2", 5L, static_cast<unsigned short>(10), false);
-  LOG_INFO(logger, "jumps dog test over {} {} {} {} {}", std::string("str2"), "example2", 2, 3.0,
-           std::string_view("view1"));
-  LOG_INFO(logger, "test over brown dog {} {} {} {} {} {}", std::string("str1"), 5L, false,
-           static_cast<short>(9), std::string("str2"), std::string_view("view2"));
-  LOG_INFO(logger, "jumps example dog logging {} {}", "example3", true);
-  LOG_INFO(logger, "dog quick jumps {} {} {} {}", 3.0, static_cast<short>(9), false, 4.0f);
-  LOG_INFO(logger, "dog over example logging {} {}", 4.0f, std::string("str1"));
-  LOG_INFO(logger, "brown fox logging {} {} {} {} {} {} {}", false, 5L, 7UL, std::string_view("view1"),
-           static_cast<short>(9), static_cast<unsigned short>(10), "example3");
-  LOG_INFO(logger, "brown fox quick dog {} {} {} {} {} {} {}", 4.0f, true, "example2",
-           std::string_view("view1"), 3.0, 7UL, 6LL);
-  LOG_INFO(logger, "lazy dog quick test {} {} {} {} {}", static_cast<short>(9), std::string("str1"),
-           "example1", 2, std::string_view("view2"));
-  LOG_INFO(logger, "logging example dog {} {} {} {} {} {}", 7UL, static_cast<short>(9), false, 1, 2,
-           "example2");
-  LOG_INFO(logger, "jumps dog example test {} {} {} {} {} {}", 6LL, 4.0f, 7UL, "example1", false,
-           std::string("str1"));
-  LOG_INFO(logger, "jumps brown example over {} {} {}", 5L, 8ULL, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "logging fox dog {} {} {} {} {} {}", true, 6LL, 3.0, 1, false, 8ULL);
-  LOG_INFO(logger, "example logging brown {} {}", static_cast<unsigned short>(10), 5L);
-  LOG_INFO(logger, "jumps example test quick {} {} {} {} {}", 5L, std::string("str1"),
-           static_cast<unsigned short>(10), 1, true);
-  LOG_INFO(logger, "fox jumps example test {}", "example3");
-  LOG_INFO(logger, "over test quick dog {} {} {} {}", static_cast<unsigned short>(10), 6LL, 8ULL,
-           "example2");
-  LOG_INFO(logger, "quick example jumps dog {} {} {} {} {} {} {}", false, 7UL, 5L,
-           static_cast<short>(9), "example3", std::string("str1"), true);
-  LOG_INFO(logger, "test logging jumps lazy {} {} {} {} {} {}", std::string_view("view1"), 7UL, 1,
-           2, "example1", false);
-  LOG_INFO(logger, "example logging dog over {} {} {} {} {} {} {} {}", 1, 5L, "example2",
-           static_cast<unsigned short>(10), 3.0, std::string_view("view1"), false, 4.0f);
-  LOG_INFO(logger, "test over lazy dog {} {} {} {} {} {} {} {} {}", std::string("str2"), "example1",
-           true, 1, "example3", 5L, static_cast<unsigned short>(10), std::string_view("view2"), 4.0f);
-  LOG_INFO(logger, "quick lazy example brown {} {} {} {}", "example1", std::string("str2"),
-           "example3", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "lazy example over {}", std::string("str2"));
-  LOG_INFO(logger, "jumps over dog {} {} {} {} {} {} {} {} {} {}", std::string_view("view1"), 1,
-           "example3", 7UL, std::string("str2"), static_cast<short>(9), "example2",
-           std::string("str1"), 3.0, true);
-  LOG_INFO(logger, "fox jumps brown {} {} {}", std::string_view("view1"), std::string("str1"), 5L);
-  LOG_INFO(logger, "dog quick jumps logging {} {} {} {} {} {} {} {} {} {}", 6LL,
-           std::string_view("view1"), true, 8ULL, false, std::string("str1"), 3.0,
-           std::string("str2"), "example2", std::string_view("view2"));
-  LOG_INFO(logger, "example fox lazy logging {} {} {} {} {} {}", "example1", true,
-           std::string("str2"), 6LL, std::string_view("view2"), 4.0f);
-  LOG_INFO(logger, "over fox jumps brown {} {} {} {} {} {}", static_cast<short>(9), true, false, 5L,
-           std::string_view("view2"), 6LL);
-  LOG_INFO(logger, "dog logging over lazy {} {}", "example3", 5L);
-  LOG_INFO(logger, "example test lazy brown {} {} {} {} {} {} {} {} {}", 8ULL, std::string_view("view2"),
-           "example1", "example3", static_cast<short>(9), 3.0, std::string("str1"), 5L, 7UL);
-  LOG_INFO(logger, "logging quick over dog {} {} {} {} {} {} {} {} {}", std::string_view("view2"), 7UL,
-           "example1", false, static_cast<short>(9), true, "example2", 5L, std::string_view("view1"));
-  LOG_INFO(logger, "test logging lazy fox {} {} {} {} {} {} {} {}", 6LL, 7UL, 2, "example2",
-           std::string("str2"), "example1", 5L, "example3");
-  LOG_INFO(logger, "quick brown lazy {} {} {} {}", static_cast<short>(9),
-           static_cast<unsigned short>(10), 8ULL, 7UL);
-  LOG_INFO(logger, "quick logging lazy dog {} {} {}", static_cast<short>(9), "example1",
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown lazy logging {}", std::string("str1"));
-  LOG_INFO(logger, "fox example lazy test {} {} {} {} {} {} {}", 8ULL, true, "example3",
-           static_cast<unsigned short>(10), false, static_cast<short>(9), 3.0);
-  LOG_INFO(logger, "over fox lazy {} {} {} {} {} {} {} {}", std::string("str2"),
-           std::string("str1"), 5L, "example3", "example2", std::string_view("view2"),
-           static_cast<unsigned short>(10), std::string_view("view1"));
-  LOG_INFO(logger, "lazy example dog {} {} {} {} {}", 2, 1, 8ULL, 7UL, 4.0f);
-  LOG_INFO(logger, "over test quick {} {} {} {} {} {} {} {} {} {}", std::string_view("view1"), 6LL, 1,
-           std::string("str1"), 4.0f, "example2", static_cast<unsigned short>(10), 2, "example1", 3.0);
-  LOG_INFO(logger, "brown test logging jumps {} {} {} {}", 2, 3.0, false, 5L);
-  LOG_INFO(logger, "over lazy dog logging {} {} {} {} {} {} {} {} {}", 2, 8ULL, 4.0f, 7UL,
-           std::string_view("view2"), static_cast<short>(9), 3.0, "example2", std::string_view("view1"));
-  LOG_INFO(logger, "dog test jumps {} {}", 6LL, static_cast<short>(9));
-  LOG_INFO(logger, "test fox example {} {} {} {}", true, 1, 6LL, std::string("str1"));
-  LOG_INFO(logger, "jumps logging quick example {} {} {} {} {} {}", std::string_view("view2"), 2,
-           8ULL, std::string("str2"), std::string("str1"), static_cast<short>(9));
-  LOG_INFO(logger, "over logging dog {} {} {} {} {} {} {}", true, "example3",
-           static_cast<unsigned short>(10), 3.0, "example2", std::string("str1"), 8ULL);
-  LOG_INFO(logger, "fox brown logging {} {} {} {} {} {} {} {}", "example2", 2, 6LL, "example3",
-           std::string_view("view1"), std::string_view("view2"), false, 7UL);
-  LOG_INFO(logger, "fox test over quick {} {}", std::string("str1"), 5L);
-  LOG_INFO(logger, "quick over brown {} {} {} {} {} {} {}", 8ULL, std::string("str2"), false, 2,
-           4.0f, std::string_view("view2"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "over fox lazy logging {} {} {} {} {} {} {}", 1, 5L, std::string_view("view1"),
-           6LL, 4.0f, "example3", "example2");
-  LOG_INFO(logger, "quick over example {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           "example1", false, true, std::string_view("view1"), 2, 6LL, 4.0f);
-  LOG_INFO(logger, "fox dog brown lazy {} {} {} {}", "example2", true, std::string("str2"), 3.0);
-  LOG_INFO(logger, "jumps dog test quick {} {}", 8ULL, std::string_view("view2"));
-  LOG_INFO(logger, "lazy quick fox jumps {} {} {} {} {} {} {}", std::string_view("view2"),
-           static_cast<unsigned short>(10), 3.0, static_cast<short>(9), 8ULL, 7UL, "example2");
-  LOG_INFO(logger, "quick example dog {} {} {} {} {} {} {} {} {}", std::string("str2"), false, 2,
-           6LL, std::string_view("view2"), std::string_view("view1"), 5L, 7UL, std::string("str1"));
-  LOG_INFO(logger, "over example lazy {} {} {} {} {} {} {}", 2, 8ULL, 5L, std::string_view("view2"),
-           "example2", false, std::string("str2"));
-  LOG_INFO(logger, "over jumps lazy test {} {} {} {}", true, std::string("str1"),
-           static_cast<unsigned short>(10), std::string("str2"));
-  LOG_INFO(logger, "lazy dog quick {}", std::string_view("view1"));
-  LOG_INFO(logger, "quick brown over {} {} {} {}", 4.0f, 1, std::string_view("view1"), "example2");
-  LOG_INFO(logger, "example quick jumps {} {} {} {}", 7UL, 4.0f, "example3", static_cast<short>(9));
-  LOG_INFO(logger, "jumps dog over {} {} {} {} {} {} {} {} {}", 2, 8ULL, 5L, 4.0f,
-           std::string_view("view2"), true, 7UL, 3.0, false);
-  LOG_INFO(logger, "fox lazy example dog {}", std::string("str2"));
-  LOG_INFO(logger, "logging over jumps {} {} {} {} {}", static_cast<unsigned short>(10), "example3",
-           std::string_view("view2"), 7UL, true);
-  LOG_INFO(logger, "brown test jumps lazy {} {} {} {} {}", 6LL, 7UL, 2, std::string_view("view1"), 4.0f);
-  LOG_INFO(logger, "over fox lazy dog {} {} {} {}", "example3", 1, 3.0, static_cast<short>(9));
-  LOG_INFO(logger, "jumps dog lazy logging {} {} {} {} {} {} {} {} {}", std::string("str1"), false,
-           "example3", 5L, std::string_view("view2"), std::string_view("view1"), 2,
-           static_cast<short>(9), true);
-  LOG_INFO(logger, "fox over lazy {} {} {} {} {} {} {} {}", 2, 4.0f, std::string("str2"),
-           "example3", 3.0, 1, 8ULL, "example2");
-  LOG_INFO(logger, "logging lazy jumps {} {} {} {} {}", static_cast<short>(9), 4.0f, 5L, 6LL,
-           std::string_view("view2"));
-  LOG_INFO(logger, "lazy logging fox {} {} {} {} {} {} {} {}", 4.0f, 6LL, static_cast<short>(9), 2,
-           std::string("str1"), "example1", std::string_view("view1"), 1);
-  LOG_INFO(logger, "over brown quick lazy {} {} {} {} {} {} {} {}", 5L, 8ULL, true, 7UL, "example1",
-           std::string("str1"), static_cast<unsigned short>(10), 1);
-  LOG_INFO(logger, "logging brown quick {} {} {} {} {} {} {} {}", 8ULL, false, "example2", true,
-           "example1", std::string_view("view1"), std::string_view("view2"), 7UL);
-  LOG_INFO(logger, "example logging brown {} {} {} {} {}", 7UL, false,
-           static_cast<unsigned short>(10), true, 5L);
-  LOG_INFO(logger, "lazy test jumps logging {} {} {} {} {} {}", static_cast<short>(9), true,
-           std::string("str1"), std::string_view("view2"), std::string_view("view1"), "example1");
-  LOG_INFO(logger, "test logging dog over {} {} {} {}", false, static_cast<short>(9), 3.0, true);
-  LOG_INFO(logger, "jumps over quick {} {} {} {} {}", 6LL, 3.0, std::string_view("view1"),
-           std::string_view("view2"), 7UL);
-  LOG_INFO(logger, "logging test quick {} {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10), 6LL,
-           std::string("str1"), static_cast<short>(9), "example2", true, 5L, std::string("str2"), 3.0, 2);
-  LOG_INFO(logger, "jumps lazy test over {} {} {} {}", false, 6LL, 8ULL, std::string("str2"));
-  LOG_INFO(logger, "brown example fox {} {}", std::string_view("view2"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "jumps brown example quick {} {} {} {}", 7UL, 2, 1, std::string_view("view2"));
-  LOG_INFO(logger, "over example lazy {}", "example3");
-  LOG_INFO(logger, "test jumps lazy over {} {} {} {} {} {} {}", 5L, "example3",
-           std::string_view("view1"), false, 2, std::string("str1"), 6LL);
-  LOG_INFO(logger, "logging over test brown {} {} {} {} {} {} {} {} {} {}", 8ULL, 1,
-           std::string("str2"), true, std::string("str1"), "example3", static_cast<short>(9),
-           std::string_view("view1"), std::string_view("view2"), "example1");
-  LOG_INFO(logger, "brown over test quick {} {} {} {} {} {} {} {} {} {}", 2, 7UL,
-           std::string_view("view1"), 1, true, false, 6LL, 5L, "example1", 8ULL);
-  LOG_INFO(logger, "lazy over jumps example {} {} {} {} {} {} {}", std::string_view("view2"), 3.0,
-           "example3", "example2", "example1", 6LL, 2);
-  LOG_INFO(logger, "test brown dog {} {} {} {} {} {} {} {} {} {}", static_cast<short>(9), 2,
-           std::string_view("view1"), std::string("str1"), 7UL, std::string_view("view2"),
-           static_cast<unsigned short>(10), "example1", "example2", 6LL);
-  LOG_INFO(logger, "dog fox logging quick {} {}", 5L, static_cast<short>(9));
-  LOG_INFO(logger, "jumps test quick {} {} {} {} {} {} {}", 8ULL, true, 2,
-           std::string_view("view2"), "example1", 1, 6LL);
-  LOG_INFO(logger, "lazy example quick logging {} {} {} {} {} {} {} {}", 1, std::string_view("view2"),
-           "example3", std::string("str1"), static_cast<short>(9), static_cast<unsigned short>(10), 7UL, 4.0f);
-  LOG_INFO(logger, "logging quick dog {} {} {}", "example2", std::string("str2"), 7UL);
-  LOG_INFO(logger, "jumps over quick {} {} {} {} {} {} {}", 4.0f, std::string("str2"), 6LL, false,
-           "example1", 5L, 8ULL);
-  LOG_INFO(logger, "quick test brown {} {} {} {} {} {} {}", 7UL, false, 1, 4.0f, "example3", 5L, 8ULL);
-  LOG_INFO(logger, "over fox example {}", std::string("str2"));
-  LOG_INFO(logger, "fox logging lazy {} {}", 5L, "example2");
-  LOG_INFO(logger, "lazy brown quick over {} {} {} {} {} {} {} {} {} {}", static_cast<short>(9),
-           std::string("str1"), 4.0f, true, 7UL, 2, "example2", 5L, false, 1);
-  LOG_INFO(logger, "quick dog over fox {} {} {}", false, "example2", std::string_view("view1"));
-  LOG_INFO(logger, "over dog quick {} {} {} {}", std::string_view("view2"),
-           static_cast<unsigned short>(10), 6LL, std::string("str1"));
-  LOG_INFO(logger, "dog over quick fox {} {}", "example2", "example1");
-  LOG_INFO(logger, "lazy fox quick {} {} {} {} {} {}", true, 2, std::string("str1"),
-           std::string("str2"), static_cast<unsigned short>(10), "example1");
-  LOG_INFO(logger, "lazy dog fox {}", "example3");
-  LOG_INFO(logger, "over example jumps dog {} {} {} {} {} {} {} {}", 4.0f, std::string("str2"),
-           static_cast<unsigned short>(10), 2, "example1", std::string_view("view2"),
-           std::string("str1"), static_cast<short>(9));
-  LOG_INFO(logger, "example quick test logging {} {} {} {} {} {} {} {} {}", std::string("str2"),
-           std::string_view("view1"), false, 1, 7UL, 2, 8ULL, "example1", "example2");
-  LOG_INFO(logger, "brown test lazy {} {} {} {}", static_cast<short>(9), 6LL, 2, 4.0f);
-  LOG_INFO(logger, "dog example logging {} {} {} {} {} {} {} {} {}", "example3",
-           std::string_view("view1"), 3.0, std::string_view("view2"),
-           static_cast<unsigned short>(10), true, 4.0f, 6LL, static_cast<short>(9));
-  LOG_INFO(logger, "over jumps test quick {} {} {} {} {} {}", std::string_view("view2"), 7UL, 8ULL,
-           std::string("str2"), 5L, "example1");
-  LOG_INFO(logger, "example brown fox {} {} {} {} {} {}", "example3", 4.0f, 7UL, 5L, 1, 2);
-  LOG_INFO(logger, "dog test quick {}", std::string_view("view2"));
-  LOG_INFO(logger, "example lazy quick {} {}", 3.0, static_cast<short>(9));
-  LOG_INFO(logger, "dog test fox {} {} {} {} {} {} {} {} {} {}", false, true, 2, std::string("str1"), 6LL,
-           "example2", std::string_view("view1"), std::string_view("view2"), std::string("str2"), 3.0);
-  LOG_INFO(logger, "brown quick example {} {}", std::string("str2"), 6LL);
-  LOG_INFO(logger, "dog brown quick {} {} {} {} {} {} {} {}", 1, 4.0f, 5L, true, 6LL,
-           std::string("str1"), "example3", false);
-  LOG_INFO(logger, "fox dog jumps quick {}", 8ULL);
-  LOG_INFO(logger, "lazy jumps test {} {} {} {} {} {}", 1, "example1", static_cast<short>(9), 3.0, false, 8ULL);
-  LOG_INFO(logger, "fox logging example {} {} {} {} {} {} {} {} {}", "example2", 5L, 4.0f, 1,
-           std::string_view("view1"), "example3", static_cast<short>(9), true, 6LL);
-  LOG_INFO(logger, "quick lazy brown {}", static_cast<short>(9));
-  LOG_INFO(logger, "test logging lazy {} {} {} {}", static_cast<unsigned short>(10),
-           std::string_view("view2"), 4.0f, std::string_view("view1"));
-  LOG_INFO(logger, "jumps dog over {} {}", false, 8ULL);
-  LOG_INFO(logger, "quick test lazy {}", true);
-  LOG_INFO(logger, "dog example logging lazy {} {} {}", 8ULL, std::string("str2"), "example2");
-  LOG_INFO(logger, "fox jumps dog over {} {} {} {} {} {}", 4.0f, "example3", 1, 8ULL, 2, true);
-  LOG_INFO(logger, "lazy fox over quick {} {} {} {} {} {} {} {}", std::string_view("view2"), 2, 5L,
-           static_cast<short>(9), 3.0, 6LL, "example3", 4.0f);
-  LOG_INFO(logger, "logging jumps fox lazy {} {} {} {} {}", std::string_view("view2"), false,
-           static_cast<short>(9), true, 8ULL);
-  LOG_INFO(logger, "lazy fox quick {} {} {}", "example2", std::string_view("view1"), true);
-  LOG_INFO(logger, "jumps dog lazy {} {} {}", static_cast<short>(9), std::string("str2"),
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "jumps quick logging test {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           "example1", false, 4.0f, 8ULL, std::string_view("view1"), static_cast<short>(9));
-  LOG_INFO(logger, "fox test jumps example {}", "example2");
-  LOG_INFO(logger, "example fox lazy quick {} {} {} {} {} {}", 8ULL, "example2", "example1", true,
-           std::string_view("view2"), 6LL);
-  LOG_INFO(logger, "test example over quick {} {} {} {}", 5L, "example2", false, 4.0f);
-  LOG_INFO(logger, "over dog example {} {} {}", 6LL, std::string_view("view2"), std::string("str1"));
-  LOG_INFO(logger, "jumps test fox logging {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           6LL, 7UL, std::string_view("view2"), static_cast<short>(9), "example1", true);
-  LOG_INFO(logger, "dog fox over {} {} {} {} {} {} {}", true, 7UL, static_cast<unsigned short>(10),
-           std::string("str1"), 3.0, std::string_view("view1"), 6LL);
-  LOG_INFO(logger, "over fox dog {} {} {} {} {} {} {} {} {} {}", 4.0f, "example3", true,
-           static_cast<short>(9), 5L, "example1", std::string("str2"), 3.0, "example2",
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "dog example brown jumps {} {} {} {} {} {}", static_cast<short>(9), 7UL, true,
-           3.0, std::string("str1"), 1);
-  LOG_INFO(logger, "lazy quick logging over {} {} {} {} {} {}", std::string_view("view1"),
-           std::string_view("view2"), "example3", std::string("str2"), 5L, static_cast<short>(9));
-  LOG_INFO(logger, "jumps test quick lazy {} {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           std::string_view("view1"), 3.0, 2, 4.0f, static_cast<short>(9), false, 5L,
-           static_cast<unsigned short>(10), "example1");
-  LOG_INFO(logger, "brown lazy fox jumps {} {} {} {} {} {} {} {} {}", 8ULL, std::string("str1"),
-           "example1", true, std::string_view("view1"), false, 2, 7UL, 4.0f);
-  LOG_INFO(logger, "example lazy logging fox {} {} {} {}", "example1", 3.0, "example2", 5L);
-  LOG_INFO(logger, "fox lazy test brown {}", true);
-  LOG_INFO(logger, "dog brown jumps {} {} {} {} {} {} {}", false, "example3", 2, 8ULL, "example1", 3.0, true);
-  LOG_INFO(logger, "quick test logging dog {} {} {}", 3.0, false, "example1");
-  LOG_INFO(logger, "test quick jumps {} {} {} {} {} {} {}", "example3", std::string("str2"), 8ULL,
-           std::string("str1"), std::string_view("view2"), true, static_cast<short>(9));
-  LOG_INFO(logger, "fox brown jumps {} {}", false, 3.0);
-  LOG_INFO(logger, "brown quick dog over {} {} {} {} {} {} {} {} {} {}", 2,
-           static_cast<unsigned short>(10), 1, "example1", std::string("str2"), true,
-           std::string_view("view2"), 6LL, 8ULL, std::string_view("view1"));
-  LOG_INFO(logger, "logging quick example {} {} {} {}", 5L, "example3", 4.0f, 1);
-  LOG_INFO(logger, "dog brown quick {}", 8ULL);
-  LOG_INFO(logger, "lazy brown test {} {} {} {} {} {} {} {}", std::string("str1"), "example1", true,
-           6LL, 5L, 1, "example3", 8ULL);
-  LOG_INFO(logger, "test example logging {} {}", 1, true);
-  LOG_INFO(logger, "test jumps quick fox {} {} {} {} {} {} {} {} {}", "example1", 5L, 4.0f, false,
-           8ULL, 7UL, static_cast<unsigned short>(10), 6LL, "example3");
-  LOG_INFO(logger, "lazy dog logging {} {} {}", "example3", std::string("str2"), 1);
-  LOG_INFO(logger, "over example dog quick {}", "example3");
-  LOG_INFO(logger, "test quick lazy logging {} {} {} {} {} {} {}", std::string_view("view1"), 5L,
-           "example3", 7UL, 3.0, true, 8ULL);
-  LOG_INFO(logger, "test dog lazy {} {} {} {}", static_cast<unsigned short>(10), 2,
-           std::string_view("view2"), static_cast<short>(9));
-  LOG_INFO(logger, "dog example jumps brown {} {} {}", "example3", 7UL, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown fox over dog {} {} {} {}", static_cast<unsigned short>(10), "example2", 2,
-           std::string_view("view1"));
-  LOG_INFO(logger, "test example quick logging {} {} {} {} {} {} {} {} {} {}", "example3",
-           "example1", 8ULL, std::string_view("view2"), false, true, 6LL, std::string("str2"), 5L, 7UL);
-  LOG_INFO(logger, "over example dog fox {} {} {} {} {} {} {} {} {} {}", 3.0, "example3", true,
-           4.0f, false, 8ULL, std::string("str2"), static_cast<short>(9), 6LL, 1);
-  LOG_INFO(logger, "example logging over dog {} {} {} {} {} {} {}", 6LL, std::string_view("view2"),
-           std::string("str1"), "example3", 1, std::string_view("view1"), 5L);
-  LOG_INFO(logger, "brown jumps logging quick {} {} {}", 2, 1, static_cast<short>(9));
-  LOG_INFO(logger, "dog test jumps {} {} {}", 6LL, 1, 3.0);
-  LOG_INFO(logger, "brown test dog quick {} {} {} {} {} {}", "example3", 1, static_cast<short>(9),
-           std::string_view("view1"), 8ULL, std::string_view("view2"));
-  LOG_INFO(logger, "quick jumps example dog {} {} {} {} {}", 2, std::string_view("view1"), 3.0,
-           static_cast<unsigned short>(10), 5L);
-  LOG_INFO(logger, "logging brown quick {} {} {}", 5L, 1, 4.0f);
-  LOG_INFO(logger, "logging jumps test brown {} {}", "example3", 6LL);
-  LOG_INFO(logger, "brown over example {}", 6LL);
-  LOG_INFO(logger, "fox dog example logging {} {} {} {} {} {} {} {}", false, static_cast<short>(9),
-           "example3", "example2", std::string("str2"), 8ULL, "example1", true);
-  LOG_INFO(logger, "logging test over brown {}", 4.0f);
-  LOG_INFO(logger, "over brown dog {} {} {} {} {} {} {} {} {} {}", 7UL, 4.0f, 2,
-           std::string_view("view1"), 3.0, 5L, 6LL, 8ULL, "example3", 1);
-  LOG_INFO(logger, "quick dog test {} {} {} {} {} {} {} {}", std::string_view("view1"), 6LL, 4.0f,
-           "example2", "example1", 1, 7UL, 3.0);
-  LOG_INFO(logger, "quick fox example test {} {} {} {} {} {}", "example3",
-           static_cast<unsigned short>(10), 2, 4.0f, 8ULL, std::string_view("view2"));
-  LOG_INFO(logger, "jumps dog logging fox {} {} {} {} {}", std::string("str2"),
-           static_cast<unsigned short>(10), "example3", 6LL, std::string("str1"));
-  LOG_INFO(logger, "lazy brown logging quick {} {} {} {} {}", static_cast<short>(9), 8ULL, true,
-           static_cast<unsigned short>(10), 1);
-  LOG_INFO(logger, "dog example jumps over {} {} {} {}", 2, 5L, 7UL, "example2");
-  LOG_INFO(logger, "example logging fox {} {} {} {} {} {} {} {} {}", 8ULL, true, static_cast<short>(9),
-           std::string("str1"), 4.0f, false, static_cast<unsigned short>(10), 7UL, "example1");
-  LOG_INFO(logger, "lazy over quick {} {} {} {} {} {} {}", false, "example2", 3.0,
-           std::string_view("view1"), std::string("str1"), 5L, 4.0f);
-  LOG_INFO(logger, "fox brown jumps {} {} {} {}", std::string("str1"), 4.0f, 5L, std::string("str2"));
-  LOG_INFO(logger, "logging test lazy {} {} {} {} {} {} {} {} {}", 8ULL, std::string("str1"),
-           std::string("str2"), std::string_view("view2"), 2, 5L, 1, 7UL, 4.0f);
-  LOG_INFO(logger, "brown example test {} {} {} {} {} {}", 4.0f, std::string_view("view2"), 2,
-           std::string("str2"), static_cast<unsigned short>(10), static_cast<short>(9));
-  LOG_INFO(logger, "logging over test dog {} {}", "example2", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown example over {} {} {} {} {}", static_cast<short>(9),
-           std::string_view("view1"), false, true, 8ULL);
-  LOG_INFO(logger, "logging brown quick {} {} {} {} {}", "example2", 7UL, 8ULL, 6LL, 3.0);
-  LOG_INFO(logger, "example jumps dog {} {} {} {} {}", std::string_view("view2"), 7UL, 6LL, true, 5L);
-  LOG_INFO(logger, "test lazy example {} {} {} {} {} {} {}", std::string_view("view1"), 5L, true,
-           std::string("str2"), 7UL, static_cast<unsigned short>(10), static_cast<short>(9));
-  LOG_INFO(logger, "over dog jumps {} {}", static_cast<short>(9), 8ULL);
-  LOG_INFO(logger, "over test jumps {} {} {} {} {} {}", 5L, 1, std::string("str1"), "example3",
-           std::string("str2"), 4.0f);
-  LOG_INFO(logger, "brown dog logging {} {} {} {} {} {}", 3.0, 8ULL, "example2", 5L,
-           std::string_view("view2"), "example1");
-  LOG_INFO(logger, "jumps dog example {} {} {} {} {}", "example2", 2, std::string("str2"),
-           "example3", 5L);
-  LOG_INFO(logger, "jumps dog logging fox {} {} {} {}", std::string("str1"), 3.0, false, std::string("str2"));
-  LOG_INFO(logger, "fox dog quick jumps {} {} {} {} {} {} {} {} {} {}", 2, "example1", 4.0f, 3.0,
-           5L, "example3", true, "example2", 6LL, 7UL);
-  LOG_INFO(logger, "dog example test quick {} {} {} {} {} {} {} {} {} {}", std::string("str1"),
-           "example1", 5L, 4.0f, 8ULL, true, 7UL, std::string_view("view2"), std::string("str2"),
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "quick jumps dog {} {} {} {} {} {} {} {} {}", "example3", "example2",
-           static_cast<unsigned short>(10), 4.0f, true, std::string_view("view1"), 1, 2, 6LL);
-  LOG_INFO(logger, "example jumps over logging {} {} {} {} {} {} {}", 1, false,
-           static_cast<short>(9), std::string_view("view2"), "example2", 7UL, std::string("str2"));
-  LOG_INFO(logger, "lazy over fox dog {} {} {} {} {} {} {} {}", 8ULL, 1, std::string("str1"), 2,
-           4.0f, 3.0, static_cast<unsigned short>(10), "example1");
-  LOG_INFO(logger, "brown over quick example {} {} {} {} {} {} {} {}", false, 3.0, 4.0f, "example3",
-           std::string_view("view2"), 7UL, std::string("str2"), true);
-  LOG_INFO(logger, "fox logging test over {} {} {} {} {} {} {} {}", 7UL, 8ULL,
-           static_cast<unsigned short>(10), 5L, "example1", 2, true, std::string_view("view2"));
-  LOG_INFO(logger, "brown example logging {} {} {} {} {} {}", true, std::string("str2"), 3.0,
-           "example1", std::string_view("view2"), 6LL);
-  LOG_INFO(logger, "brown lazy quick {} {} {} {} {} {} {} {} {}", true, 4.0f, std::string_view("view1"),
-           static_cast<unsigned short>(10), 3.0, 8ULL, std::string("str2"), 6LL, std::string_view("view2"));
-  LOG_INFO(logger, "brown over example {} {} {} {} {} {} {}", std::string_view("view2"), "example3",
-           static_cast<unsigned short>(10), 5L, std::string("str2"), static_cast<short>(9), 1);
-  LOG_INFO(logger, "jumps dog logging test {} {} {} {} {}", 3.0, std::string("str1"), "example1",
-           "example3", static_cast<short>(9));
-  LOG_INFO(logger, "jumps fox test quick {}", "example3");
-  LOG_INFO(logger, "quick dog logging lazy {} {} {} {} {}", 8ULL, "example2", static_cast<short>(9), 4.0f, 5L);
-  LOG_INFO(logger, "test example over {} {} {} {} {}", 7UL, std::string("str1"), 1, 8ULL,
-           std::string_view("view2"));
-  LOG_INFO(logger, "quick lazy brown {} {}", 8ULL, 6LL);
-  LOG_INFO(logger, "test brown fox {}", 1);
-  LOG_INFO(logger, "over example lazy {} {} {} {} {} {}", 2, 6LL, 1, 4.0f, std::string("str1"),
-           std::string_view("view1"));
-  LOG_INFO(logger, "fox test jumps {} {} {} {} {} {} {}", "example3", true, "example1",
-           std::string_view("view2"), 7UL, 5L, std::string("str1"));
-  LOG_INFO(logger, "logging lazy example {} {}", std::string_view("view2"), std::string_view("view1"));
-  LOG_INFO(logger, "logging fox dog {} {} {}", std::string("str2"), true, std::string_view("view2"));
-  LOG_INFO(logger, "jumps over brown {} {} {}", 4.0f, "example1", std::string_view("view1"));
-  LOG_INFO(logger, "over lazy dog brown {} {} {} {} {} {} {} {} {}", false, std::string_view("view2"),
-           std::string_view("view1"), 1, std::string("str1"), "example3", 3.0, "example1", 4.0f);
-  LOG_INFO(logger, "dog test brown lazy {} {} {} {} {} {} {}", std::string("str2"), true,
-           "example1", 2, std::string_view("view2"), "example3", 7UL);
-  LOG_INFO(logger, "example lazy quick dog {} {}", 4.0f, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "test brown lazy dog {}", 5L);
-  LOG_INFO(logger, "quick fox logging {} {} {} {} {} {}", std::string_view("view2"), "example1",
-           std::string_view("view1"), 8ULL, "example3", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "over dog quick fox {} {} {} {} {} {} {} {} {} {}", false, 3.0, std::string_view("view1"),
-           "example1", 1, static_cast<unsigned short>(10), 2, static_cast<short>(9), 6LL, 4.0f);
-  LOG_INFO(logger, "jumps example brown {} {} {} {} {}", true, 1, std::string("str2"),
-           static_cast<short>(9), 6LL);
-  LOG_INFO(logger, "over test logging quick {} {} {} {} {} {} {} {}", 4.0f, "example2",
-           std::string_view("view1"), 8ULL, 3.0, 5L, "example1", 2);
-  LOG_INFO(logger, "lazy dog test jumps {} {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           6LL, 4.0f, 7UL, false, std::string_view("view2"), 3.0, "example2", 1, true);
-  LOG_INFO(logger, "example dog fox brown {} {} {} {} {}", std::string("str1"), false, 3.0, 8ULL, true);
-  LOG_INFO(logger, "jumps over logging test {} {}", 1, std::string("str1"));
-  LOG_INFO(logger, "dog test brown {}", 4.0f);
-  LOG_INFO(logger, "over dog test example {} {} {} {}", std::string("str1"), 8ULL, 5L, 2);
-  LOG_INFO(logger, "quick test lazy logging {} {} {} {} {} {} {} {} {} {}", "example1", "example2",
-           2, std::string_view("view1"), std::string("str2"), false, 1, static_cast<short>(9),
-           std::string_view("view2"), std::string("str1"));
-  LOG_INFO(logger, "example test fox over {} {} {} {} {} {} {}", 3.0, 6LL, std::string("str2"),
-           static_cast<short>(9), std::string("str1"), 4.0f, 1);
-  LOG_INFO(logger, "test jumps logging {} {} {} {} {} {}", 3.0, 5L, std::string("str1"),
-           std::string("str2"), static_cast<short>(9), 1);
-  LOG_INFO(logger, "dog example fox logging {} {} {} {} {} {} {}", std::string("str2"), 3.0, 7UL,
-           5L, std::string_view("view2"), 8ULL, 1);
-  LOG_INFO(logger, "over fox lazy {} {} {} {} {} {}", 1, 6LL, 2, std::string("str1"), "example1", false);
-  LOG_INFO(logger, "logging test lazy dog {} {} {} {} {} {} {} {} {} {}",
-           static_cast<unsigned short>(10), 8ULL, false, std::string("str1"),
-           std::string_view("view2"), "example1", std::string_view("view1"), 2, 1, 5L);
-  LOG_INFO(logger, "quick dog jumps {} {} {}", static_cast<short>(9), std::string("str2"), 8ULL);
-  LOG_INFO(logger, "fox test dog over {} {} {} {} {} {} {}", 4.0f, true, false, 3.0, 7UL, 8ULL,
-           "example3");
-  LOG_INFO(logger, "jumps over logging quick {}", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "jumps logging fox example {} {} {} {} {} {} {} {} {} {}", "example3",
-           "example1", static_cast<unsigned short>(10), std::string("str2"), 8ULL,
-           static_cast<short>(9), 4.0f, std::string("str1"), std::string_view("view2"), 7UL);
-  LOG_INFO(logger, "fox over quick test {}", false);
-  LOG_INFO(logger, "brown dog quick test {} {} {} {} {} {} {}", std::string("str2"),
-           std::string("str1"), static_cast<short>(9), true, false, "example1", 3.0);
-  LOG_INFO(logger, "over example brown {} {} {} {} {} {} {} {}", 7UL, 8ULL, "example3",
-           static_cast<short>(9), "example1", std::string("str1"), std::string_view("view1"), true);
-  LOG_INFO(logger, "jumps test example {}", 8ULL);
-  LOG_INFO(logger, "over test example brown {} {} {} {} {} {} {} {} {}", true, 4.0f,
-           std::string_view("view1"), "example3", std::string("str2"), 3.0, static_cast<short>(9),
-           1, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "logging jumps test example {} {} {} {} {}", 7UL, "example2", 1, 2, 5L);
-  LOG_INFO(logger, "lazy jumps brown {} {}", "example2", std::string_view("view2"));
-  LOG_INFO(logger, "brown over quick {} {} {} {} {} {} {}", std::string_view("view1"), 5L,
-           static_cast<unsigned short>(10), std::string_view("view2"), "example1", 4.0f, 2);
-  LOG_INFO(logger, "test example fox over {} {} {} {} {}", 4.0f, false, "example2", true, 8ULL);
-  LOG_INFO(logger, "quick fox lazy over {} {} {} {} {} {}", std::string("str1"), static_cast<short>(9),
-           5L, static_cast<unsigned short>(10), std::string_view("view2"), 8ULL);
-  LOG_INFO(logger, "test logging lazy {} {} {}", "example1", 7UL, 1);
-  LOG_INFO(logger, "fox dog example {} {} {} {} {} {}", "example3", std::string_view("view2"), 8ULL,
-           false, std::string("str2"), "example2");
-  LOG_INFO(logger, "over fox dog example {} {} {} {} {} {}", std::string_view("view1"), "example3",
-           "example2", 2, "example1", 6LL);
-  LOG_INFO(logger, "dog brown example quick {} {} {} {} {} {} {} {} {} {}", 3.0, "example3", 2, 8ULL,
-           4.0f, std::string_view("view1"), 5L, 7UL, static_cast<unsigned short>(10), "example2");
-  LOG_INFO(logger, "test fox dog jumps {} {} {} {} {}", "example1", static_cast<unsigned short>(10),
-           "example3", 7UL, 1);
-  LOG_INFO(logger, "fox dog over {} {} {} {} {}", std::string("str1"),
-           static_cast<unsigned short>(10), 4.0f, 2, static_cast<short>(9));
-  LOG_INFO(logger, "logging brown fox {}", 3.0);
-  LOG_INFO(logger, "example fox over brown {} {} {}", 3.0, "example3", 1);
-  LOG_INFO(logger, "quick dog lazy jumps {} {} {} {} {} {} {} {} {} {}", 8ULL, "example2",
-           "example3", 1, 5L, false, 3.0, std::string_view("view2"), "example1", true);
-  LOG_INFO(logger, "jumps dog test {} {} {} {} {} {} {} {} {} {}", 5L, 2, "example1", 1, 7UL, false,
-           "example2", static_cast<unsigned short>(10), true, std::string("str1"));
-  LOG_INFO(logger, "quick logging lazy example {} {}", false, "example3");
-  LOG_INFO(logger, "example logging test {} {} {} {} {} {} {} {} {} {}", 6LL, 1,
-           std::string("str1"), "example2", 3.0, 8ULL, "example1", 5L, 2, "example3");
-  LOG_INFO(logger, "example jumps dog quick {} {} {} {} {} {} {}", 7UL, static_cast<unsigned short>(10),
-           6LL, "example1", std::string_view("view2"), std::string("str1"), std::string("str2"));
-  LOG_INFO(logger, "quick logging jumps example {} {}", "example3", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "dog example lazy test {} {} {} {} {}", std::string("str2"),
-           std::string_view("view1"), 6LL, static_cast<short>(9), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "lazy logging jumps dog {} {} {} {} {} {} {} {} {}", 1, "example2",
-           std::string_view("view2"), true, static_cast<short>(9), 5L, std::string("str1"),
-           "example3", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "logging jumps dog lazy {} {} {} {} {} {} {} {} {}", false, std::string("str1"),
-           std::string_view("view2"), "example2", 2, static_cast<short>(9),
-           std::string_view("view1"), 6LL, 7UL);
-  LOG_INFO(logger, "test lazy example {} {} {} {} {}", static_cast<short>(9), true, std::string("str1"), 1, 2);
-  LOG_INFO(logger, "quick lazy test {} {}", std::string("str2"), 8ULL);
-  LOG_INFO(logger, "logging quick example dog {} {} {} {} {}", 1, 3.0, static_cast<short>(9), 6LL,
-           std::string("str2"));
-  LOG_INFO(logger, "logging quick test {} {} {} {} {} {} {}", 8ULL, 7UL,
-           static_cast<unsigned short>(10), 1, "example3", 4.0f, "example1");
-  LOG_INFO(logger, "quick logging over jumps {} {}", 3.0, 1);
-  LOG_INFO(logger, "over example brown jumps {}", 8ULL);
-  LOG_INFO(logger, "dog jumps brown logging {} {} {} {} {} {} {} {}", "example2", std::string_view("view2"),
-           std::string_view("view1"), 8ULL, static_cast<unsigned short>(10), 5L, std::string("str2"), 7UL);
-  LOG_INFO(logger, "test example brown jumps {} {} {}", 6LL, 5L, 8ULL);
-  LOG_INFO(logger, "jumps example quick over {} {} {} {} {} {} {} {} {} {}", 5L, "example1", false,
-           3.0, "example3", std::string("str2"), 2, std::string("str1"), true, 4.0f);
-  LOG_INFO(logger, "dog brown jumps lazy {} {} {} {} {} {} {} {} {} {}", 1, 3.0,
-           static_cast<unsigned short>(10), "example1", std::string("str2"),
-           std::string_view("view1"), std::string_view("view2"), 4.0f, "example2", false);
-  LOG_INFO(logger, "fox dog over {} {} {} {} {} {} {} {} {} {}", 5L, 6LL, true, "example3",
-           static_cast<unsigned short>(10), "example2", std::string("str1"), false, std::string("str2"), 8ULL);
-  LOG_INFO(logger, "lazy jumps test dog {} {} {} {} {} {} {} {} {} {}", 5L, 8ULL, false, 7UL, 2,
-           static_cast<short>(9), "example2", static_cast<unsigned short>(10), "example3", 6LL);
-  LOG_INFO(logger, "over lazy example {} {} {}", std::string("str2"), "example2", std::string("str1"));
-  LOG_INFO(logger, "fox dog example logging {} {} {} {} {}", std::string_view("view1"), "example1",
-           3.0, 7UL, 2);
-  LOG_INFO(logger, "example logging lazy {} {} {} {} {} {}", 4.0f, true, "example3",
-           std::string_view("view1"), std::string("str2"), std::string("str1"));
-  LOG_INFO(logger, "lazy fox quick over {} {} {} {} {}", 1, 7UL, 4.0f, 3.0, 2);
-  LOG_INFO(logger, "logging quick brown fox {} {} {} {} {} {} {} {} {} {}", false,
-           std::string_view("view2"), std::string("str1"), std::string_view("view1"), 3.0,
-           "example2", 4.0f, 7UL, static_cast<short>(9), std::string("str2"));
-  LOG_INFO(logger, "quick example fox {} {} {} {} {} {} {} {}", 5L, 8ULL,
-           static_cast<unsigned short>(10), false, std::string("str2"), "example2", 7UL, 6LL);
-  LOG_INFO(logger, "logging fox example {} {} {} {} {} {} {} {}", 2, 8ULL, 4.0f, true,
-           static_cast<unsigned short>(10), 5L, 1, 6LL);
-  LOG_INFO(logger, "over example fox test {} {} {} {} {} {}", 6LL, 7UL, std::string_view("view2"), 2, 3.0, true);
-  LOG_INFO(logger, "lazy test brown {} {} {}", 8ULL, "example1", false);
-  LOG_INFO(logger, "dog over jumps {} {} {}", std::string_view("view1"), 3.0, 6LL);
-  LOG_INFO(logger, "over dog fox {} {} {} {} {}", std::string_view("view2"), "example2", false,
-           static_cast<unsigned short>(10), std::string("str1"));
-  LOG_INFO(logger, "over dog jumps {} {} {} {} {} {} {} {}", 7UL, 2, true, std::string("str1"),
-           static_cast<unsigned short>(10), "example2", 3.0, 6LL);
-  LOG_INFO(logger, "brown quick over {} {} {} {} {} {}", std::string_view("view1"),
-           static_cast<unsigned short>(10), 5L, 6LL, "example1", std::string_view("view2"));
-  LOG_INFO(logger, "logging jumps example brown {} {}", static_cast<unsigned short>(10), false);
-  LOG_INFO(logger, "fox quick test brown {} {} {} {} {} {} {} {}", 7UL, static_cast<short>(9),
-           "example1", false, 6LL, std::string_view("view1"), std::string("str2"),
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "jumps test brown lazy {} {} {} {} {}", 1, 2, std::string("str1"),
-           static_cast<short>(9), "example1");
-  LOG_INFO(logger, "logging test lazy {} {} {} {} {} {} {}", false, static_cast<short>(9), 3.0,
-           std::string("str1"), true, 6LL, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "dog logging fox lazy {} {} {} {} {} {}", 4.0f, 6LL, 1, 2, std::string("str1"),
-           std::string_view("view2"));
-  LOG_INFO(logger, "lazy dog logging test {} {} {} {} {}", "example1", 8ULL,
-           std::string_view("view1"), 7UL, std::string_view("view2"));
-  LOG_INFO(logger, "quick jumps dog over {} {} {} {} {} {}", 7UL, "example1", 2, false, true, 1);
-  LOG_INFO(logger, "logging jumps lazy {} {} {} {} {} {} {} {}", std::string_view("view2"), 1, 2,
-           std::string_view("view1"), "example3", "example2", 3.0, true);
-  LOG_INFO(logger, "jumps example over {} {} {} {} {} {} {} {} {} {}", 1, std::string_view("view2"),
-           std::string_view("view1"), 3.0, 8ULL, static_cast<unsigned short>(10), "example1", false,
-           std::string("str1"), 6LL);
-  LOG_INFO(logger, "test quick example brown {}", "example3");
-  LOG_INFO(logger, "jumps over example lazy {} {} {} {} {}", static_cast<short>(9), 5L, "example1",
-           "example3", std::string("str2"));
-  LOG_INFO(logger, "dog fox over {} {} {}", "example3", 3.0, "example1");
-  LOG_INFO(logger, "over logging jumps {} {} {} {} {} {} {} {} {}", std::string_view("view2"), 8ULL,
-           "example3", true, "example2", 3.0, std::string_view("view1"), std::string("str1"), false);
-  LOG_INFO(logger, "dog lazy brown {} {} {} {} {} {} {}", "example1", std::string_view("view1"),
-           static_cast<unsigned short>(10), std::string("str1"), false, 3.0, true);
-  LOG_INFO(logger, "logging quick fox {} {} {} {} {} {}", 7UL, 3.0, static_cast<unsigned short>(10),
-           4.0f, "example1", std::string_view("view1"));
-  LOG_INFO(logger, "lazy quick example jumps {} {} {} {} {} {}", static_cast<short>(9), false,
-           "example2", 7UL, 1, "example1");
-  LOG_INFO(logger, "quick brown example {} {}", 4.0f, 7UL);
-  LOG_INFO(logger, "over brown logging {} {} {} {} {}", std::string_view("view2"),
-           std::string_view("view1"), 7UL, 2, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "brown over jumps logging {} {} {} {} {} {} {} {} {} {}", true, std::string("str1"), 1,
-           static_cast<short>(9), false, 4.0f, static_cast<unsigned short>(10), 2, 6LL, "example1");
-  LOG_INFO(logger, "jumps fox lazy test {} {} {} {} {} {} {} {} {} {}", 2, true, "example2", false,
-           std::string("str1"), 5L, 4.0f, std::string_view("view2"), static_cast<short>(9), 7UL);
-  LOG_INFO(logger, "example fox test {} {} {} {} {} {}", false, 8ULL, std::string("str2"), true,
-           7UL, std::string_view("view1"));
-  LOG_INFO(logger, "logging fox over {} {} {} {} {} {} {}", static_cast<unsigned short>(10), 8ULL,
-           std::string_view("view2"), 6LL, std::string("str1"), 4.0f, 3.0);
-  LOG_INFO(logger, "test dog lazy {} {} {} {} {} {}", std::string_view("view1"),
-           static_cast<short>(9), std::string_view("view2"), 5L, false, 2);
-  LOG_INFO(logger, "brown over quick {} {} {}", 8ULL, 7UL, false);
-  LOG_INFO(logger, "lazy quick dog {} {} {} {} {}", "example1", "example2", "example3",
-           std::string_view("view1"), 8ULL);
-  LOG_INFO(logger, "over dog example {} {} {} {} {} {} {}", "example2", 6LL, false, "example1", 2,
-           static_cast<unsigned short>(10), 7UL);
-  LOG_INFO(logger, "brown test jumps {} {} {}", 4.0f, true, 6LL);
-  LOG_INFO(logger, "jumps over logging quick {} {} {} {} {} {} {}", 6LL, 7UL,
-           static_cast<unsigned short>(10), 3.0, 5L, 8ULL, 4.0f);
-  LOG_INFO(logger, "lazy quick fox test {} {} {} {} {} {}", static_cast<unsigned short>(10), 4.0f,
-           std::string_view("view1"), 1, 2, true);
-  LOG_INFO(logger, "test example dog {} {}", "example2", 1);
-  LOG_INFO(logger, "fox over brown quick {} {} {} {} {} {} {} {} {} {}", 2, "example3", 8ULL,
-           "example2", std::string("str1"), static_cast<unsigned short>(10), std::string("str2"),
-           static_cast<short>(9), std::string_view("view2"), 4.0f);
-  LOG_INFO(logger, "test dog quick fox {} {} {} {} {} {} {} {} {}", 5L, "example2", true,
-           "example1", "example3", false, 4.0f, 3.0, std::string_view("view2"));
-  LOG_INFO(logger, "example fox dog over {} {} {} {} {} {} {}", true, static_cast<short>(9),
-           std::string_view("view1"), 1, 5L, 4.0f, std::string("str2"));
-  LOG_INFO(logger, "lazy brown fox over {}", std::string("str1"));
-  LOG_INFO(logger, "test over dog logging {} {} {} {} {} {}", false, 8ULL,
-           static_cast<unsigned short>(10), 2, 4.0f, "example1");
-  LOG_INFO(logger, "brown fox over {} {} {} {} {} {} {} {} {} {}", std::string_view("view1"), 8ULL,
-           6LL, false, "example3", 5L, std::string("str1"), "example2", "example1", 3.0);
-  LOG_INFO(logger, "over test example {} {} {}", false, 8ULL, 3.0);
-  LOG_INFO(logger, "example fox dog brown {} {} {} {} {} {} {}", std::string("str2"), "example1",
-           4.0f, 1, static_cast<unsigned short>(10), 3.0, 6LL);
-  LOG_INFO(logger, "brown fox lazy example {} {}", 4.0f, 2);
-  LOG_INFO(logger, "over logging example {} {} {} {} {} {} {} {}", 2, std::string("str1"),
-           "example1", 6LL, 3.0, std::string("str2"), "example2", true);
-  LOG_INFO(logger, "dog logging test lazy {} {} {} {} {} {} {} {} {} {}", 1, std::string("str2"),
-           "example1", "example3", std::string_view("view2"), std::string_view("view1"),
-           static_cast<short>(9), 4.0f, 7UL, 3.0);
-  LOG_INFO(logger, "jumps over test {} {} {} {} {} {} {} {} {}", 3.0, 4.0f,
-           static_cast<unsigned short>(10), std::string("str1"), std::string("str2"), 5L, 7UL, true, false);
-  LOG_INFO(logger, "over example quick brown {} {}", 6LL, true);
-  LOG_INFO(logger, "logging over brown quick {} {} {}", "example2", static_cast<short>(9), 7UL);
-  LOG_INFO(logger, "logging brown test fox {} {} {} {} {} {} {} {} {}", true, 7UL,
-           std::string("str1"), std::string_view("view2"), static_cast<unsigned short>(10), 4.0f,
-           std::string_view("view1"), "example3", false);
-  LOG_INFO(logger, "example dog over {} {} {} {} {} {} {}", 2, 6LL, false, 7UL,
-           static_cast<unsigned short>(10), 1, std::string_view("view1"));
-  LOG_INFO(logger, "over quick lazy test {} {} {} {} {} {} {} {} {}", std::string_view("view2"), 1,
-           5L, "example3", std::string("str1"), static_cast<unsigned short>(10),
-           static_cast<short>(9), 4.0f, 6LL);
-  LOG_INFO(logger, "jumps over example {}", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "logging quick lazy {} {}", 4.0f, 8ULL);
-  LOG_INFO(logger, "over test logging dog {}", 7UL);
-  LOG_INFO(logger, "test jumps brown quick {} {} {} {} {}", std::string("str1"),
-           static_cast<short>(9), 3.0, std::string("str2"), std::string_view("view2"));
-  LOG_INFO(logger, "test logging over {} {} {} {} {} {} {} {} {} {}", std::string_view("view1"),
-           "example1", "example2", 2, false, "example3", 8ULL, 1, true, 7UL);
-  LOG_INFO(logger, "lazy dog logging {} {} {} {} {} {} {} {} {} {}", std::string("str2"), 2,
-           "example2", 4.0f, "example1", static_cast<unsigned short>(10), std::string("str1"), 7UL,
-           static_cast<short>(9), std::string_view("view2"));
-  LOG_INFO(logger, "jumps example quick {} {} {} {} {} {} {}", 8ULL, std::string("str1"),
-           static_cast<unsigned short>(10), false, static_cast<short>(9), "example1", 4.0f);
-  LOG_INFO(logger, "logging fox dog {} {} {} {} {} {} {} {} {}", 4.0f, "example1", 1, 7UL, true,
-           std::string_view("view1"), false, static_cast<unsigned short>(10), std::string_view("view2"));
-  LOG_INFO(logger, "logging example dog test {} {} {} {} {}", false, static_cast<short>(9), 7UL,
-           static_cast<unsigned short>(10), 8ULL);
-  LOG_INFO(logger, "jumps brown test example {} {} {}", false, std::string_view("view2"), std::string("str2"));
-  LOG_INFO(logger, "quick test lazy dog {} {} {} {} {} {} {} {} {} {}", std::string_view("view2"), 6LL, 3.0,
-           std::string("str2"), static_cast<unsigned short>(10), 4.0f, 5L, true, false, "example3");
-  LOG_INFO(logger, "quick brown fox {} {} {} {} {} {} {} {} {}", 8ULL, "example1", false,
-           "example2", 3.0, 4.0f, 6LL, true, 5L);
-  LOG_INFO(logger, "test brown over {}", std::string_view("view1"));
-  LOG_INFO(logger, "logging brown quick over {}", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "jumps lazy over {}", std::string_view("view2"));
-  LOG_INFO(logger, "brown dog jumps over {} {} {}", std::string_view("view1"), 8ULL, "example3");
-  LOG_INFO(logger, "quick test dog fox {} {} {} {} {} {} {} {} {}", true, false, static_cast<short>(9),
-           std::string("str1"), "example1", 8ULL, std::string_view("view1"), 4.0f, std::string_view("view2"));
-  LOG_INFO(logger, "test logging brown dog {} {} {} {} {} {} {} {} {} {}", 7UL, 6LL, 2,
-           static_cast<unsigned short>(10), 4.0f, std::string_view("view2"), 1, false,
-           static_cast<short>(9), "example2");
-  LOG_INFO(logger, "lazy fox brown quick {}", "example2");
-  LOG_INFO(logger, "dog fox example quick {} {} {} {} {}", static_cast<short>(9), false, true, 3.0,
-           std::string_view("view1"));
-  LOG_INFO(logger, "over jumps example quick {} {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           false, "example3", 1, 7UL, 2, true, 4.0f, "example1", static_cast<short>(9));
-  LOG_INFO(logger, "fox dog brown {}", 8ULL);
-  LOG_INFO(logger, "example fox dog {} {} {} {} {} {}", false, std::string_view("view2"),
-           static_cast<short>(9), std::string("str1"), "example3", "example2");
-  LOG_INFO(logger, "lazy test jumps {} {}", "example2", 6LL);
-  LOG_INFO(logger, "logging example fox {} {} {} {} {} {} {} {}", static_cast<short>(9), 3.0,
-           "example3", 1, std::string_view("view1"), std::string("str1"),
-           static_cast<unsigned short>(10), "example2");
-  LOG_INFO(logger, "lazy over fox example {} {} {} {} {} {} {} {} {} {}", static_cast<short>(9), 7UL, false,
-           3.0, 4.0f, std::string_view("view1"), "example2", std::string_view("view2"), "example1", 8ULL);
-  LOG_INFO(logger, "quick lazy logging {} {} {} {} {} {} {}", false, std::string_view("view1"),
-           "example1", true, "example3", std::string_view("view2"), static_cast<short>(9));
-  LOG_INFO(logger, "dog lazy jumps {} {} {} {}", 3.0, std::string("str2"), 1, 6LL);
-  LOG_INFO(logger, "dog example brown test {} {} {} {} {} {}", 6LL, 2, 8ULL,
-           static_cast<unsigned short>(10), "example2", 1);
-  LOG_INFO(logger, "lazy jumps dog {} {} {} {} {} {} {} {} {} {}", 3.0, static_cast<short>(9), 6LL,
-           std::string_view("view2"), true, 5L, std::string("str2"), "example2", "example3",
-           std::string_view("view1"));
-  LOG_INFO(logger, "fox dog logging quick {} {}", "example1", "example2");
-  LOG_INFO(logger, "dog jumps example over {} {} {} {} {} {} {}", "example1", 2, 5L, 8ULL,
-           std::string("str2"), 6LL, "example3");
-  LOG_INFO(logger, "dog lazy quick {} {} {} {} {} {} {} {} {}", 8ULL, std::string("str1"),
-           "example3", 3.0, std::string_view("view1"), true, static_cast<short>(9), 1,
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "jumps brown lazy {} {} {} {} {} {} {}", std::string("str2"), 2,
-           static_cast<unsigned short>(10), true, "example3", std::string_view("view2"), 6LL);
-  LOG_INFO(logger, "brown dog example {} {} {}", std::string("str2"), static_cast<unsigned short>(10), true);
-  LOG_INFO(logger, "fox brown lazy {} {} {} {} {} {}", 6LL, "example1", std::string("str1"), true,
-           std::string("str2"), "example3");
-  LOG_INFO(logger, "quick over jumps logging {} {}", 4.0f, std::string("str1"));
-  LOG_INFO(logger, "dog fox brown quick {} {} {} {} {} {} {} {} {}", "example2", std::string("str2"), 7UL,
-           static_cast<unsigned short>(10), 6LL, 8ULL, std::string_view("view2"), "example1", 4.0f);
-  LOG_INFO(logger, "quick example dog {} {} {} {} {} {}", false, "example1", true, 5L, 3.0,
-           static_cast<unsigned short>(10));
-  LOG_INFO(logger, "test brown lazy dog {} {}", std::string("str2"), 2);
-  LOG_INFO(logger, "dog logging example {} {} {} {} {} {} {} {} {}", 7UL, std::string("str1"), 8ULL,
-           6LL, 2, false, "example3", std::string_view("view1"), std::string("str2"));
-  LOG_INFO(logger, "dog test quick {} {} {} {} {}", std::string_view("view2"), 2,
-           static_cast<unsigned short>(10), "example3", 8ULL);
-  LOG_INFO(logger, "lazy example dog {}", static_cast<short>(9));
-  LOG_INFO(logger, "example dog logging {} {} {} {} {} {} {} {}", 5L, 8ULL, 2, false, "example2",
-           true, static_cast<short>(9), 4.0f);
-  LOG_INFO(logger, "test logging example brown {} {} {} {} {} {} {} {} {}", "example3", 4.0f, 5L,
-           static_cast<short>(9), 2, std::string_view("view1"), std::string_view("view2"), true, 6LL);
-  LOG_INFO(logger, "over example brown {} {} {} {} {}", 1, "example2", std::string_view("view2"),
-           std::string_view("view1"), "example3");
-  LOG_INFO(logger, "over example lazy quick {}", 8ULL);
-  LOG_INFO(logger, "logging dog fox {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           std::string_view("view2"), 8ULL, 1, "example3", static_cast<short>(9), std::string("str2"), true);
-  LOG_INFO(logger, "quick dog example {} {} {} {} {} {} {} {}", 1, 3.0, std::string("str2"),
-           static_cast<short>(9), std::string_view("view1"), static_cast<unsigned short>(10),
-           "example3", 4.0f);
-  LOG_INFO(logger, "dog quick logging jumps {} {} {} {} {}", 2, std::string("str1"), "example2", 1, true);
-  LOG_INFO(logger, "dog fox logging test {} {} {} {} {} {} {} {} {} {}", 1, static_cast<short>(9),
-           std::string_view("view2"), "example1", 3.0, 5L, true, 2, std::string_view("view1"), 8ULL);
-  LOG_INFO(logger, "dog jumps fox quick {} {}", true, 2);
-  LOG_INFO(logger, "jumps over dog quick {} {} {} {} {} {} {} {} {} {}", "example2", 6LL, 8ULL, 1,
-           4.0f, 7UL, 2, std::string_view("view1"), false, 5L);
-  LOG_INFO(logger, "logging example quick lazy {} {} {} {} {} {} {} {} {} {}", "example3", 2, false,
-           std::string("str1"), 1, "example2", std::string_view("view2"), 6LL, true, 7UL);
-  LOG_INFO(logger, "fox quick jumps logging {} {} {} {} {} {} {} {} {} {}",
-           static_cast<unsigned short>(10), 1, std::string_view("view1"), static_cast<short>(9),
-           false, true, std::string("str2"), 3.0, 5L, std::string("str1"));
-  LOG_INFO(logger, "fox dog brown {} {}", std::string("str1"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox jumps lazy {} {} {} {}", std::string_view("view1"), "example3", false,
-           std::string("str2"));
-  LOG_INFO(logger, "brown lazy example fox {} {}", "example2", 1);
-  LOG_INFO(logger, "quick lazy example jumps {} {}", true, std::string_view("view1"));
-  LOG_INFO(logger, "test quick fox {} {} {} {}", 6LL, std::string("str1"), 8ULL, std::string("str2"));
-  LOG_INFO(logger, "dog logging test lazy {}", std::string("str1"));
-  LOG_INFO(logger, "lazy over dog example {} {} {} {} {} {} {}", 7UL, 8ULL, std::string_view("view1"),
-           "example2", std::string("str2"), static_cast<unsigned short>(10), 5L);
-  LOG_INFO(logger, "example logging brown jumps {} {} {} {} {} {} {} {}", 5L, 6LL,
-           std::string_view("view2"), std::string_view("view1"), 2, true, 7UL, std::string("str1"));
-  LOG_INFO(logger, "fox brown lazy over {} {} {} {} {} {} {} {} {} {}", 2, "example1", 6LL, 4.0f, 5L,
-           true, std::string_view("view2"), std::string_view("view1"), "example3", std::string("str2"));
-  LOG_INFO(logger, "logging dog brown lazy {} {} {} {} {} {} {} {} {} {}", 4.0f, "example3",
-           "example2", std::string_view("view2"), 5L, false, std::string("str2"),
-           std::string_view("view1"), 7UL, std::string("str1"));
-  LOG_INFO(logger, "test fox quick brown {} {} {} {} {} {} {} {} {}", false, static_cast<unsigned short>(10),
-           std::string("str1"), true, "example2", 2, 7UL, std::string_view("view1"), 4.0f);
-  LOG_INFO(logger, "over brown jumps {} {} {} {} {} {} {} {} {}", 6LL, static_cast<short>(9), false,
-           "example3", 5L, 8ULL, 1, std::string("str1"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "example brown dog lazy {} {} {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           false, static_cast<short>(9), true, 1, 6LL, 8ULL, 7UL, 3.0, "example2");
-  LOG_INFO(logger, "lazy dog over {} {} {} {} {} {}", std::string("str2"), "example3",
-           std::string_view("view1"), "example2", static_cast<short>(9), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox example quick lazy {} {} {} {}", 8ULL, 2, static_cast<short>(9), true);
-  LOG_INFO(logger, "test over fox {} {} {} {} {} {} {}", false, "example2", "example1", 2, 1,
-           "example3", 5L);
-  LOG_INFO(logger, "test lazy example {} {} {} {} {} {} {}", 8ULL, std::string("str1"),
-           std::string_view("view2"), "example2", std::string("str2"), static_cast<short>(9), 4.0f);
-  LOG_INFO(logger, "jumps example over dog {} {} {} {} {} {} {} {} {} {}", std::string_view("view1"), 3.0,
-           std::string("str2"), "example2", true, static_cast<short>(9), 4.0f, 5L, "example3", false);
-  LOG_INFO(logger, "logging example test {} {} {} {}", static_cast<unsigned short>(10), "example1",
-           static_cast<short>(9), "example2");
-  LOG_INFO(logger, "quick fox test brown {} {} {}", 6LL, true, 7UL);
-  LOG_INFO(logger, "over logging test lazy {} {} {} {}", 1, 8ULL, static_cast<short>(9), "example1");
-  LOG_INFO(logger, "example lazy quick {} {} {} {} {} {} {} {}", "example2", "example1", 7UL, 1,
-           std::string("str2"), std::string("str1"), 6LL, 4.0f);
-  LOG_INFO(logger, "lazy brown dog {}", static_cast<short>(9));
-  LOG_INFO(logger, "test quick jumps example {}", 6LL);
-  LOG_INFO(logger, "dog quick lazy {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           std::string("str1"), 5L, 8ULL, "example3", 3.0, "example2");
-  LOG_INFO(logger, "brown logging lazy quick {} {} {} {} {} {}", 2, 7UL, "example2", true,
-           "example3", static_cast<short>(9));
-  LOG_INFO(logger, "test brown fox dog {} {} {} {} {}", std::string("str1"), "example3", false,
-           std::string_view("view1"), 6LL);
-  LOG_INFO(logger, "logging test over dog {}", std::string_view("view1"));
-  LOG_INFO(logger, "test dog brown {} {} {} {}", 3.0, 1, 6LL, std::string_view("view1"));
-  LOG_INFO(logger, "example test quick {}", std::string_view("view2"));
-  LOG_INFO(logger, "dog over fox {} {} {} {} {}", 6LL, static_cast<short>(9), 4.0f, 2, true);
-  LOG_INFO(logger, "logging test fox {} {} {}", 1, 3.0, 7UL);
-  LOG_INFO(logger, "over lazy dog jumps {} {} {} {} {}", std::string("str1"), false,
-           std::string_view("view2"), 6LL, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "test quick over example {} {} {} {} {} {} {} {}", std::string_view("view1"),
-           3.0, 6LL, 5L, static_cast<short>(9), 2, 7UL, false);
-  LOG_INFO(logger, "example test lazy logging {}", 3.0);
-  LOG_INFO(logger, "jumps lazy quick over {} {} {} {} {} {} {}", std::string_view("view2"), false,
-           std::string("str1"), true, 6LL, 1, 2);
-  LOG_INFO(logger, "fox jumps quick {} {} {} {} {}", true, static_cast<unsigned short>(10),
-           "example3", 1, "example2");
-  LOG_INFO(logger, "jumps dog lazy {} {} {} {} {} {} {} {}", false, std::string_view("view2"), 4.0f,
-           "example2", static_cast<short>(9), std::string("str2"), 3.0, std::string_view("view1"));
-  LOG_INFO(logger, "fox lazy logging jumps {}", 1);
-  LOG_INFO(logger, "brown fox example {} {}", "example3", static_cast<short>(9));
-  LOG_INFO(logger, "fox lazy jumps logging {} {} {} {} {} {}", std::string_view("view2"), 4.0f, 2, 6LL, 5L, 3.0);
-  LOG_INFO(logger, "fox lazy logging jumps {} {} {} {} {} {} {}", std::string("str2"),
-           std::string_view("view1"), 6LL, 1, std::string_view("view2"), 5L, static_cast<short>(9));
-  LOG_INFO(logger, "quick dog jumps {} {}", std::string("str1"), 6LL);
-  LOG_INFO(logger, "dog quick jumps example {} {} {} {} {} {} {} {}", 1, 3.0, false, 6LL,
-           static_cast<short>(9), "example2", 4.0f, static_cast<unsigned short>(10));
-  LOG_INFO(logger, "quick example logging brown {} {} {} {} {} {} {}", 5L, "example3", 4.0f, 7UL,
-           static_cast<unsigned short>(10), "example2", false);
-  LOG_INFO(logger, "lazy jumps test {} {} {} {} {} {} {} {}", 2, true, 4.0f, 8ULL,
-           std::string_view("view1"), 6LL, "example2", std::string_view("view2"));
-  LOG_INFO(logger, "lazy jumps dog {} {} {} {} {} {} {}", std::string_view("view1"), "example3",
-           "example2", static_cast<short>(9), "example1", 6LL, std::string_view("view2"));
-  LOG_INFO(logger, "jumps quick test {} {} {} {} {} {} {} {}", 2, 8ULL, std::string("str1"), false,
-           1, std::string_view("view1"), static_cast<short>(9), std::string("str2"));
-  LOG_INFO(logger, "example jumps lazy {} {} {} {} {}", 7UL, "example2", 3.0, std::string("str2"), true);
-  LOG_INFO(logger, "jumps quick over example {} {} {}", 6LL, 7UL, std::string("str2"));
-  LOG_INFO(logger, "lazy dog jumps test {} {}", 7UL, true);
-  LOG_INFO(logger, "lazy jumps example {} {} {} {} {} {} {} {} {}", false, 7UL, true, 5L,
-           "example3", std::string("str2"), "example2", 1, static_cast<short>(9));
-  LOG_INFO(logger, "dog logging fox lazy {} {} {} {} {}", 8ULL, static_cast<unsigned short>(10),
-           std::string("str1"), 7UL, 6LL);
-  LOG_INFO(logger, "logging over fox lazy {} {} {} {} {} {} {} {}", 2, std::string_view("view2"),
-           true, 6LL, std::string("str2"), 8ULL, std::string("str1"), 1);
-  LOG_INFO(logger, "lazy fox brown {} {}", "example1", "example3");
-  LOG_INFO(logger, "fox quick test over {} {} {}", "example3", 1, std::string("str2"));
-  LOG_INFO(logger, "lazy over brown {} {} {} {} {} {} {} {}", true, std::string_view("view1"), 7UL,
-           5L, std::string("str1"), std::string("str2"), 4.0f, static_cast<short>(9));
-  LOG_INFO(logger, "test jumps brown dog {} {} {} {} {} {} {} {} {} {}", 8ULL, "example1",
-           "example3", 1, static_cast<short>(9), std::string_view("view2"), 4.0f,
-           std::string_view("view1"), 3.0, 7UL);
-  LOG_INFO(logger, "fox example jumps {}", static_cast<unsigned short>(10));
-  LOG_INFO(logger, "dog lazy quick {} {} {} {} {} {}", false, static_cast<short>(9),
-           std::string_view("view1"), 1, "example3", std::string("str1"));
-  LOG_INFO(logger, "jumps fox over logging {} {}", 1, "example1");
-  LOG_INFO(logger, "lazy example test {} {} {}", 4.0f, 7UL, 8ULL);
-  LOG_INFO(logger, "fox brown example {} {} {} {} {}", std::string_view("view1"),
-           std::string("str1"), std::string("str2"), std::string_view("view2"), 4.0f);
-  LOG_INFO(logger, "logging lazy jumps {} {} {} {} {} {} {}", 4.0f, 5L, static_cast<short>(9), 6LL,
-           false, std::string_view("view2"), static_cast<unsigned short>(10));
-  LOG_INFO(logger, "fox over logging {} {} {} {} {} {} {} {} {} {}", std::string_view("view2"), 5L,
-           8ULL, "example3", 6LL, false, 2, "example1", 7UL, static_cast<short>(9));
-  LOG_INFO(logger, "over example logging dog {} {} {} {} {} {}", 4.0f, 8ULL, "example2", true,
-           static_cast<unsigned short>(10), static_cast<short>(9));
-  LOG_INFO(logger, "example lazy dog {} {} {} {} {}", 8ULL, std::string_view("view2"),
-           std::string("str2"), std::string("str1"), 1);
-  LOG_INFO(logger, "fox example quick dog {} {} {} {} {} {} {} {} {}", "example2", false, 5L, 7UL,
-           std::string("str2"), static_cast<short>(9), true, "example1", "example3");
-  LOG_INFO(logger, "logging quick over {} {} {} {} {} {} {} {} {} {}", 2, 4.0f, "example3", std::string("str2"),
-           std::string("str1"), 7UL, static_cast<unsigned short>(10), "example2", 8ULL, 3.0);
-  LOG_INFO(logger, "fox over jumps brown {} {} {} {} {} {} {} {}", std::string_view("view2"),
-           std::string("str2"), "example2", 3.0, 5L, false, "example3", 6LL);
-  LOG_INFO(logger, "test logging quick dog {} {} {} {} {} {} {} {} {}", 6LL, 3.0, "example2", true,
-           false, static_cast<unsigned short>(10), std::string("str2"), std::string("str1"), 8ULL);
-  LOG_INFO(logger, "test logging quick lazy {} {}", std::string_view("view2"), 4.0f);
-  LOG_INFO(logger, "logging brown example {} {} {}", 4.0f, "example1", std::string("str2"));
-  LOG_INFO(logger, "jumps test over {} {}", std::string("str1"), std::string("str2"));
-  LOG_INFO(logger, "fox jumps quick {} {} {} {} {} {}", 6LL, std::string("str2"), false, 7UL,
-           std::string_view("view2"), 4.0f);
-  LOG_INFO(logger, "quick over jumps logging {}", false);
-  LOG_INFO(logger, "test dog logging {} {} {} {} {}", std::string("str2"), 5L, "example2",
-           static_cast<unsigned short>(10), 1);
-  LOG_INFO(logger, "example dog jumps lazy {} {} {} {} {}", "example2", 2, 7UL, false, static_cast<short>(9));
-  LOG_INFO(logger, "example test logging {} {} {} {} {} {} {} {} {} {}", 6LL, 1, 3.0,
-           static_cast<unsigned short>(10), std::string("str1"), "example2", 5L, "example3", 4.0f,
-           static_cast<short>(9));
-  LOG_INFO(logger, "lazy brown over logging {}", 7UL);
-  LOG_INFO(logger, "over lazy quick fox {} {} {} {} {}", 8ULL, 1, 7UL, 5L, "example3");
-  LOG_INFO(logger, "over example fox {} {} {}", true, 2, static_cast<short>(9));
-  LOG_INFO(logger, "fox over brown jumps {} {} {}", std::string_view("view2"), 5L, 4.0f);
-  LOG_INFO(logger, "brown jumps quick {}", "example1");
-  LOG_INFO(logger, "test jumps lazy {} {} {} {} {}", 6LL, 8ULL, 4.0f, "example1", 2);
-  LOG_INFO(logger, "dog fox lazy {} {}", 3.0, false);
-  LOG_INFO(logger, "jumps test quick brown {} {} {} {} {} {} {} {}", "example3", 7UL, 2,
-           std::string_view("view1"), false, true, "example1", "example2");
-  LOG_INFO(logger, "dog over quick {} {} {} {} {} {} {} {} {} {}", 2, 5L, "example2", 7UL,
-           "example3", std::string_view("view1"), std::string_view("view2"), std::string("str1"),
-           false, "example1");
-  LOG_INFO(logger, "quick dog over brown {} {} {} {} {}", 6LL, 4.0f, "example1", 3.0, 1);
-  LOG_INFO(logger, "logging over fox {} {}", 2, "example3");
-  LOG_INFO(logger, "quick logging example {} {} {} {}", 7UL, 4.0f, 1, 8ULL);
-  LOG_INFO(logger, "quick fox brown {} {} {} {} {}", 5L, 3.0, 2, false, "example3");
-  LOG_INFO(logger, "quick lazy logging test {} {} {}", static_cast<unsigned short>(10), 7UL, 2);
-  LOG_INFO(logger, "example lazy logging {} {} {} {} {}", static_cast<unsigned short>(10), 1, 8ULL,
-           7UL, static_cast<short>(9));
-  LOG_INFO(logger, "lazy quick logging brown {} {} {} {} {} {} {} {}", static_cast<short>(9), 3.0,
-           7UL, true, 5L, std::string_view("view2"), std::string("str1"), "example2");
-  LOG_INFO(logger, "over fox test {} {} {}", false, std::string_view("view2"), 8ULL);
-  LOG_INFO(logger, "test dog example jumps {} {} {} {}", "example2", 2, true, 8ULL);
-  LOG_INFO(logger, "quick lazy dog test {} {} {} {} {} {} {} {} {} {}", 6LL,
-           std::string_view("view2"), false, "example2", std::string_view("view1"),
-           static_cast<short>(9), "example3", static_cast<unsigned short>(10), 1, std::string("str2"));
-  LOG_INFO(logger, "over example quick {} {} {} {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           "example3", "example2", 2, 4.0f, std::string_view("view2"), "example1", false, 8ULL, true);
-  LOG_INFO(logger, "lazy test fox dog {} {} {} {} {} {}", std::string_view("view1"), 5L, 2, 4.0f,
-           static_cast<short>(9), 1);
-  LOG_INFO(logger, "jumps lazy test brown {}", true);
-  LOG_INFO(logger, "brown fox over {} {} {} {} {} {} {} {}", 4.0f, 8ULL, 3.0, 5L, 2, 6LL,
-           std::string_view("view1"), 1);
-  LOG_INFO(logger, "logging over quick test {} {} {} {} {} {} {}", 4.0f, static_cast<short>(9), 1,
-           6LL, "example2", 5L, std::string_view("view1"));
-  LOG_INFO(logger, "logging test dog {} {} {} {} {} {} {}", static_cast<unsigned short>(10),
-           "example3", 2, false, 3.0, 6LL, 4.0f);
-  LOG_INFO(logger, "example brown dog test {} {} {} {} {}", 6LL, 8ULL, true, 3.0, std::string_view("view1"));
-  LOG_INFO(logger, "logging test jumps quick {} {} {} {}", "example3", 3.0, std::string("str1"), 7UL);
-  LOG_INFO(logger, "dog lazy quick {} {} {}", 2, true, static_cast<short>(9));
-  LOG_INFO(logger, "quick over example fox {} {} {} {} {} {} {}", 8ULL, static_cast<short>(9), 6LL,
-           3.0, 7UL, "example1", 1);
-  LOG_INFO(logger, "jumps example fox {} {} {} {} {} {}", std::string_view("view2"), true, 8ULL,
-           static_cast<unsigned short>(10), "example2", false);
-  LOG_INFO(logger, "jumps logging brown {} {} {} {}", true, std::string_view("view2"), 7UL, std::string("str1"));
-  LOG_INFO(logger, "test fox jumps {} {} {}", 2, "example3", static_cast<short>(9));
-  LOG_INFO(logger, "jumps lazy quick {}", "example2");
-  LOG_INFO(logger, "logging brown over {} {} {} {} {}", "example1", 5L, 3.0, 7UL, 4.0f);
-  LOG_INFO(logger, "dog lazy quick test {} {} {} {}", "example3", std::string_view("view1"), 6LL,
-           std::string_view("view2"));
-  LOG_INFO(logger, "jumps lazy dog {} {} {}", static_cast<short>(9), std::string_view("view2"),
-           "example2");
-  LOG_INFO(logger, "over fox brown lazy {} {} {} {} {} {} {}", 7UL, 2, "example1", "example3", 5L,
-           std::string("str2"), 6LL);
-  LOG_INFO(logger, "logging over test {} {} {} {} {} {}", std::string_view("view2"), 1, false, 2, true, 8ULL);
-  LOG_INFO(logger, "jumps dog over test {} {} {} {} {} {} {} {} {} {}", 1, "example3", false, 2,
-           8ULL, 3.0, 7UL, 5L, static_cast<unsigned short>(10), std::string_view("view2"));
-  LOG_INFO(logger, "brown test lazy {} {} {} {} {} {} {} {} {}", std::string("str2"), 4.0f, 5L, 2,
-           "example3", static_cast<unsigned short>(10), 8ULL, static_cast<short>(9),
-           std::string_view("view1"));
-  LOG_INFO(logger, "over dog brown {} {}", "example2", 5L);
-  LOG_INFO(logger, "fox lazy over logging {} {} {} {} {} {} {} {} {} {}", std::string("str1"),
-           "example2", 2, 1, std::string_view("view1"), 5L, 3.0, true, 8ULL, 7UL);
-  LOG_INFO(logger, "fox example over logging {} {} {} {} {}", 2, std::string_view("view1"),
-           static_cast<short>(9), 5L, std::string("str2"));
-  LOG_INFO(logger, "lazy dog over fox {} {} {} {} {} {} {}", std::string("str1"), 3.0, false, 7UL,
-           1, std::string("str2"), 2);
-  LOG_INFO(logger, "brown fox quick lazy {} {}", 8ULL, std::string_view("view1"));
-  LOG_INFO(logger, "example logging brown lazy {} {} {} {} {} {} {} {} {}", 8ULL, 6LL, 2, true,
-           std::string("str2"), static_cast<short>(9), 7UL, "example2", "example3");
-  LOG_INFO(logger, "quick over logging brown {} {} {} {}", true, static_cast<unsigned short>(10), 1, 4.0f);
-  LOG_INFO(logger, "brown over fox {} {}", std::string("str2"), 8ULL);
-  LOG_INFO(logger, "over jumps quick {} {}", false, static_cast<short>(9));
-  LOG_INFO(logger, "quick test example {} {} {} {} {} {} {} {} {} {}", static_cast<short>(9),
-           std::string("str2"), 3.0, 2, 1, std::string_view("view1"), "example2", false, 8ULL, 5L);
-  LOG_INFO(logger, "brown lazy dog test {} {}", static_cast<unsigned short>(10), 3.0);
-  LOG_INFO(logger, "jumps fox dog {}", std::string_view("view1"));
-  LOG_INFO(logger, "dog fox brown {} {} {} {} {} {} {}", 1, 4.0f, 5L, 8ULL, 3.0, "example1",
-           "example3");
-  LOG_INFO(logger, "test lazy over {} {} {} {} {} {} {} {}", false, true, std::string_view("view2"),
-           3.0, "example3", 7UL, 1, "example1");
-  LOG_INFO(logger, "fox dog brown logging {} {} {} {} {}", false, true, 7UL, "example3", std::string("str2"));
-  LOG_INFO(logger, "over dog lazy example {} {}", false, "example3");
-  LOG_INFO(logger, "lazy jumps dog {} {} {} {}", 4.0f, std::string("str1"), "example2", false);
-  LOG_INFO(logger, "lazy test fox {} {} {} {} {} {} {}", 7UL, true, std::string_view("view2"), 2,
-           3.0, std::string_view("view1"), 4.0f);
-  LOG_INFO(logger, "example jumps test {} {} {} {} {} {} {} {} {} {}", static_cast<short>(9),
-           static_cast<unsigned short>(10), 4.0f, std::string("str2"), true, "example3",
-           std::string_view("view2"), false, 6LL, 3.0);
-  LOG_INFO(logger, "logging brown fox {} {}", std::string_view("view2"), 8ULL);
-  LOG_INFO(logger, "lazy test dog jumps {} {} {}", 2, 8ULL, 4.0f);
-  LOG_INFO(logger, "fox dog jumps {} {} {} {} {} {} {} {} {} {}", 8ULL, std::string("str2"), false,
-           static_cast<short>(9), std::string_view("view2"), static_cast<unsigned short>(10),
-           std::string_view("view1"), "example1", 3.0, 7UL);
-
-  return 0;
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/benchmarks/compile_time/gen_log_messages.py b/subprojects/quill-4.2.0/benchmarks/compile_time/gen_log_messages.py
deleted file mode 100644
index d7f4a02..0000000
--- a/subprojects/quill-4.2.0/benchmarks/compile_time/gen_log_messages.py
+++ /dev/null
@@ -1,57 +0,0 @@
-import random
-
-
-def generate_log_statements(num_statements):
-    argument_types = [
-        '1', '2', '3.0', '4.0f', '5L', '6LL', '7UL', '8ULL', 'true', 'false',
-        '"example1"', '"example2"', '"example3"', 'std::string("str1")',
-        'std::string("str2")', 'std::string_view("view1")', 'std::string_view("view2")',
-        'static_cast<short>(9)', 'static_cast<unsigned short>(10)'
-    ]
-    random_words = ["quick", "brown", "fox", "jumps", "over", "lazy", "dog", "logging", "test", "example"]
-
-    statements = []
-    for i in range(num_statements):
-        num_args = random.randint(1, 10)  # Number of arguments for the log statement
-        args = random.sample(argument_types, num_args)
-        placeholders = ' '.join(["{}" for _ in args])
-        num_words = random.randint(3, 4)  # Number of random words in the log message
-        words = ' '.join(random.sample(random_words, num_words))
-        statement = f'  LOG_INFO(logger, "{words} {placeholders}", {", ".join(args)});'
-        statements.append(statement)
-
-    return statements
-
-
-def write_to_file(filename, statements):
-    with open(filename, 'w') as f:
-        f.write('#include "quill/Backend.h"\n')
-        f.write('#include "quill/Frontend.h"\n')
-        f.write('#include "quill/LogMacros.h"\n')
-        f.write('#include "quill/Logger.h"\n')
-        f.write('#include "quill/sinks/ConsoleSink.h"\n')
-        f.write('#include <string>\n')
-        f.write('#include <utility>\n\n')
-        f.write('/**\n')
-        f.write(' * Trivial logging example to console\n')
-        f.write(' */\n\n')
-        f.write('int main()\n')
-        f.write('{\n')
-        f.write('  // Start the backend thread\n')
-        f.write('  quill::BackendOptions backend_options;\n')
-        f.write('  quill::Backend::start(backend_options);\n\n')
-        f.write('  // Frontend\n')
-        f.write('  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");\n')
-        f.write('  quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));\n\n')
-
-        for statement in statements:
-            f.write(f'{statement}\n')
-
-        f.write('\n  return 0;\n')
-        f.write('}\n')
-
-
-if __name__ == '__main__':
-    num_statements = 2000
-    statements = generate_log_statements(num_statements)
-    write_to_file('log_benchmark.cpp', statements)
diff --git a/subprojects/quill-4.2.0/benchmarks/compile_time/qwrapper/CMakeLists.txt b/subprojects/quill-4.2.0/benchmarks/compile_time/qwrapper/CMakeLists.txt
deleted file mode 100644
index 1f814a8..0000000
--- a/subprojects/quill-4.2.0/benchmarks/compile_time/qwrapper/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-set(LIB_NAME qwrapper_compile_time_bench)
-
-add_library(${LIB_NAME} STATIC
-        include/qwrapper/qwrapper.h
-        include/qwrapper/qwrapper.cpp)
-
-# Add include directories for this library
-target_include_directories(${LIB_NAME}
-        PUBLIC
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-        $<INSTALL_INTERFACE:include>
-        PRIVATE
-        ${CMAKE_CURRENT_SOURCE_DIR})
-
-# Link quill dependency
-target_link_libraries(${LIB_NAME} PUBLIC quill::quill)
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/benchmarks/compile_time/qwrapper/include/qwrapper/qwrapper.cpp b/subprojects/quill-4.2.0/benchmarks/compile_time/qwrapper/include/qwrapper/qwrapper.cpp
deleted file mode 100644
index 2a217eb..0000000
--- a/subprojects/quill-4.2.0/benchmarks/compile_time/qwrapper/include/qwrapper/qwrapper.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "qwrapper.h"
-
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/Logger.h"
-#include "quill/sinks/ConsoleSink.h"
-
-void setup_quill(char const* log_file)
-{
-  quill::Backend::start();
-
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("s1");
-
-  quill::Frontend::create_or_get_logger("root", std::move(console_sink),
-                                        "%(time) [%(thread_id)] %(short_source_location:<28) "
-                                        "LOG_%(log_level:<9) %(logger:<12) %(message)",
-                                        "%H:%M:%S.%Qns", quill::Timezone::GmtTime);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/benchmarks/compile_time/qwrapper/include/qwrapper/qwrapper.h b/subprojects/quill-4.2.0/benchmarks/compile_time/qwrapper/include/qwrapper/qwrapper.h
deleted file mode 100644
index c71a95e..0000000
--- a/subprojects/quill-4.2.0/benchmarks/compile_time/qwrapper/include/qwrapper/qwrapper.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#pragma once
-
-void setup_quill(char const* log_file);
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/benchmarks/hot_path_latency/CMakeLists.txt b/subprojects/quill-4.2.0/benchmarks/hot_path_latency/CMakeLists.txt
deleted file mode 100644
index cd521cf..0000000
--- a/subprojects/quill-4.2.0/benchmarks/hot_path_latency/CMakeLists.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-add_executable(BENCHMARK_quill_hot_path_rdtsc_clock hot_path_bench_config.h hot_path_bench.h quill_hot_path_rdtsc_clock.cpp)
-set_common_compile_options(BENCHMARK_quill_hot_path_rdtsc_clock)
-target_link_libraries(BENCHMARK_quill_hot_path_rdtsc_clock quill)
-
-add_executable(BENCHMARK_quill_hot_path_system_clock hot_path_bench_config.h hot_path_bench.h quill_hot_path_system_clock.cpp)
-set_common_compile_options(BENCHMARK_quill_hot_path_system_clock)
-target_link_libraries(BENCHMARK_quill_hot_path_system_clock quill)
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/benchmarks/hot_path_latency/hot_path_bench.h b/subprojects/quill-4.2.0/benchmarks/hot_path_latency/hot_path_bench.h
deleted file mode 100644
index f38297d..0000000
--- a/subprojects/quill-4.2.0/benchmarks/hot_path_latency/hot_path_bench.h
+++ /dev/null
@@ -1,204 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "hot_path_bench_config.h"
-
-#include "quill/backend/BackendUtilities.h"
-#include "quill/backend/RdtscClock.h"
-#include "quill/core/Rdtsc.h"
-
-#include <algorithm>
-#include <chrono>
-#include <cstdint>
-#include <functional>
-#include <iostream>
-#include <numeric>
-#include <random>
-#include <thread>
-
-#if defined(_WIN32)
-  #include <intrin.h>
-#else
-  #include <x86intrin.h>
-#endif
-
-inline uint16_t get_cpu_to_pin_thread(uint16_t thread_num)
-{
-  auto const num_cores = static_cast<uint16_t>(std::thread::hardware_concurrency());
-
-  // If hardware_concurrency feature is not supported, zero value is returned.
-  if (num_cores == 0)
-    return 0;
-
-  return thread_num % num_cores;
-}
-
-// Instead of sleep
-inline void wait(std::chrono::nanoseconds min, std::chrono::nanoseconds max)
-{
-#ifdef PERF_ENABLED
-  // when in perf use sleep as the other variables add noise
-  std::this_thread::sleep_for(max);
-#else
-  static std::random_device rd;
-  static std::mt19937 gen(rd());
-  static std::uniform_int_distribution<> dis(static_cast<int>(min.count()), static_cast<int>(max.count()));
-
-  auto const start_time = std::chrono::steady_clock::now();
-  auto const end_time = start_time.time_since_epoch() + std::chrono::nanoseconds{dis(gen)};
-  std::chrono::nanoseconds time_now;
-  do
-  {
-    time_now = std::chrono::steady_clock::now().time_since_epoch();
-  } while (time_now < end_time);
-#endif
-}
-
-#ifdef PERF_ENABLED
-/***/
-inline void run_log_benchmark(size_t num_iterations, size_t messages_per_iteration,
-                              std::function<void()> on_thread_start,
-                              std::function<void(uint64_t, uint64_t, double)> log_func,
-                              std::function<void()> on_thread_exit, size_t current_thread_num)
-{
-  // running thread affinity
-  quill::detail::set_cpu_affinity(get_cpu_to_pin_thread(current_thread_num));
-
-  on_thread_start();
-
-  unsigned int aux;
-  // Main Benchmark
-  for (size_t iteration = 0; iteration < num_iterations; ++iteration)
-  {
-    double const d = iteration + (0.1 * iteration);
-
-    auto const start = __rdtscp(&aux);
-    for (size_t i = 0; i < messages_per_iteration; ++i)
-    {
-      log_func(iteration, i, d);
-    }
-    auto const end = __rdtscp(&aux);
-
-    // send the next batch of messages after x time
-    wait(MIN_WAIT_DURATION, MAX_WAIT_DURATION);
-  }
-
-  on_thread_exit();
-}
-#else
-/***/
-inline void run_log_benchmark(size_t num_iterations, size_t messages_per_iteration,
-                              std::function<void()> const& on_thread_start,
-                              std::function<void(uint64_t, uint64_t, double)> const& log_func,
-                              std::function<void()> const& on_thread_exit, uint16_t current_thread_num,
-                              std::vector<uint64_t>& latencies, double rdtsc_ns_per_tick)
-{
-  // running thread affinity
-  quill::detail::set_cpu_affinity(get_cpu_to_pin_thread(current_thread_num));
-
-  on_thread_start();
-
-  unsigned int aux;
-  // Main Benchmark
-  for (size_t iteration = 0; iteration < num_iterations; ++iteration)
-  {
-    double const d = static_cast<double>(iteration) + (0.1 * static_cast<double>(iteration));
-
-    auto const start = __rdtscp(&aux);
-    for (size_t i = 0; i < messages_per_iteration; ++i)
-    {
-      log_func(iteration, i, d);
-    }
-    auto const end = __rdtscp(&aux);
-
-    uint64_t const latency{static_cast<uint64_t>(
-      static_cast<double>((end - start)) / static_cast<double>(messages_per_iteration) * rdtsc_ns_per_tick)};
-    latencies.push_back(latency);
-
-    // send the next batch of messages after x time
-    wait(MIN_WAIT_DURATION, MAX_WAIT_DURATION);
-  }
-
-  on_thread_exit();
-}
-#endif
-
-/***/
-inline void run_benchmark(char const* benchmark_name, uint16_t thread_count, size_t num_iterations,
-                          size_t messages_per_iteration, std::function<void()> const& on_thread_start,
-                          std::function<void(uint64_t, uint64_t, double)> const& log_func,
-                          std::function<void()> const& on_thread_exit)
-{
-  // main thread affinity
-  quill::detail::set_cpu_affinity(0);
-
-#ifndef PERF_ENABLED
-  std::cout << "running for " << thread_count << " thread(s)" << std::endl;
-
-  quill::detail::RdtscClock rdtsc_clock{std::chrono::minutes{30}};
-
-  // each thread gets a vector of latencies
-  std::vector<std::vector<uint64_t>> latencies;
-  latencies.resize(thread_count);
-  for (auto& elem : latencies)
-  {
-    elem.reserve(num_iterations);
-  }
-#endif
-
-  std::vector<std::thread> threads;
-  threads.reserve(thread_count);
-  for (uint16_t thread_num = 0; thread_num < thread_count; ++thread_num)
-  {
-#ifdef PERF_ENABLED
-    // Spawn num threads
-    threads.emplace_back(run_log_benchmark, num_iterations, (messages_per_iteration / thread_count),
-                         on_thread_start, log_func, on_thread_exit, thread_num + 1);
-#else
-    // Spawn num threads
-    threads.emplace_back(run_log_benchmark, num_iterations,
-                         static_cast<size_t>(messages_per_iteration / thread_count),
-                         std::ref(on_thread_start), std::ref(log_func), std::ref(on_thread_exit),
-                         static_cast<uint16_t>(thread_num + 1u), std::ref(latencies[thread_num]),
-                         rdtsc_clock.nanoseconds_per_tick());
-#endif
-  }
-
-  // Wait for threads to finish
-  for (uint16_t i = 0; i < thread_count; ++i)
-  {
-    threads[i].join();
-  }
-
-#ifndef PERF_ENABLED
-  // All threads have finished we can read all latencies
-  std::vector<uint64_t> latencies_combined;
-  latencies_combined.reserve(num_iterations * thread_count);
-  for (auto const& elem : latencies)
-  {
-    latencies_combined.insert(latencies_combined.end(), elem.begin(), elem.end());
-  }
-
-  // Sort all latencies
-  std::sort(latencies_combined.begin(), latencies_combined.end());
-
-  std::cout
-    << "Thread Count " << thread_count << " - Total messages " << latencies_combined.size() * messages_per_iteration
-    << " - " << benchmark_name << "\n |  50th | 75th | 90th | 95th | 99th | 99.9th | Worst |\n"
-    << " |  "
-    << latencies_combined[static_cast<size_t>(static_cast<double>(num_iterations * thread_count) * 0.5)] << "  |  "
-    << latencies_combined[static_cast<size_t>(static_cast<double>(num_iterations * thread_count) * 0.75)]
-    << "  |  "
-    << latencies_combined[static_cast<size_t>(static_cast<double>(num_iterations * thread_count) * 0.9)] << "  |  "
-    << latencies_combined[static_cast<size_t>(static_cast<double>(num_iterations * thread_count) * 0.95)]
-    << "  |  "
-    << latencies_combined[static_cast<size_t>(static_cast<double>(num_iterations * thread_count) * 0.99)]
-    << "  |  "
-    << latencies_combined[static_cast<size_t>(static_cast<double>(num_iterations * thread_count) * 0.999)]
-    << "  |  " << latencies_combined[static_cast<size_t>(latencies_combined.size() - 1)] << "  |\n\n";
-#endif
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/benchmarks/hot_path_latency/hot_path_bench_config.h b/subprojects/quill-4.2.0/benchmarks/hot_path_latency/hot_path_bench_config.h
deleted file mode 100644
index ab7113a..0000000
--- a/subprojects/quill-4.2.0/benchmarks/hot_path_latency/hot_path_bench_config.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-#include <chrono>
-
-/**
- * When running the benchmark using e.g. perf, enable this definition to remove extra noise
- * from calculating and printing the results.
- *
- * To see shared cached lines :
- * perf c2c record -g --call-graph dwarf,8192  ./benchmark_quill_call_site_latency
- * perf c2c report -NN -g --call-graph -c pid,iaddr --stdio
- */
-// #define PERF_ENABLED
-
-#define THREAD_LIST_COUNT                                                                          \
-  std::vector<uint16_t> { 1, 4 }
-
-#define MESSAGES_PER_ITERATION                                                                     \
-  std::size_t { 20 }
-
-#define ITERATIONS                                                                                 \
-  std::size_t { 100000 }
-
-/**
- * Min-Max wait duration between each iteration - This lets the backend thread catch up
- * a little bit with the caller thread, because the caller thread is so much faster.
- * When the backend thread can't catch up it will cause the caller thread on the hot path
- * to reallocate more space in the queue slowing it down.
- * This benchmark is measuring latency not high throughput
- * **/
-#define MIN_WAIT_DURATION                                                                          \
-  std::chrono::microseconds { 2000 }
-
-#define MAX_WAIT_DURATION                                                                          \
-  std::chrono::microseconds { 2200 }
diff --git a/subprojects/quill-4.2.0/benchmarks/hot_path_latency/quill_hot_path_rdtsc_clock.cpp b/subprojects/quill-4.2.0/benchmarks/hot_path_latency/quill_hot_path_rdtsc_clock.cpp
deleted file mode 100644
index 05aa0c4..0000000
--- a/subprojects/quill-4.2.0/benchmarks/hot_path_latency/quill_hot_path_rdtsc_clock.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/**
- * Adding a benchmark for a another logger should be straight forward by duplicating and modifying
- * this file.
- */
-
-#include "hot_path_bench.h"
-
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-struct FrontendOptions
-{
-  static constexpr quill::QueueType queue_type = quill::QueueType::UnboundedBlocking;
-  static constexpr uint32_t initial_queue_capacity = 131'072;
-  static constexpr uint32_t blocking_queue_retry_interval_ns = 800;
-  static constexpr bool huge_pages_enabled = false;
-};
-
-using Frontend = quill::FrontendImpl<FrontendOptions>;
-using Logger = quill::LoggerImpl<FrontendOptions>;
-
-/***/
-void quill_benchmark(std::vector<uint16_t> const& thread_count_array,
-                     size_t num_iterations_per_thread, size_t messages_per_iteration)
-{
-  /** - MAIN THREAD START - Logger setup if any **/
-
-  /** - Setup Quill **/
-  // main thread affinity
-  quill::detail::set_cpu_affinity(0);
-
-  quill::BackendOptions backend_options;
-  backend_options.backend_cpu_affinity = 5;
-
-  // Start the logging backend thread and give it some tiem to init
-  quill::Backend::start(backend_options);
-
-  std::this_thread::sleep_for(std::chrono::milliseconds{100});
-
-  // wait for the backend thread to start
-  std::this_thread::sleep_for(std::chrono::seconds(1));
-
-  // Create a file sink to write to a file
-  std::shared_ptr<quill::Sink> file_sink = Frontend::create_or_get_sink<quill::FileSink>(
-    "quill_hot_path_rdtsc_clock.log",
-    []()
-    {
-      quill::FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    quill::FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(
-    "bench_logger", std::move(file_sink),
-    "%(time) [%(thread_id)] %(short_source_location) %(log_level) %(message)");
-
-  /** LOGGING THREAD FUNCTIONS - on_start, on_exit, log_func must be implemented **/
-  /** those run on a several thread(s). It can be one or multiple threads based on THREAD_LIST_COUNT config */
-  auto on_start = []() {
-    // on thread start
-    Frontend::preallocate();
-  };
-
-  auto on_exit = [logger]()
-  {
-    // on thread exit we block flush, so the next benchmark starts with the backend thread ready
-    // to process the messages
-    logger->flush_log();
-  };
-
-  // on main
-  auto log_func = [logger](uint64_t k, uint64_t i, double d) {
-    // Main logging function
-    // This will get called MESSAGES_PER_ITERATION * ITERATIONS for each caller thread.
-    // MESSAGES_PER_ITERATION will get averaged to a single number
-
-    LOG_INFO(logger, "Logging iteration: {}, message: {}, double: {}", k, i, d);
-  };
-
-  /** ALWAYS REQUIRED **/
-  // Run the benchmark for n threads
-  for (auto thread_count : thread_count_array)
-  {
-    run_benchmark("Logger: Quill - Benchmark: Hot Path Latency / Nanoseconds", thread_count,
-                  num_iterations_per_thread, messages_per_iteration, on_start, log_func, on_exit);
-  }
-}
-
-/***/
-int main(int, char**) { quill_benchmark(THREAD_LIST_COUNT, ITERATIONS, MESSAGES_PER_ITERATION); }
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/benchmarks/hot_path_latency/quill_hot_path_system_clock.cpp b/subprojects/quill-4.2.0/benchmarks/hot_path_latency/quill_hot_path_system_clock.cpp
deleted file mode 100644
index 41f8b1c..0000000
--- a/subprojects/quill-4.2.0/benchmarks/hot_path_latency/quill_hot_path_system_clock.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/**
- * Adding a benchmark for a another logger should be straight forward by duplicating and modifying
- * this file.
- */
-
-#include "hot_path_bench.h"
-
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-struct FrontendOptions
-{
-  static constexpr quill::QueueType queue_type = quill::QueueType::UnboundedBlocking;
-  static constexpr uint32_t initial_queue_capacity = 131'072;
-  static constexpr uint32_t blocking_queue_retry_interval_ns = 800;
-  static constexpr bool huge_pages_enabled = false;
-};
-
-using Frontend = quill::FrontendImpl<FrontendOptions>;
-using Logger = quill::LoggerImpl<FrontendOptions>;
-
-/***/
-void quill_benchmark(std::vector<uint16_t> const& thread_count_array,
-                     size_t num_iterations_per_thread, size_t messages_per_iteration)
-{
-  /** - MAIN THREAD START - Logger setup if any **/
-
-  /** - Setup Quill **/
-  // main thread affinity
-  quill::detail::set_cpu_affinity(0);
-
-  quill::BackendOptions backend_options;
-  backend_options.backend_cpu_affinity = 5;
-
-  // Start the logging backend thread and give it some tiem to init
-  quill::Backend::start(backend_options);
-
-  std::this_thread::sleep_for(std::chrono::milliseconds{100});
-
-  // wait for the backend thread to start
-  std::this_thread::sleep_for(std::chrono::seconds(1));
-
-  // Create a file sink to write to a file
-  std::shared_ptr<quill::Sink> file_sink = Frontend::create_or_get_sink<quill::FileSink>(
-    "quill_hot_path_rdtsc_clock.log",
-    []()
-    {
-      quill::FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    quill::FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(
-    "bench_logger", std::move(file_sink),
-    "%(time) [%(thread_id)] %(short_source_location) %(log_level) %(message)", "%H:%M:%S.%Qns",
-    quill::Timezone::LocalTime, quill::ClockSourceType::System);
-
-  /** LOGGING THREAD FUNCTIONS - on_start, on_exit, log_func must be implemented **/
-  /** those run on a several thread(s). It can be one or multiple threads based on THREAD_LIST_COUNT config */
-  auto on_start = []()
-  {
-    // on thread start
-    Frontend::preallocate();
-  };
-
-  auto on_exit = [logger]()
-  {
-    // on thread exit we block flush, so the next benchmark starts with the backend thread ready
-    // to process the messages
-    logger->flush_log();
-  };
-
-  // on main
-  auto log_func = [logger](uint64_t k, uint64_t i, double d)
-  {
-    // Main logging function
-    // This will get called MESSAGES_PER_ITERATION * ITERATIONS for each caller thread.
-    // MESSAGES_PER_ITERATION will get averaged to a single number
-
-    LOG_INFO(logger, "Logging iteration: {}, message: {}, double: {}", k, i, d);
-  };
-
-  /** ALWAYS REQUIRED **/
-  // Run the benchmark for n threads
-  for (auto thread_count : thread_count_array)
-  {
-    run_benchmark("Logger: Quill - Benchmark: Hot Path Latency / Nanoseconds", thread_count,
-                  num_iterations_per_thread, messages_per_iteration, on_start, log_func, on_exit);
-  }
-}
-
-/***/
-int main(int, char**) { quill_benchmark(THREAD_LIST_COUNT, ITERATIONS, MESSAGES_PER_ITERATION); }
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/cmake/FindSphinx.cmake b/subprojects/quill-4.2.0/cmake/FindSphinx.cmake
deleted file mode 100644
index 24bf486..0000000
--- a/subprojects/quill-4.2.0/cmake/FindSphinx.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-#Look for an executable called sphinx-build
-find_program(SPHINX_EXECUTABLE
-        NAMES sphinx-build
-        DOC "Path to sphinx-build executable")
-
-include(FindPackageHandleStandardArgs)
-
-#Handle standard arguments to find_package like REQUIRED and QUIET
-find_package_handle_standard_args(Sphinx
-        "Failed to find sphinx-build executable"
-        SPHINX_EXECUTABLE)
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/cmake/SetCommonCompileOptions.cmake b/subprojects/quill-4.2.0/cmake/SetCommonCompileOptions.cmake
deleted file mode 100644
index 8ba5bf6..0000000
--- a/subprojects/quill-4.2.0/cmake/SetCommonCompileOptions.cmake
+++ /dev/null
@@ -1,21 +0,0 @@
-# Define the function to set common compile options
-function(set_common_compile_options target_name)
-    cmake_parse_arguments(COMPILE_OPTIONS "" "VISIBILITY" "" ${ARGN})
-
-    # Set default visibility to PRIVATE if not provided
-    if (NOT DEFINED COMPILE_OPTIONS_VISIBILITY)
-        set(COMPILE_OPTIONS_VISIBILITY PRIVATE)
-    endif ()
-
-    target_compile_options(${target_name} ${COMPILE_OPTIONS_VISIBILITY}
-            $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>:
-            -Wall -Wextra -Wconversion -pedantic -Wfatal-errors -Wno-unused-private-field -Wno-gnu-zero-variadic-macro-arguments -Wno-unused-parameter>
-            $<$<CXX_COMPILER_ID:MSVC>:/bigobj /WX /W4 /wd4324 /wd4189 /wd4996 /wd4100 /wd4127 /wd4702>)
-
-    # Additional MSVC specific options
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-        if (NOT QUILL_NO_EXCEPTIONS)
-            target_compile_options(${target_name} ${COMPILE_OPTIONS_VISIBILITY} /EHsc)
-        endif ()
-    endif ()
-endfunction()
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/cmake/doctest.cmake b/subprojects/quill-4.2.0/cmake/doctest.cmake
deleted file mode 100644
index 169bbcd..0000000
--- a/subprojects/quill-4.2.0/cmake/doctest.cmake
+++ /dev/null
@@ -1,189 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-doctest
------
-
-This module defines a function to help use the doctest test framework.
-
-The :command:`doctest_discover_tests` discovers tests by asking the compiled test
-executable to enumerate its tests.  This does not require CMake to be re-run
-when tests change.  However, it may not work in a cross-compiling environment,
-and setting test properties is less convenient.
-
-This command is intended to replace use of :command:`add_test` to register
-tests, and will create a separate CTest test for each doctest test case.  Note
-that this is in some cases less efficient, as common set-up and tear-down logic
-cannot be shared by multiple test cases executing in the same instance.
-However, it provides more fine-grained pass/fail information to CTest, which is
-usually considered as more beneficial.  By default, the CTest test name is the
-same as the doctest name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
-
-.. command:: doctest_discover_tests
-
-  Automatically add tests with CTest by querying the compiled test executable
-  for available tests::
-
-    doctest_discover_tests(target
-                         [TEST_SPEC arg1...]
-                         [EXTRA_ARGS arg1...]
-                         [WORKING_DIRECTORY dir]
-                         [TEST_PREFIX prefix]
-                         [TEST_SUFFIX suffix]
-                         [PROPERTIES name1 value1...]
-                         [ADD_LABELS value]
-                         [TEST_LIST var]
-                         [JUNIT_OUTPUT_DIR dir]
-    )
-
-  ``doctest_discover_tests`` sets up a post-build command on the test executable
-  that generates the list of tests by parsing the output from running the test
-  with the ``--list-test-cases`` argument.  This ensures that the full
-  list of tests is obtained.  Since test discovery occurs at build time, it is
-  not necessary to re-run CMake when the list of tests changes.
-  However, it requires that :prop_tgt:`CROSSCOMPILING_EMULATOR` is properly set
-  in order to function in a cross-compiling environment.
-
-  Additionally, setting properties on tests is somewhat less convenient, since
-  the tests are not available at CMake time.  Additional test properties may be
-  assigned to the set of tests as a whole using the ``PROPERTIES`` option.  If
-  more fine-grained test control is needed, custom content may be provided
-  through an external CTest script using the :prop_dir:`TEST_INCLUDE_FILES`
-  directory property.  The set of discovered tests is made accessible to such a
-  script via the ``<target>_TESTS`` variable.
-
-  The options are:
-
-  ``target``
-    Specifies the doctest executable, which must be a known CMake executable
-    target.  CMake will substitute the location of the built executable when
-    running the test.
-
-  ``TEST_SPEC arg1...``
-    Specifies test cases, wildcarded test cases, tags and tag expressions to
-    pass to the doctest executable with the ``--list-test-cases`` argument.
-
-  ``EXTRA_ARGS arg1...``
-    Any extra arguments to pass on the command line to each test case.
-
-  ``WORKING_DIRECTORY dir``
-    Specifies the directory in which to run the discovered test cases.  If this
-    option is not provided, the current binary directory is used.
-
-  ``TEST_PREFIX prefix``
-    Specifies a ``prefix`` to be prepended to the name of each discovered test
-    case.  This can be useful when the same test executable is being used in
-    multiple calls to ``doctest_discover_tests()`` but with different
-    ``TEST_SPEC`` or ``EXTRA_ARGS``.
-
-  ``TEST_SUFFIX suffix``
-    Similar to ``TEST_PREFIX`` except the ``suffix`` is appended to the name of
-    every discovered test case.  Both ``TEST_PREFIX`` and ``TEST_SUFFIX`` may
-    be specified.
-
-  ``PROPERTIES name1 value1...``
-    Specifies additional properties to be set on all tests discovered by this
-    invocation of ``doctest_discover_tests``.
-
-  ``ADD_LABELS value``
-    Specifies if the test labels should be set automatically.
-
-  ``TEST_LIST var``
-    Make the list of tests available in the variable ``var``, rather than the
-    default ``<target>_TESTS``.  This can be useful when the same test
-    executable is being used in multiple calls to ``doctest_discover_tests()``.
-    Note that this variable is only available in CTest.
-
-  ``JUNIT_OUTPUT_DIR dir``
-    If specified, the parameter is passed along with ``--reporters=junit``
-    and ``--out=`` to the test executable. The actual file name is the same
-    as the test target, including prefix and suffix. This should be used
-    instead of EXTRA_ARGS to avoid race conditions writing the XML result
-    output when using parallel test execution.
-
-#]=======================================================================]
-
-#------------------------------------------------------------------------------
-function(doctest_discover_tests TARGET)
-    cmake_parse_arguments(
-            ""
-            ""
-            "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST;JUNIT_OUTPUT_DIR"
-            "TEST_SPEC;EXTRA_ARGS;PROPERTIES;ADD_LABELS"
-            ${ARGN}
-    )
-
-    if(NOT _WORKING_DIRECTORY)
-        set(_WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
-    endif()
-    if(NOT _TEST_LIST)
-        set(_TEST_LIST ${TARGET}_TESTS)
-    endif()
-
-    ## Generate a unique name based on the extra arguments
-    string(SHA1 args_hash "${_TEST_SPEC} ${_EXTRA_ARGS}")
-    string(SUBSTRING ${args_hash} 0 7 args_hash)
-
-    # Define rule to generate test list for aforementioned test executable
-    set(ctest_include_file "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_include-${args_hash}.cmake")
-    set(ctest_tests_file "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_tests-${args_hash}.cmake")
-    get_property(crosscompiling_emulator
-            TARGET ${TARGET}
-            PROPERTY CROSSCOMPILING_EMULATOR
-            )
-    add_custom_command(
-            TARGET ${TARGET} POST_BUILD
-            BYPRODUCTS "${ctest_tests_file}"
-            COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_TARGET=${TARGET}"
-            -D "TEST_EXECUTABLE=$<TARGET_FILE:${TARGET}>"
-            -D "TEST_EXECUTOR=${crosscompiling_emulator}"
-            -D "TEST_WORKING_DIR=${_WORKING_DIRECTORY}"
-            -D "TEST_SPEC=${_TEST_SPEC}"
-            -D "TEST_EXTRA_ARGS=${_EXTRA_ARGS}"
-            -D "TEST_PROPERTIES=${_PROPERTIES}"
-            -D "TEST_ADD_LABELS=${_ADD_LABELS}"
-            -D "TEST_PREFIX=${_TEST_PREFIX}"
-            -D "TEST_SUFFIX=${_TEST_SUFFIX}"
-            -D "TEST_LIST=${_TEST_LIST}"
-            -D "TEST_JUNIT_OUTPUT_DIR=${_JUNIT_OUTPUT_DIR}"
-            -D "CTEST_FILE=${ctest_tests_file}"
-            -P "${_DOCTEST_DISCOVER_TESTS_SCRIPT}"
-            VERBATIM
-    )
-
-    file(WRITE "${ctest_include_file}"
-            "if(EXISTS \"${ctest_tests_file}\")\n"
-            "  include(\"${ctest_tests_file}\")\n"
-            "else()\n"
-            "  add_test(${TARGET}_NOT_BUILT-${args_hash} ${TARGET}_NOT_BUILT-${args_hash})\n"
-            "endif()\n"
-            )
-
-    if(NOT CMAKE_VERSION VERSION_LESS 3.10)
-        # Add discovered tests to directory TEST_INCLUDE_FILES
-        set_property(DIRECTORY
-                APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
-                )
-    else()
-        # Add discovered tests as directory TEST_INCLUDE_FILE if possible
-        get_property(test_include_file_set DIRECTORY PROPERTY TEST_INCLUDE_FILE SET)
-        if(NOT ${test_include_file_set})
-            set_property(DIRECTORY
-                    PROPERTY TEST_INCLUDE_FILE "${ctest_include_file}"
-                    )
-        else()
-            message(FATAL_ERROR
-                    "Cannot set more than one TEST_INCLUDE_FILE"
-                    )
-        endif()
-    endif()
-
-endfunction()
-
-###############################################################################
-
-set(_DOCTEST_DISCOVER_TESTS_SCRIPT
-        ${CMAKE_CURRENT_LIST_DIR}/doctestAddTests.cmake
-        )
diff --git a/subprojects/quill-4.2.0/cmake/doctestAddTests.cmake b/subprojects/quill-4.2.0/cmake/doctestAddTests.cmake
deleted file mode 100644
index ec7f21b..0000000
--- a/subprojects/quill-4.2.0/cmake/doctestAddTests.cmake
+++ /dev/null
@@ -1,120 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-set(prefix "${TEST_PREFIX}")
-set(suffix "${TEST_SUFFIX}")
-set(spec ${TEST_SPEC})
-set(extra_args ${TEST_EXTRA_ARGS})
-set(properties ${TEST_PROPERTIES})
-set(add_labels ${TEST_ADD_LABELS})
-set(junit_output_dir "${TEST_JUNIT_OUTPUT_DIR}")
-set(script)
-set(suite)
-set(tests)
-
-function(add_command NAME)
-    set(_args "")
-    foreach(_arg ${ARGN})
-        if(_arg MATCHES "[^-./:a-zA-Z0-9_]")
-            set(_args "${_args} [==[${_arg}]==]") # form a bracket_argument
-        else()
-            set(_args "${_args} ${_arg}")
-        endif()
-    endforeach()
-    set(script "${script}${NAME}(${_args})\n" PARENT_SCOPE)
-endfunction()
-
-# Run test executable to get list of available tests
-if(NOT EXISTS "${TEST_EXECUTABLE}")
-    message(FATAL_ERROR
-            "Specified test executable '${TEST_EXECUTABLE}' does not exist"
-            )
-endif()
-
-if("${spec}" MATCHES .)
-    set(spec "--test-case=${spec}")
-endif()
-
-execute_process(
-        COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} --list-test-cases
-        OUTPUT_VARIABLE output
-        RESULT_VARIABLE result
-        WORKING_DIRECTORY "${TEST_WORKING_DIR}"
-)
-if(NOT ${result} EQUAL 0)
-    message(FATAL_ERROR
-            "Error running test executable '${TEST_EXECUTABLE}':\n"
-            "  Result: ${result}\n"
-            "  Output: ${output}\n"
-            )
-endif()
-
-string(REPLACE "\n" ";" output "${output}")
-
-# Parse output
-foreach(line ${output})
-    if("${line}" STREQUAL "===============================================================================" OR "${line}" MATCHES [==[^\[doctest\] ]==])
-        continue()
-    endif()
-    set(test ${line})
-    set(labels "")
-    if(${add_labels})
-        # get test suite that test belongs to
-        execute_process(
-                COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" --test-case=${test} --list-test-suites
-                OUTPUT_VARIABLE labeloutput
-                RESULT_VARIABLE labelresult
-                WORKING_DIRECTORY "${TEST_WORKING_DIR}"
-        )
-        if(NOT ${labelresult} EQUAL 0)
-            message(FATAL_ERROR
-                    "Error running test executable '${TEST_EXECUTABLE}':\n"
-                    "  Result: ${labelresult}\n"
-                    "  Output: ${labeloutput}\n"
-                    )
-        endif()
-
-        string(REPLACE "\n" ";" labeloutput "${labeloutput}")
-        foreach(labelline ${labeloutput})
-            if("${labelline}" STREQUAL "===============================================================================" OR "${labelline}" MATCHES [==[^\[doctest\] ]==])
-                continue()
-            endif()
-            list(APPEND labels ${labelline})
-        endforeach()
-    endif()
-
-    if(NOT "${junit_output_dir}" STREQUAL "")
-        # turn testname into a valid filename by replacing all special characters with "-"
-        string(REGEX REPLACE "[/\\:\"|<>]" "-" test_filename "${test}")
-        set(TEST_JUNIT_OUTPUT_PARAM "--reporters=junit" "--out=${junit_output_dir}/${prefix}${test_filename}${suffix}.xml")
-    else()
-        unset(TEST_JUNIT_OUTPUT_PARAM)
-    endif()
-    # use escape commas to handle properly test cases with commas inside the name
-    string(REPLACE "," "\\," test_name ${test})
-    # ...and add to script
-    add_command(add_test
-            "${prefix}${test}${suffix}"
-            ${TEST_EXECUTOR}
-            "${TEST_EXECUTABLE}"
-            "--test-case=${test_name}"
-            "${TEST_JUNIT_OUTPUT_PARAM}"
-            ${extra_args}
-            )
-    add_command(set_tests_properties
-            "${prefix}${test}${suffix}"
-            PROPERTIES
-            WORKING_DIRECTORY "${TEST_WORKING_DIR}"
-            ${properties}
-            LABELS ${labels}
-            )
-    unset(labels)
-    list(APPEND tests "${prefix}${test}${suffix}")
-endforeach()
-
-# Create a list of all discovered tests, which users may use to e.g. set
-# properties on the tests
-add_command(set ${TEST_LIST} ${tests})
-
-# Write CTest script
-file(WRITE "${CTEST_FILE}" "${script}")
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/docs/CMakeLists.txt b/subprojects/quill-4.2.0/docs/CMakeLists.txt
deleted file mode 100644
index 1df3edf..0000000
--- a/subprojects/quill-4.2.0/docs/CMakeLists.txt
+++ /dev/null
@@ -1,55 +0,0 @@
-find_package(Doxygen REQUIRED)
-
-# Find all the public headers
-get_target_property(QUILL_PUBLIC_HEADER_DIR quill INTERFACE_INCLUDE_DIRECTORIES)
-file(GLOB_RECURSE QUILL_PUBLIC_HEADERS ${QUILL_PUBLIC_HEADER_DIR}/*.h)
-
-set(DOXYGEN_INPUT_DIR ${PROJECT_SOURCE_DIR}/quill)
-set(DOXYGEN_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/doxygen)
-set(DOXYGEN_INDEX_FILE ${DOXYGEN_OUTPUT_DIR}/xml/index.xml)
-set(DOXYFILE_IN ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in)
-set(DOXYFILE_OUT ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
-
-#Replace variables inside @@ with the current values
-configure_file(${DOXYFILE_IN} ${DOXYFILE_OUT} @ONLY)
-
-file(MAKE_DIRECTORY ${DOXYGEN_OUTPUT_DIR}) #Doxygen won't create this for us
-add_custom_command(OUTPUT ${DOXYGEN_INDEX_FILE}
-        DEPENDS ${QUILL_PUBLIC_HEADERS}
-        COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYFILE_OUT}
-        MAIN_DEPENDENCY ${DOXYFILE_OUT} ${DOXYFILE_IN}
-        COMMENT "Generating docs")
-
-add_custom_target(Doxygen ALL DEPENDS ${DOXYGEN_INDEX_FILE})
-
-find_package(Sphinx REQUIRED)
-
-set(SPHINX_SOURCE ${CMAKE_CURRENT_SOURCE_DIR})
-set(SPHINX_BUILD ${CMAKE_CURRENT_BINARY_DIR}/sphinx)
-set(SPHINX_INDEX_FILE ${SPHINX_BUILD}/index.html)
-
-# Only regenerate Sphinx when:
-# - Doxygen has rerun
-# - Our doc files have been updated
-# - The Sphinx config has been updated
-add_custom_command(OUTPUT ${SPHINX_INDEX_FILE}
-        COMMAND
-        ${SPHINX_EXECUTABLE} -b html
-        # Tell Breathe where to find the Doxygen output
-        -Dbreathe_projects.Quill=${DOXYGEN_OUTPUT_DIR}/xml
-        ${SPHINX_SOURCE} ${SPHINX_BUILD}
-        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-        DEPENDS
-        # Other docs files you want to track should go here (or in some variable)
-        ${CMAKE_CURRENT_SOURCE_DIR}/index.rst
-        ${CMAKE_CURRENT_SOURCE_DIR}/users-api.rst
-        ${CMAKE_CURRENT_SOURCE_DIR}/install.rst
-        ${CMAKE_CURRENT_SOURCE_DIR}/usage.rst
-        ${CMAKE_CURRENT_SOURCE_DIR}/tutorial.rst
-        ${CMAKE_CURRENT_SOURCE_DIR}/features.rst
-        ${DOXYGEN_INDEX_FILE}
-        MAIN_DEPENDENCY ${SPHINX_SOURCE}/conf.py
-        COMMENT "Generating documentation with Sphinx")
-
-# Nice named target so we can run the job easily
-add_custom_target(Sphinx ALL DEPENDS ${SPHINX_INDEX_FILE})
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/docs/Doxyfile.in b/subprojects/quill-4.2.0/docs/Doxyfile.in
deleted file mode 100644
index d30e770..0000000
--- a/subprojects/quill-4.2.0/docs/Doxyfile.in
+++ /dev/null
@@ -1,2660 +0,0 @@
-# Doxyfile 1.9.1
-
-# This file describes the settings to be used by the documentation system
-# doxygen (www.doxygen.org) for a project.
-#
-# All text after a double hash (##) is considered a comment and is placed in
-# front of the TAG it is preceding.
-#
-# All text after a single hash (#) is considered a comment and will be ignored.
-# The format is:
-# TAG = value [value, ...]
-# For lists, items can also be appended using:
-# TAG += value [value, ...]
-# Values that contain spaces should be placed between quotes (\" \").
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-
-# This tag specifies the encoding used for all characters in the configuration
-# file that follow. The default is UTF-8 which is also the encoding used for all
-# text before the first occurrence of this tag. Doxygen uses libiconv (or the
-# iconv built into libc) for the transcoding. See
-# https://www.gnu.org/software/libiconv/ for the list of possible encodings.
-# The default value is: UTF-8.
-
-DOXYFILE_ENCODING      = UTF-8
-
-# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
-# double-quotes, unless you are using Doxywizard) that should identify the
-# project for which the documentation is generated. This name is used in the
-# title of most generated pages and in a few other places.
-# The default value is: My Project.
-
-PROJECT_NAME           = "My Project"
-
-# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
-# could be handy for archiving the generated documentation or if some version
-# control system is used.
-
-PROJECT_NUMBER         =
-
-# Using the PROJECT_BRIEF tag one can provide an optional one line description
-# for a project that appears at the top of each page and should give viewer a
-# quick idea about the purpose of the project. Keep the description short.
-
-PROJECT_BRIEF          =
-
-# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
-# in the documentation. The maximum height of the logo should not exceed 55
-# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
-# the logo to the output directory.
-
-PROJECT_LOGO           =
-
-# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
-# into which the generated documentation will be written. If a relative path is
-# entered, it will be relative to the location where doxygen was started. If
-# left blank the current directory will be used.
-
-OUTPUT_DIRECTORY       = "@DOXYGEN_OUTPUT_DIR@"
-
-# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
-# directories (in 2 levels) under the output directory of each output format and
-# will distribute the generated files over these directories. Enabling this
-# option can be useful when feeding doxygen a huge amount of source files, where
-# putting all generated files in the same directory would otherwise causes
-# performance problems for the file system.
-# The default value is: NO.
-
-CREATE_SUBDIRS         = NO
-
-# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
-# characters to appear in the names of generated files. If set to NO, non-ASCII
-# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
-# U+3044.
-# The default value is: NO.
-
-ALLOW_UNICODE_NAMES    = NO
-
-# The OUTPUT_LANGUAGE tag is used to specify the language in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all constant output in the proper language.
-# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
-# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
-# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
-# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
-# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
-# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
-# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
-# Ukrainian and Vietnamese.
-# The default value is: English.
-
-OUTPUT_LANGUAGE        = English
-
-# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all generated output in the proper direction.
-# Possible values are: None, LTR, RTL and Context.
-# The default value is: None.
-
-OUTPUT_TEXT_DIRECTION  = None
-
-# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
-# descriptions after the members that are listed in the file and class
-# documentation (similar to Javadoc). Set to NO to disable this.
-# The default value is: YES.
-
-BRIEF_MEMBER_DESC      = YES
-
-# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
-# description of a member or function before the detailed description
-#
-# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
-# brief descriptions will be completely suppressed.
-# The default value is: YES.
-
-REPEAT_BRIEF           = YES
-
-# This tag implements a quasi-intelligent brief description abbreviator that is
-# used to form the text in various listings. Each string in this list, if found
-# as the leading text of the brief description, will be stripped from the text
-# and the result, after processing the whole list, is used as the annotated
-# text. Otherwise, the brief description is used as-is. If left blank, the
-# following values are used ($name is automatically replaced with the name of
-# the entity):The $name class, The $name widget, The $name file, is, provides,
-# specifies, contains, represents, a, an and the.
-
-ABBREVIATE_BRIEF       = "The $name class" \
-                         "The $name widget" \
-                         "The $name file" \
-                         is \
-                         provides \
-                         specifies \
-                         contains \
-                         represents \
-                         a \
-                         an \
-                         the
-
-# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
-# doxygen will generate a detailed section even if there is only a brief
-# description.
-# The default value is: NO.
-
-ALWAYS_DETAILED_SEC    = NO
-
-# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
-# inherited members of a class in the documentation of that class as if those
-# members were ordinary class members. Constructors, destructors and assignment
-# operators of the base classes will not be shown.
-# The default value is: NO.
-
-INLINE_INHERITED_MEMB  = NO
-
-# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
-# before files name in the file list and in the header files. If set to NO the
-# shortest path that makes the file name unique will be used
-# The default value is: YES.
-
-FULL_PATH_NAMES        = YES
-
-# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
-# Stripping is only done if one of the specified strings matches the left-hand
-# part of the path. The tag can be used to show relative paths in the file list.
-# If left blank the directory from which doxygen is run is used as the path to
-# strip.
-#
-# Note that you can specify absolute paths here, but also relative paths, which
-# will be relative from the directory where doxygen is started.
-# This tag requires that the tag FULL_PATH_NAMES is set to YES.
-
-STRIP_FROM_PATH        =
-
-# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
-# path mentioned in the documentation of a class, which tells the reader which
-# header file to include in order to use a class. If left blank only the name of
-# the header file containing the class definition is used. Otherwise one should
-# specify the list of include paths that are normally passed to the compiler
-# using the -I flag.
-
-STRIP_FROM_INC_PATH    =
-
-# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
-# less readable) file names. This can be useful is your file systems doesn't
-# support long names like on DOS, Mac, or CD-ROM.
-# The default value is: NO.
-
-SHORT_NAMES            = NO
-
-# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
-# first line (until the first dot) of a Javadoc-style comment as the brief
-# description. If set to NO, the Javadoc-style will behave just like regular Qt-
-# style comments (thus requiring an explicit @brief command for a brief
-# description.)
-# The default value is: NO.
-
-JAVADOC_AUTOBRIEF      = NO
-
-# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
-# such as
-# /***************
-# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
-# Javadoc-style will behave just like regular comments and it will not be
-# interpreted by doxygen.
-# The default value is: NO.
-
-JAVADOC_BANNER         = NO
-
-# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
-# line (until the first dot) of a Qt-style comment as the brief description. If
-# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
-# requiring an explicit \brief command for a brief description.)
-# The default value is: NO.
-
-QT_AUTOBRIEF           = NO
-
-# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
-# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
-# a brief description. This used to be the default behavior. The new default is
-# to treat a multi-line C++ comment block as a detailed description. Set this
-# tag to YES if you prefer the old behavior instead.
-#
-# Note that setting this tag to YES also means that rational rose comments are
-# not recognized any more.
-# The default value is: NO.
-
-MULTILINE_CPP_IS_BRIEF = NO
-
-# By default Python docstrings are displayed as preformatted text and doxygen's
-# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the
-# doxygen's special commands can be used and the contents of the docstring
-# documentation blocks is shown as doxygen documentation.
-# The default value is: YES.
-
-PYTHON_DOCSTRING       = YES
-
-# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
-# documentation from any documented member that it re-implements.
-# The default value is: YES.
-
-INHERIT_DOCS           = YES
-
-# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
-# page for each member. If set to NO, the documentation of a member will be part
-# of the file/class/namespace that contains it.
-# The default value is: NO.
-
-SEPARATE_MEMBER_PAGES  = NO
-
-# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
-# uses this value to replace tabs by spaces in code fragments.
-# Minimum value: 1, maximum value: 16, default value: 4.
-
-TAB_SIZE               = 4
-
-# This tag can be used to specify a number of aliases that act as commands in
-# the documentation. An alias has the form:
-# name=value
-# For example adding
-# "sideeffect=@par Side Effects:\n"
-# will allow you to put the command \sideeffect (or @sideeffect) in the
-# documentation, which will result in a user-defined paragraph with heading
-# "Side Effects:". You can put \n's in the value part of an alias to insert
-# newlines (in the resulting output). You can put ^^ in the value part of an
-# alias to insert a newline as if a physical newline was in the original file.
-# When you need a literal { or } or , in the value part of an alias you have to
-# escape them by means of a backslash (\), this can lead to conflicts with the
-# commands \{ and \} for these it is advised to use the version @{ and @} or use
-# a double escape (\\{ and \\})
-
-ALIASES                =
-
-# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
-# only. Doxygen will then generate output that is more tailored for C. For
-# instance, some of the names that are used will be different. The list of all
-# members will be omitted, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_FOR_C  = NO
-
-# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
-# Python sources only. Doxygen will then generate output that is more tailored
-# for that language. For instance, namespaces will be presented as packages,
-# qualified scopes will look different, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_JAVA   = NO
-
-# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
-# sources. Doxygen will then generate output that is tailored for Fortran.
-# The default value is: NO.
-
-OPTIMIZE_FOR_FORTRAN   = NO
-
-# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
-# sources. Doxygen will then generate output that is tailored for VHDL.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_VHDL   = NO
-
-# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice
-# sources only. Doxygen will then generate output that is more tailored for that
-# language. For instance, namespaces will be presented as modules, types will be
-# separated into more groups, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_SLICE  = NO
-
-# Doxygen selects the parser to use depending on the extension of the files it
-# parses. With this tag you can assign which parser to use for a given
-# extension. Doxygen has a built-in mapping, but you can override or extend it
-# using this tag. The format is ext=language, where ext is a file extension, and
-# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
-# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, VHDL,
-# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
-# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
-# tries to guess whether the code is fixed or free formatted code, this is the
-# default for Fortran type files). For instance to make doxygen treat .inc files
-# as Fortran files (default is PHP), and .f files as C (default is Fortran),
-# use: inc=Fortran f=C.
-#
-# Note: For files without extension you can use no_extension as a placeholder.
-#
-# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
-# the files are not read by doxygen. When specifying no_extension you should add
-# * to the FILE_PATTERNS.
-#
-# Note see also the list of default file extension mappings.
-
-EXTENSION_MAPPING      =
-
-# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
-# according to the Markdown format, which allows for more readable
-# documentation. See https://daringfireball.net/projects/markdown/ for details.
-# The output of markdown processing is further processed by doxygen, so you can
-# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
-# case of backward compatibilities issues.
-# The default value is: YES.
-
-MARKDOWN_SUPPORT       = YES
-
-# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
-# to that level are automatically included in the table of contents, even if
-# they do not have an id attribute.
-# Note: This feature currently applies only to Markdown headings.
-# Minimum value: 0, maximum value: 99, default value: 5.
-# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
-
-TOC_INCLUDE_HEADINGS   = 5
-
-# When enabled doxygen tries to link words that correspond to documented
-# classes, or namespaces to their corresponding documentation. Such a link can
-# be prevented in individual cases by putting a % sign in front of the word or
-# globally by setting AUTOLINK_SUPPORT to NO.
-# The default value is: YES.
-
-AUTOLINK_SUPPORT       = YES
-
-# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
-# to include (a tag file for) the STL sources as input, then you should set this
-# tag to YES in order to let doxygen match functions declarations and
-# definitions whose arguments contain STL classes (e.g. func(std::string);
-# versus func(std::string) {}). This also make the inheritance and collaboration
-# diagrams that involve STL classes more complete and accurate.
-# The default value is: NO.
-
-BUILTIN_STL_SUPPORT    = NO
-
-# If you use Microsoft's C++/CLI language, you should set this option to YES to
-# enable parsing support.
-# The default value is: NO.
-
-CPP_CLI_SUPPORT        = NO
-
-# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
-# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen
-# will parse them like normal C++ but will assume all classes use public instead
-# of private inheritance when no explicit protection keyword is present.
-# The default value is: NO.
-
-SIP_SUPPORT            = NO
-
-# For Microsoft's IDL there are propget and propput attributes to indicate
-# getter and setter methods for a property. Setting this option to YES will make
-# doxygen to replace the get and set methods by a property in the documentation.
-# This will only work if the methods are indeed getting or setting a simple
-# type. If this is not the case, or you want to show the methods anyway, you
-# should set this option to NO.
-# The default value is: YES.
-
-IDL_PROPERTY_SUPPORT   = YES
-
-# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
-# tag is set to YES then doxygen will reuse the documentation of the first
-# member in the group (if any) for the other members of the group. By default
-# all members of a group must be documented explicitly.
-# The default value is: NO.
-
-DISTRIBUTE_GROUP_DOC   = NO
-
-# If one adds a struct or class to a group and this option is enabled, then also
-# any nested class or struct is added to the same group. By default this option
-# is disabled and one has to add nested compounds explicitly via \ingroup.
-# The default value is: NO.
-
-GROUP_NESTED_COMPOUNDS = NO
-
-# Set the SUBGROUPING tag to YES to allow class member groups of the same type
-# (for instance a group of public functions) to be put as a subgroup of that
-# type (e.g. under the Public Functions section). Set it to NO to prevent
-# subgrouping. Alternatively, this can be done per class using the
-# \nosubgrouping command.
-# The default value is: YES.
-
-SUBGROUPING            = YES
-
-# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
-# are shown inside the group in which they are included (e.g. using \ingroup)
-# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
-# and RTF).
-#
-# Note that this feature does not work in combination with
-# SEPARATE_MEMBER_PAGES.
-# The default value is: NO.
-
-INLINE_GROUPED_CLASSES = NO
-
-# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
-# with only public data fields or simple typedef fields will be shown inline in
-# the documentation of the scope in which they are defined (i.e. file,
-# namespace, or group documentation), provided this scope is documented. If set
-# to NO, structs, classes, and unions are shown on a separate page (for HTML and
-# Man pages) or section (for LaTeX and RTF).
-# The default value is: NO.
-
-INLINE_SIMPLE_STRUCTS  = NO
-
-# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
-# enum is documented as struct, union, or enum with the name of the typedef. So
-# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
-# with name TypeT. When disabled the typedef will appear as a member of a file,
-# namespace, or class. And the struct will be named TypeS. This can typically be
-# useful for C code in case the coding convention dictates that all compound
-# types are typedef'ed and only the typedef is referenced, never the tag name.
-# The default value is: NO.
-
-TYPEDEF_HIDES_STRUCT   = NO
-
-# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
-# cache is used to resolve symbols given their name and scope. Since this can be
-# an expensive process and often the same symbol appears multiple times in the
-# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
-# doxygen will become slower. If the cache is too large, memory is wasted. The
-# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
-# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
-# symbols. At the end of a run doxygen will report the cache usage and suggest
-# the optimal cache size from a speed point of view.
-# Minimum value: 0, maximum value: 9, default value: 0.
-
-LOOKUP_CACHE_SIZE      = 0
-
-# The NUM_PROC_THREADS specifies the number threads doxygen is allowed to use
-# during processing. When set to 0 doxygen will based this on the number of
-# cores available in the system. You can set it explicitly to a value larger
-# than 0 to get more control over the balance between CPU load and processing
-# speed. At this moment only the input processing can be done using multiple
-# threads. Since this is still an experimental feature the default is set to 1,
-# which efficively disables parallel processing. Please report any issues you
-# encounter. Generating dot graphs in parallel is controlled by the
-# DOT_NUM_THREADS setting.
-# Minimum value: 0, maximum value: 32, default value: 1.
-
-NUM_PROC_THREADS       = 1
-
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-
-# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
-# documentation are documented, even if no documentation was available. Private
-# class members and static file members will be hidden unless the
-# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
-# Note: This will also disable the warnings about undocumented members that are
-# normally produced when WARNINGS is set to YES.
-# The default value is: NO.
-
-EXTRACT_ALL            = YES
-
-# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
-# be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PRIVATE        = YES
-
-# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
-# methods of a class will be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PRIV_VIRTUAL   = NO
-
-# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
-# scope will be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PACKAGE        = YES
-
-# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
-# included in the documentation.
-# The default value is: NO.
-
-EXTRACT_STATIC         = YES
-
-# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
-# locally in source files will be included in the documentation. If set to NO,
-# only classes defined in header files are included. Does not have any effect
-# for Java sources.
-# The default value is: YES.
-
-EXTRACT_LOCAL_CLASSES  = YES
-
-# This flag is only useful for Objective-C code. If set to YES, local methods,
-# which are defined in the implementation section but not in the interface are
-# included in the documentation. If set to NO, only methods in the interface are
-# included.
-# The default value is: NO.
-
-EXTRACT_LOCAL_METHODS  = YES
-
-# If this flag is set to YES, the members of anonymous namespaces will be
-# extracted and appear in the documentation as a namespace called
-# 'anonymous_namespace{file}', where file will be replaced with the base name of
-# the file that contains the anonymous namespace. By default anonymous namespace
-# are hidden.
-# The default value is: NO.
-
-EXTRACT_ANON_NSPACES   = NO
-
-# If this flag is set to YES, the name of an unnamed parameter in a declaration
-# will be determined by the corresponding definition. By default unnamed
-# parameters remain unnamed in the output.
-# The default value is: YES.
-
-RESOLVE_UNNAMED_PARAMS = YES
-
-# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
-# undocumented members inside documented classes or files. If set to NO these
-# members will be included in the various overviews, but no documentation
-# section is generated. This option has no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_MEMBERS     = NO
-
-# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
-# undocumented classes that are normally visible in the class hierarchy. If set
-# to NO, these classes will be included in the various overviews. This option
-# has no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_CLASSES     = NO
-
-# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
-# declarations. If set to NO, these declarations will be included in the
-# documentation.
-# The default value is: NO.
-
-HIDE_FRIEND_COMPOUNDS  = NO
-
-# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
-# documentation blocks found inside the body of a function. If set to NO, these
-# blocks will be appended to the function's detailed documentation block.
-# The default value is: NO.
-
-HIDE_IN_BODY_DOCS      = NO
-
-# The INTERNAL_DOCS tag determines if documentation that is typed after a
-# \internal command is included. If the tag is set to NO then the documentation
-# will be excluded. Set it to YES to include the internal documentation.
-# The default value is: NO.
-
-INTERNAL_DOCS          = NO
-
-# With the correct setting of option CASE_SENSE_NAMES doxygen will better be
-# able to match the capabilities of the underlying filesystem. In case the
-# filesystem is case sensitive (i.e. it supports files in the same directory
-# whose names only differ in casing), the option must be set to YES to properly
-# deal with such files in case they appear in the input. For filesystems that
-# are not case sensitive the option should be be set to NO to properly deal with
-# output files written for symbols that only differ in casing, such as for two
-# classes, one named CLASS and the other named Class, and to also support
-# references to files without having to specify the exact matching casing. On
-# Windows (including Cygwin) and MacOS, users should typically set this option
-# to NO, whereas on Linux or other Unix flavors it should typically be set to
-# YES.
-# The default value is: system dependent.
-
-CASE_SENSE_NAMES       = YES
-
-# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
-# their full class and namespace scopes in the documentation. If set to YES, the
-# scope will be hidden.
-# The default value is: NO.
-
-HIDE_SCOPE_NAMES       = NO
-
-# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
-# append additional text to a page's title, such as Class Reference. If set to
-# YES the compound reference will be hidden.
-# The default value is: NO.
-
-HIDE_COMPOUND_REFERENCE= NO
-
-# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
-# the files that are included by a file in the documentation of that file.
-# The default value is: YES.
-
-SHOW_INCLUDE_FILES     = YES
-
-# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
-# grouped member an include statement to the documentation, telling the reader
-# which file to include in order to use the member.
-# The default value is: NO.
-
-SHOW_GROUPED_MEMB_INC  = NO
-
-# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
-# files with double quotes in the documentation rather than with sharp brackets.
-# The default value is: NO.
-
-FORCE_LOCAL_INCLUDES   = NO
-
-# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
-# documentation for inline members.
-# The default value is: YES.
-
-INLINE_INFO            = YES
-
-# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
-# (detailed) documentation of file and class members alphabetically by member
-# name. If set to NO, the members will appear in declaration order.
-# The default value is: YES.
-
-SORT_MEMBER_DOCS       = YES
-
-# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
-# descriptions of file, namespace and class members alphabetically by member
-# name. If set to NO, the members will appear in declaration order. Note that
-# this will also influence the order of the classes in the class list.
-# The default value is: NO.
-
-SORT_BRIEF_DOCS        = NO
-
-# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
-# (brief and detailed) documentation of class members so that constructors and
-# destructors are listed first. If set to NO the constructors will appear in the
-# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
-# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
-# member documentation.
-# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
-# detailed member documentation.
-# The default value is: NO.
-
-SORT_MEMBERS_CTORS_1ST = NO
-
-# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
-# of group names into alphabetical order. If set to NO the group names will
-# appear in their defined order.
-# The default value is: NO.
-
-SORT_GROUP_NAMES       = NO
-
-# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
-# fully-qualified names, including namespaces. If set to NO, the class list will
-# be sorted only by class name, not including the namespace part.
-# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
-# Note: This option applies only to the class list, not to the alphabetical
-# list.
-# The default value is: NO.
-
-SORT_BY_SCOPE_NAME     = NO
-
-# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
-# type resolution of all parameters of a function it will reject a match between
-# the prototype and the implementation of a member function even if there is
-# only one candidate or it is obvious which candidate to choose by doing a
-# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
-# accept a match between prototype and implementation in such cases.
-# The default value is: NO.
-
-STRICT_PROTO_MATCHING  = NO
-
-# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
-# list. This list is created by putting \todo commands in the documentation.
-# The default value is: YES.
-
-GENERATE_TODOLIST      = YES
-
-# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
-# list. This list is created by putting \test commands in the documentation.
-# The default value is: YES.
-
-GENERATE_TESTLIST      = YES
-
-# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
-# list. This list is created by putting \bug commands in the documentation.
-# The default value is: YES.
-
-GENERATE_BUGLIST       = YES
-
-# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
-# the deprecated list. This list is created by putting \deprecated commands in
-# the documentation.
-# The default value is: YES.
-
-GENERATE_DEPRECATEDLIST= YES
-
-# The ENABLED_SECTIONS tag can be used to enable conditional documentation
-# sections, marked by \if <section_label> ... \endif and \cond <section_label>
-# ... \endcond blocks.
-
-ENABLED_SECTIONS       =
-
-# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
-# initial value of a variable or macro / define can have for it to appear in the
-# documentation. If the initializer consists of more lines than specified here
-# it will be hidden. Use a value of 0 to hide initializers completely. The
-# appearance of the value of individual variables and macros / defines can be
-# controlled using \showinitializer or \hideinitializer command in the
-# documentation regardless of this setting.
-# Minimum value: 0, maximum value: 10000, default value: 30.
-
-MAX_INITIALIZER_LINES  = 30
-
-# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
-# the bottom of the documentation of classes and structs. If set to YES, the
-# list will mention the files that were used to generate the documentation.
-# The default value is: YES.
-
-SHOW_USED_FILES        = YES
-
-# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
-# will remove the Files entry from the Quick Index and from the Folder Tree View
-# (if specified).
-# The default value is: YES.
-
-SHOW_FILES             = YES
-
-# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
-# page. This will remove the Namespaces entry from the Quick Index and from the
-# Folder Tree View (if specified).
-# The default value is: YES.
-
-SHOW_NAMESPACES        = YES
-
-# The FILE_VERSION_FILTER tag can be used to specify a program or script that
-# doxygen should invoke to get the current version for each file (typically from
-# the version control system). Doxygen will invoke the program by executing (via
-# popen()) the command command input-file, where command is the value of the
-# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
-# by doxygen. Whatever the program writes to standard output is used as the file
-# version. For an example see the documentation.
-
-FILE_VERSION_FILTER    =
-
-# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
-# by doxygen. The layout file controls the global structure of the generated
-# output files in an output format independent way. To create the layout file
-# that represents doxygen's defaults, run doxygen with the -l option. You can
-# optionally specify a file name after the option, if omitted DoxygenLayout.xml
-# will be used as the name of the layout file.
-#
-# Note that if you run doxygen from a directory containing a file called
-# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
-# tag is left empty.
-
-LAYOUT_FILE            =
-
-# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
-# the reference definitions. This must be a list of .bib files. The .bib
-# extension is automatically appended if omitted. This requires the bibtex tool
-# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
-# For LaTeX the style of the bibliography can be controlled using
-# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
-# search path. See also \cite for info how to create references.
-
-CITE_BIB_FILES         =
-
-#---------------------------------------------------------------------------
-# Configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-
-# The QUIET tag can be used to turn on/off the messages that are generated to
-# standard output by doxygen. If QUIET is set to YES this implies that the
-# messages are off.
-# The default value is: NO.
-
-QUIET                  = NO
-
-# The WARNINGS tag can be used to turn on/off the warning messages that are
-# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
-# this implies that the warnings are on.
-#
-# Tip: Turn warnings on while writing the documentation.
-# The default value is: YES.
-
-WARNINGS               = YES
-
-# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
-# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
-# will automatically be disabled.
-# The default value is: YES.
-
-WARN_IF_UNDOCUMENTED   = YES
-
-# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some parameters
-# in a documented function, or documenting parameters that don't exist or using
-# markup commands wrongly.
-# The default value is: YES.
-
-WARN_IF_DOC_ERROR      = YES
-
-# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
-# are documented, but have no documentation for their parameters or return
-# value. If set to NO, doxygen will only warn about wrong or incomplete
-# parameter documentation, but not about the absence of documentation. If
-# EXTRACT_ALL is set to YES then this flag will automatically be disabled.
-# The default value is: NO.
-
-WARN_NO_PARAMDOC       = NO
-
-# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
-# a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
-# then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
-# at the end of the doxygen process doxygen will return with a non-zero status.
-# Possible values are: NO, YES and FAIL_ON_WARNINGS.
-# The default value is: NO.
-
-WARN_AS_ERROR          = NO
-
-# The WARN_FORMAT tag determines the format of the warning messages that doxygen
-# can produce. The string should contain the $file, $line, and $text tags, which
-# will be replaced by the file and line number from which the warning originated
-# and the warning text. Optionally the format may contain $version, which will
-# be replaced by the version of the file (if it could be obtained via
-# FILE_VERSION_FILTER)
-# The default value is: $file:$line: $text.
-
-WARN_FORMAT            = "$file:$line: $text"
-
-# The WARN_LOGFILE tag can be used to specify a file to which warning and error
-# messages should be written. If left blank the output is written to standard
-# error (stderr).
-
-WARN_LOGFILE           =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the input files
-#---------------------------------------------------------------------------
-
-# The INPUT tag is used to specify the files and/or directories that contain
-# documented source files. You may enter file names like myfile.cpp or
-# directories like /usr/src/myproject. Separate the files or directories with
-# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
-# Note: If this tag is empty the current directory is searched.
-
-INPUT                  = "@DOXYGEN_INPUT_DIR@"
-
-# This tag can be used to specify the character encoding of the source files
-# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
-# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
-# documentation (see:
-# https://www.gnu.org/software/libiconv/) for the list of possible encodings.
-# The default value is: UTF-8.
-
-INPUT_ENCODING         = UTF-8
-
-# If the value of the INPUT tag contains directories, you can use the
-# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
-# *.h) to filter out the source-files in the directories.
-#
-# Note that for custom extensions or not directly supported extensions you also
-# need to set EXTENSION_MAPPING for the extension otherwise the files are not
-# read by doxygen.
-#
-# Note the list of default checked file patterns might differ from the list of
-# default file extension mappings.
-#
-# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
-# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
-# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
-# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment),
-# *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd, *.vhdl,
-# *.ucf, *.qsf and *.ice.
-
-FILE_PATTERNS          = *.c \
-                         *.cc \
-                         *.cxx \
-                         *.cpp \
-                         *.c++ \
-                         *.java \
-                         *.ii \
-                         *.ixx \
-                         *.ipp \
-                         *.i++ \
-                         *.inl \
-                         *.idl \
-                         *.ddl \
-                         *.odl \
-                         *.h \
-                         *.hh \
-                         *.hxx \
-                         *.hpp \
-                         *.h++ \
-                         *.cs \
-                         *.d \
-                         *.php \
-                         *.php4 \
-                         *.php5 \
-                         *.phtml \
-                         *.inc \
-                         *.m \
-                         *.markdown \
-                         *.md \
-                         *.mm \
-                         *.dox \
-                         *.py \
-                         *.pyw \
-                         *.f90 \
-                         *.f95 \
-                         *.f03 \
-                         *.f08 \
-                         *.f18 \
-                         *.f \
-                         *.for \
-                         *.vhd \
-                         *.vhdl \
-                         *.ucf \
-                         *.qsf \
-                         *.ice
-
-# The RECURSIVE tag can be used to specify whether or not subdirectories should
-# be searched for input files as well.
-# The default value is: NO.
-
-RECURSIVE              = YES
-
-# The EXCLUDE tag can be used to specify files and/or directories that should be
-# excluded from the INPUT source files. This way you can easily exclude a
-# subdirectory from a directory tree whose root is specified with the INPUT tag.
-#
-# Note that relative paths are relative to the directory from which doxygen is
-# run.
-
-EXCLUDE                =
-
-# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
-# directories that are symbolic links (a Unix file system feature) are excluded
-# from the input.
-# The default value is: NO.
-
-EXCLUDE_SYMLINKS       = NO
-
-# If the value of the INPUT tag contains directories, you can use the
-# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
-# certain files from those directories.
-#
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories for example use the pattern */test/*
-
-EXCLUDE_PATTERNS       = */quill/bundled/* */src/bundled/* */test/*
-
-# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
-# (namespaces, classes, functions, etc.) that should be excluded from the
-# output. The symbol name can be a fully qualified name, a word, or if the
-# wildcard * is used, a substring. Examples: ANamespace, AClass,
-# AClass::ANamespace, ANamespace::*Test
-#
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories use the pattern */test/*
-
-EXCLUDE_SYMBOLS        =
-
-# The EXAMPLE_PATH tag can be used to specify one or more files or directories
-# that contain example code fragments that are included (see the \include
-# command).
-
-EXAMPLE_PATH           =
-
-# If the value of the EXAMPLE_PATH tag contains directories, you can use the
-# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
-# *.h) to filter out the source-files in the directories. If left blank all
-# files are included.
-
-EXAMPLE_PATTERNS       = *
-
-# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
-# searched for input files to be used with the \include or \dontinclude commands
-# irrespective of the value of the RECURSIVE tag.
-# The default value is: NO.
-
-EXAMPLE_RECURSIVE      = NO
-
-# The IMAGE_PATH tag can be used to specify one or more files or directories
-# that contain images that are to be included in the documentation (see the
-# \image command).
-
-IMAGE_PATH             =
-
-# The INPUT_FILTER tag can be used to specify a program that doxygen should
-# invoke to filter for each input file. Doxygen will invoke the filter program
-# by executing (via popen()) the command:
-#
-# <filter> <input-file>
-#
-# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
-# name of an input file. Doxygen will then use the output that the filter
-# program writes to standard output. If FILTER_PATTERNS is specified, this tag
-# will be ignored.
-#
-# Note that the filter must not add or remove lines; it is applied before the
-# code is scanned, but not when the output code is generated. If lines are added
-# or removed, the anchors will not be placed correctly.
-#
-# Note that for custom extensions or not directly supported extensions you also
-# need to set EXTENSION_MAPPING for the extension otherwise the files are not
-# properly processed by doxygen.
-
-INPUT_FILTER           =
-
-# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
-# basis. Doxygen will compare the file name with each pattern and apply the
-# filter if there is a match. The filters are a list of the form: pattern=filter
-# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
-# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
-# patterns match the file name, INPUT_FILTER is applied.
-#
-# Note that for custom extensions or not directly supported extensions you also
-# need to set EXTENSION_MAPPING for the extension otherwise the files are not
-# properly processed by doxygen.
-
-FILTER_PATTERNS        =
-
-# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
-# INPUT_FILTER) will also be used to filter the input files that are used for
-# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
-# The default value is: NO.
-
-FILTER_SOURCE_FILES    = NO
-
-# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
-# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
-# it is also possible to disable source filtering for a specific pattern using
-# *.ext= (so without naming a filter).
-# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
-
-FILTER_SOURCE_PATTERNS =
-
-# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
-# is part of the input, its contents will be placed on the main page
-# (index.html). This can be useful if you have a project on for instance GitHub
-# and want to reuse the introduction page also for the doxygen output.
-
-USE_MDFILE_AS_MAINPAGE =
-
-#---------------------------------------------------------------------------
-# Configuration options related to source browsing
-#---------------------------------------------------------------------------
-
-# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
-# generated. Documented entities will be cross-referenced with these sources.
-#
-# Note: To get rid of all source code in the generated output, make sure that
-# also VERBATIM_HEADERS is set to NO.
-# The default value is: NO.
-
-SOURCE_BROWSER         = NO
-
-# Setting the INLINE_SOURCES tag to YES will include the body of functions,
-# classes and enums directly into the documentation.
-# The default value is: NO.
-
-INLINE_SOURCES         = NO
-
-# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
-# special comment blocks from generated source code fragments. Normal C, C++ and
-# Fortran comments will always remain visible.
-# The default value is: YES.
-
-STRIP_CODE_COMMENTS    = YES
-
-# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
-# entity all documented functions referencing it will be listed.
-# The default value is: NO.
-
-REFERENCED_BY_RELATION = NO
-
-# If the REFERENCES_RELATION tag is set to YES then for each documented function
-# all documented entities called/used by that function will be listed.
-# The default value is: NO.
-
-REFERENCES_RELATION    = NO
-
-# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
-# to YES then the hyperlinks from functions in REFERENCES_RELATION and
-# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
-# link to the documentation.
-# The default value is: YES.
-
-REFERENCES_LINK_SOURCE = YES
-
-# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
-# source code will show a tooltip with additional information such as prototype,
-# brief description and links to the definition and documentation. Since this
-# will make the HTML file larger and loading of large files a bit slower, you
-# can opt to disable this feature.
-# The default value is: YES.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-SOURCE_TOOLTIPS        = YES
-
-# If the USE_HTAGS tag is set to YES then the references to source code will
-# point to the HTML generated by the htags(1) tool instead of doxygen built-in
-# source browser. The htags tool is part of GNU's global source tagging system
-# (see https://www.gnu.org/software/global/global.html). You will need version
-# 4.8.6 or higher.
-#
-# To use it do the following:
-# - Install the latest version of global
-# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file
-# - Make sure the INPUT points to the root of the source tree
-# - Run doxygen as normal
-#
-# Doxygen will invoke htags (and that will in turn invoke gtags), so these
-# tools must be available from the command line (i.e. in the search path).
-#
-# The result: instead of the source browser generated by doxygen, the links to
-# source code will now point to the output of htags.
-# The default value is: NO.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-USE_HTAGS              = NO
-
-# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
-# verbatim copy of the header file for each class for which an include is
-# specified. Set to NO to disable this.
-# See also: Section \class.
-# The default value is: YES.
-
-VERBATIM_HEADERS       = YES
-
-# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
-# clang parser (see:
-# http://clang.llvm.org/) for more accurate parsing at the cost of reduced
-# performance. This can be particularly helpful with template rich C++ code for
-# which doxygen's built-in parser lacks the necessary type information.
-# Note: The availability of this option depends on whether or not doxygen was
-# generated with the -Duse_libclang=ON option for CMake.
-# The default value is: NO.
-
-CLANG_ASSISTED_PARSING = NO
-
-# If clang assisted parsing is enabled and the CLANG_ADD_INC_PATHS tag is set to
-# YES then doxygen will add the directory of each input to the include path.
-# The default value is: YES.
-
-CLANG_ADD_INC_PATHS    = YES
-
-# If clang assisted parsing is enabled you can provide the compiler with command
-# line options that you would normally use when invoking the compiler. Note that
-# the include paths will already be set by doxygen for the files and directories
-# specified with INPUT and INCLUDE_PATH.
-# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
-
-CLANG_OPTIONS          =
-
-# If clang assisted parsing is enabled you can provide the clang parser with the
-# path to the directory containing a file called compile_commands.json. This
-# file is the compilation database (see:
-# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) containing the
-# options used when the source files were built. This is equivalent to
-# specifying the -p option to a clang tool, such as clang-check. These options
-# will then be passed to the parser. Any options specified with CLANG_OPTIONS
-# will be added as well.
-# Note: The availability of this option depends on whether or not doxygen was
-# generated with the -Duse_libclang=ON option for CMake.
-
-CLANG_DATABASE_PATH    =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-
-# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
-# compounds will be generated. Enable this if the project contains a lot of
-# classes, structs, unions or interfaces.
-# The default value is: YES.
-
-ALPHABETICAL_INDEX     = YES
-
-# In case all classes in a project start with a common prefix, all classes will
-# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
-# can be used to specify a prefix (or a list of prefixes) that should be ignored
-# while generating the index headers.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-IGNORE_PREFIX          =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the HTML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
-# The default value is: YES.
-
-GENERATE_HTML          = NO
-
-# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_OUTPUT            = html
-
-# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
-# generated HTML page (for example: .htm, .php, .asp).
-# The default value is: .html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FILE_EXTENSION    = .html
-
-# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
-# each generated HTML page. If the tag is left blank doxygen will generate a
-# standard header.
-#
-# To get valid HTML the header file that includes any scripts and style sheets
-# that doxygen needs, which is dependent on the configuration options used (e.g.
-# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
-# default header using
-# doxygen -w html new_header.html new_footer.html new_stylesheet.css
-# YourConfigFile
-# and then modify the file new_header.html. See also section "Doxygen usage"
-# for information on how to generate the default header that doxygen normally
-# uses.
-# Note: The header is subject to change so you typically have to regenerate the
-# default header when upgrading to a newer version of doxygen. For a description
-# of the possible markers and block names see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_HEADER            =
-
-# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
-# generated HTML page. If the tag is left blank doxygen will generate a standard
-# footer. See HTML_HEADER for more information on how to generate a default
-# footer and what special commands can be used inside the footer. See also
-# section "Doxygen usage" for information on how to generate the default footer
-# that doxygen normally uses.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FOOTER            =
-
-# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
-# sheet that is used by each HTML page. It can be used to fine-tune the look of
-# the HTML output. If left blank doxygen will generate a default style sheet.
-# See also section "Doxygen usage" for information on how to generate the style
-# sheet that doxygen normally uses.
-# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
-# it is more robust and this tag (HTML_STYLESHEET) will in the future become
-# obsolete.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_STYLESHEET        =
-
-# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
-# cascading style sheets that are included after the standard style sheets
-# created by doxygen. Using this option one can overrule certain style aspects.
-# This is preferred over using HTML_STYLESHEET since it does not replace the
-# standard style sheet and is therefore more robust against future updates.
-# Doxygen will copy the style sheet files to the output directory.
-# Note: The order of the extra style sheet files is of importance (e.g. the last
-# style sheet in the list overrules the setting of the previous ones in the
-# list). For an example see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_STYLESHEET  =
-
-# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the HTML output directory. Note
-# that these files will be copied to the base HTML output directory. Use the
-# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
-# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
-# files will be copied as-is; there are no commands or markers available.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_FILES       =
-
-# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
-# will adjust the colors in the style sheet and background images according to
-# this color. Hue is specified as an angle on a colorwheel, see
-# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
-# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
-# purple, and 360 is red again.
-# Minimum value: 0, maximum value: 359, default value: 220.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_HUE    = 220
-
-# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
-# in the HTML output. For a value of 0 the output will use grayscales only. A
-# value of 255 will produce the most vivid colors.
-# Minimum value: 0, maximum value: 255, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_SAT    = 100
-
-# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
-# luminance component of the colors in the HTML output. Values below 100
-# gradually make the output lighter, whereas values above 100 make the output
-# darker. The value divided by 100 is the actual gamma applied, so 80 represents
-# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
-# change the gamma.
-# Minimum value: 40, maximum value: 240, default value: 80.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_GAMMA  = 80
-
-# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
-# page will contain the date and time when the page was generated. Setting this
-# to YES can help to show when doxygen was last run and thus if the
-# documentation is up to date.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_TIMESTAMP         = NO
-
-# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
-# documentation will contain a main index with vertical navigation menus that
-# are dynamically created via JavaScript. If disabled, the navigation index will
-# consists of multiple levels of tabs that are statically embedded in every HTML
-# page. Disable this option to support browsers that do not have JavaScript,
-# like the Qt help browser.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_DYNAMIC_MENUS     = YES
-
-# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
-# documentation will contain sections that can be hidden and shown after the
-# page has loaded.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_DYNAMIC_SECTIONS  = NO
-
-# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
-# shown in the various tree structured indices initially; the user can expand
-# and collapse entries dynamically later on. Doxygen will expand the tree to
-# such a level that at most the specified number of entries are visible (unless
-# a fully collapsed tree already exceeds this amount). So setting the number of
-# entries 1 will produce a full collapsed tree by default. 0 is a special value
-# representing an infinite number of entries and will result in a full expanded
-# tree by default.
-# Minimum value: 0, maximum value: 9999, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_INDEX_NUM_ENTRIES = 100
-
-# If the GENERATE_DOCSET tag is set to YES, additional index files will be
-# generated that can be used as input for Apple's Xcode 3 integrated development
-# environment (see:
-# https://developer.apple.com/xcode/), introduced with OSX 10.5 (Leopard). To
-# create a documentation set, doxygen will generate a Makefile in the HTML
-# output directory. Running make will produce the docset in that directory and
-# running make install will install the docset in
-# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
-# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
-# genXcode/_index.html for more information.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_DOCSET        = NO
-
-# This tag determines the name of the docset feed. A documentation feed provides
-# an umbrella under which multiple documentation sets from a single provider
-# (such as a company or product suite) can be grouped.
-# The default value is: Doxygen generated docs.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_FEEDNAME        = "Doxygen generated docs"
-
-# This tag specifies a string that should uniquely identify the documentation
-# set bundle. This should be a reverse domain-name style string, e.g.
-# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_BUNDLE_ID       = org.doxygen.Project
-
-# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
-# the documentation publisher. This should be a reverse domain-name style
-# string, e.g. com.mycompany.MyDocSet.documentation.
-# The default value is: org.doxygen.Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
-
-# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
-# The default value is: Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_NAME  = Publisher
-
-# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
-# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
-# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see:
-# https://www.microsoft.com/en-us/download/details.aspx?id=21138) on Windows.
-#
-# The HTML Help Workshop contains a compiler that can convert all HTML output
-# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
-# files are now used as the Windows 98 help format, and will replace the old
-# Windows help format (.hlp) on all Windows platforms in the future. Compressed
-# HTML files also contain an index, a table of contents, and you can search for
-# words in the documentation. The HTML workshop also contains a viewer for
-# compressed HTML files.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_HTMLHELP      = NO
-
-# The CHM_FILE tag can be used to specify the file name of the resulting .chm
-# file. You can add a path in front of the file if the result should not be
-# written to the html output directory.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_FILE               =
-
-# The HHC_LOCATION tag can be used to specify the location (absolute path
-# including file name) of the HTML help compiler (hhc.exe). If non-empty,
-# doxygen will try to run the HTML help compiler on the generated index.hhp.
-# The file has to be specified with full path.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-HHC_LOCATION           =
-
-# The GENERATE_CHI flag controls if a separate .chi index file is generated
-# (YES) or that it should be included in the main .chm file (NO).
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-GENERATE_CHI           = NO
-
-# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
-# and project file content.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_INDEX_ENCODING     =
-
-# The BINARY_TOC flag controls whether a binary table of contents is generated
-# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
-# enables the Previous and Next buttons.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-BINARY_TOC             = NO
-
-# The TOC_EXPAND flag can be set to YES to add extra items for group members to
-# the table of contents of the HTML help documentation and to the tree view.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-TOC_EXPAND             = NO
-
-# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
-# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
-# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
-# (.qch) of the generated HTML documentation.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_QHP           = NO
-
-# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
-# the file name of the resulting .qch file. The path specified is relative to
-# the HTML output folder.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QCH_FILE               =
-
-# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
-# Project output. For more information please see Qt Help Project / Namespace
-# (see:
-# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_NAMESPACE          = org.doxygen.Project
-
-# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
-# Help Project output. For more information please see Qt Help Project / Virtual
-# Folders (see:
-# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders).
-# The default value is: doc.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_VIRTUAL_FOLDER     = doc
-
-# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
-# filter to add. For more information please see Qt Help Project / Custom
-# Filters (see:
-# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_NAME   =
-
-# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
-# custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see:
-# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_ATTRS  =
-
-# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
-# project's filter section matches. Qt Help Project / Filter Attributes (see:
-# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_SECT_FILTER_ATTRS  =
-
-# The QHG_LOCATION tag can be used to specify the location (absolute path
-# including file name) of Qt's qhelpgenerator. If non-empty doxygen will try to
-# run qhelpgenerator on the generated .qhp file.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHG_LOCATION           =
-
-# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
-# generated, together with the HTML files, they form an Eclipse help plugin. To
-# install this plugin and make it available under the help contents menu in
-# Eclipse, the contents of the directory containing the HTML and XML files needs
-# to be copied into the plugins directory of eclipse. The name of the directory
-# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
-# After copying Eclipse needs to be restarted before the help appears.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_ECLIPSEHELP   = NO
-
-# A unique identifier for the Eclipse help plugin. When installing the plugin
-# the directory name containing the HTML and XML files should also have this
-# name. Each documentation set should have its own identifier.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
-
-ECLIPSE_DOC_ID         = org.doxygen.Project
-
-# If you want full control over the layout of the generated HTML pages it might
-# be necessary to disable the index and replace it with your own. The
-# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
-# of each HTML page. A value of NO enables the index and the value YES disables
-# it. Since the tabs in the index contain the same information as the navigation
-# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-DISABLE_INDEX          = NO
-
-# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
-# structure should be generated to display hierarchical information. If the tag
-# value is set to YES, a side panel will be generated containing a tree-like
-# index structure (just like the one that is generated for HTML Help). For this
-# to work a browser that supports JavaScript, DHTML, CSS and frames is required
-# (i.e. any modern browser). Windows users are probably better off using the
-# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
-# further fine-tune the look of the index. As an example, the default style
-# sheet generated by doxygen has an example that shows how to put an image at
-# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
-# the same information as the tab index, you could consider setting
-# DISABLE_INDEX to YES when enabling this option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_TREEVIEW      = NO
-
-# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
-# doxygen will group on one line in the generated HTML documentation.
-#
-# Note that a value of 0 will completely suppress the enum values from appearing
-# in the overview section.
-# Minimum value: 0, maximum value: 20, default value: 4.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-ENUM_VALUES_PER_LINE   = 4
-
-# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
-# to set the initial width (in pixels) of the frame in which the tree is shown.
-# Minimum value: 0, maximum value: 1500, default value: 250.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-TREEVIEW_WIDTH         = 250
-
-# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
-# external symbols imported via tag files in a separate window.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-EXT_LINKS_IN_WINDOW    = NO
-
-# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg
-# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
-# https://inkscape.org) to generate formulas as SVG images instead of PNGs for
-# the HTML output. These images will generally look nicer at scaled resolutions.
-# Possible values are: png (the default) and svg (looks nicer but requires the
-# pdf2svg or inkscape tool).
-# The default value is: png.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FORMULA_FORMAT    = png
-
-# Use this tag to change the font size of LaTeX formulas included as images in
-# the HTML documentation. When you change the font size after a successful
-# doxygen run you need to manually remove any form_*.png images from the HTML
-# output directory to force them to be regenerated.
-# Minimum value: 8, maximum value: 50, default value: 10.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_FONTSIZE       = 10
-
-# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
-# generated for formulas are transparent PNGs. Transparent PNGs are not
-# supported properly for IE 6.0, but are supported on all modern browsers.
-#
-# Note that when changing this option you need to delete any form_*.png files in
-# the HTML output directory before the changes have effect.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_TRANSPARENT    = YES
-
-# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
-# to create new LaTeX commands to be used in formulas as building blocks. See
-# the section "Including formulas" for details.
-
-FORMULA_MACROFILE      =
-
-# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
-# https://www.mathjax.org) which uses client side JavaScript for the rendering
-# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
-# installed or if you want to formulas look prettier in the HTML output. When
-# enabled you may also need to install MathJax separately and configure the path
-# to it using the MATHJAX_RELPATH option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-USE_MATHJAX            = NO
-
-# When MathJax is enabled you can set the default output format to be used for
-# the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details.
-# Possible values are: HTML-CSS (which is slower, but has the best
-# compatibility), NativeMML (i.e. MathML) and SVG.
-# The default value is: HTML-CSS.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_FORMAT         = HTML-CSS
-
-# When MathJax is enabled you need to specify the location relative to the HTML
-# output directory using the MATHJAX_RELPATH option. The destination directory
-# should contain the MathJax.js script. For instance, if the mathjax directory
-# is located at the same level as the HTML output directory, then
-# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
-# Content Delivery Network so you can quickly see the result without installing
-# MathJax. However, it is strongly recommended to install a local copy of
-# MathJax from https://www.mathjax.org before deployment.
-# The default value is: https://cdn.jsdelivr.net/npm/mathjax@2.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_RELPATH        = https://cdn.jsdelivr.net/npm/mathjax@2
-
-# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
-# extension names that should be enabled during MathJax rendering. For example
-# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_EXTENSIONS     =
-
-# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
-# of code that will be used on startup of the MathJax code. See the MathJax site
-# (see:
-# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details. For an
-# example see the documentation.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_CODEFILE       =
-
-# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
-# the HTML output. The underlying search engine uses javascript and DHTML and
-# should work on any modern browser. Note that when using HTML help
-# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
-# there is already a search function so this one should typically be disabled.
-# For large projects the javascript based search engine can be slow, then
-# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
-# search using the keyboard; to jump to the search box use <access key> + S
-# (what the <access key> is depends on the OS and browser, but it is typically
-# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
-# key> to jump into the search results window, the results can be navigated
-# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
-# the search. The filter options can be selected when the cursor is inside the
-# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
-# to select a filter and <Enter> or <escape> to activate or cancel the filter
-# option.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-SEARCHENGINE           = NO
-
-# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a web server instead of a web client using JavaScript. There
-# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
-# setting. When disabled, doxygen will generate a PHP script for searching and
-# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
-# and searching needs to be provided by external tools. See the section
-# "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SERVER_BASED_SEARCH    = NO
-
-# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
-# script for searching. Instead the search results are written to an XML file
-# which needs to be processed by an external indexer. Doxygen will invoke an
-# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
-# search results.
-#
-# Doxygen ships with an example indexer (doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see:
-# https://xapian.org/).
-#
-# See the section "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH        = NO
-
-# The SEARCHENGINE_URL should point to a search engine hosted by a web server
-# which will return the search results when EXTERNAL_SEARCH is enabled.
-#
-# Doxygen ships with an example indexer (doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see:
-# https://xapian.org/). See the section "External Indexing and Searching" for
-# details.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHENGINE_URL       =
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
-# search data is written to a file for indexing by an external tool. With the
-# SEARCHDATA_FILE tag the name of this file can be specified.
-# The default file is: searchdata.xml.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHDATA_FILE        = searchdata.xml
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
-# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
-# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
-# projects and redirect the results back to the right project.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH_ID     =
-
-# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
-# projects other than the one defined by this configuration file, but that are
-# all added to the same external search index. Each project needs to have a
-# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
-# to a relative location where the documentation can be found. The format is:
-# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTRA_SEARCH_MAPPINGS  =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
-# The default value is: YES.
-
-GENERATE_LATEX         = NO
-
-# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: latex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_OUTPUT           = latex
-
-# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
-# invoked.
-#
-# Note that when not enabling USE_PDFLATEX the default is latex when enabling
-# USE_PDFLATEX the default is pdflatex and when in the later case latex is
-# chosen this is overwritten by pdflatex. For specific output languages the
-# default can have been set differently, this depends on the implementation of
-# the output language.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_CMD_NAME         =
-
-# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
-# index for LaTeX.
-# Note: This tag is used in the Makefile / make.bat.
-# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file
-# (.tex).
-# The default file is: makeindex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-MAKEINDEX_CMD_NAME     = makeindex
-
-# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
-# generate index for LaTeX. In case there is no backslash (\) as first character
-# it will be automatically added in the LaTeX code.
-# Note: This tag is used in the generated output file (.tex).
-# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
-# The default value is: makeindex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_MAKEINDEX_CMD    = makeindex
-
-# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-COMPACT_LATEX          = NO
-
-# The PAPER_TYPE tag can be used to set the paper type that is used by the
-# printer.
-# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
-# 14 inches) and executive (7.25 x 10.5 inches).
-# The default value is: a4.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PAPER_TYPE             = a4
-
-# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
-# that should be included in the LaTeX output. The package can be specified just
-# by its name or with the correct syntax as to be used with the LaTeX
-# \usepackage command. To get the times font for instance you can specify :
-# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
-# To use the option intlimits with the amsmath package you can specify:
-# EXTRA_PACKAGES=[intlimits]{amsmath}
-# If left blank no extra packages will be included.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-EXTRA_PACKAGES         =
-
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
-# generated LaTeX document. The header should contain everything until the first
-# chapter. If it is left blank doxygen will generate a standard header. See
-# section "Doxygen usage" for information on how to let doxygen write the
-# default header to a separate file.
-#
-# Note: Only use a user-defined header if you know what you are doing! The
-# following commands have a special meaning inside the header: $title,
-# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
-# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
-# string, for the replacement values of the other commands the user is referred
-# to HTML_HEADER.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HEADER           =
-
-# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
-# generated LaTeX document. The footer should contain everything after the last
-# chapter. If it is left blank doxygen will generate a standard footer. See
-# LATEX_HEADER for more information on how to generate a default footer and what
-# special commands can be used inside the footer.
-#
-# Note: Only use a user-defined footer if you know what you are doing!
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_FOOTER           =
-
-# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
-# LaTeX style sheets that are included after the standard style sheets created
-# by doxygen. Using this option one can overrule certain style aspects. Doxygen
-# will copy the style sheet files to the output directory.
-# Note: The order of the extra style sheet files is of importance (e.g. the last
-# style sheet in the list overrules the setting of the previous ones in the
-# list).
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EXTRA_STYLESHEET =
-
-# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the LATEX_OUTPUT output
-# directory. Note that the files will be copied as-is; there are no commands or
-# markers available.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EXTRA_FILES      =
-
-# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
-# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
-# contain links (just like the HTML output) instead of page references. This
-# makes the output suitable for online browsing using a PDF viewer.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PDF_HYPERLINKS         = YES
-
-# If the USE_PDFLATEX tag is set to YES, doxygen will use the engine as
-# specified with LATEX_CMD_NAME to generate the PDF file directly from the LaTeX
-# files. Set this option to YES, to get a higher quality PDF documentation.
-#
-# See also section LATEX_CMD_NAME for selecting the engine.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-USE_PDFLATEX           = YES
-
-# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
-# command to the generated LaTeX files. This will instruct LaTeX to keep running
-# if errors occur, instead of asking the user for help. This option is also used
-# when generating formulas in HTML.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BATCHMODE        = NO
-
-# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
-# index chapters (such as File Index, Compound Index, etc.) in the output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HIDE_INDICES     = NO
-
-# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
-# code with syntax highlighting in the LaTeX output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_SOURCE_CODE      = NO
-
-# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
-# bibliography, e.g. plainnat, or ieeetr. See
-# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
-# The default value is: plain.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BIB_STYLE        = plain
-
-# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
-# page will contain the date and time when the page was generated. Setting this
-# to NO can help when comparing the output of multiple runs.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_TIMESTAMP        = NO
-
-# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
-# path from which the emoji images will be read. If a relative path is entered,
-# it will be relative to the LATEX_OUTPUT directory. If left blank the
-# LATEX_OUTPUT directory will be used.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EMOJI_DIRECTORY  =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the RTF output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
-# RTF output is optimized for Word 97 and may not look too pretty with other RTF
-# readers/editors.
-# The default value is: NO.
-
-GENERATE_RTF           = NO
-
-# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: rtf.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_OUTPUT             = rtf
-
-# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-COMPACT_RTF            = NO
-
-# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
-# contain hyperlink fields. The RTF file will contain links (just like the HTML
-# output) instead of page references. This makes the output suitable for online
-# browsing using Word or some other Word compatible readers that support those
-# fields.
-#
-# Note: WordPad (write) and others do not support links.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_HYPERLINKS         = NO
-
-# Load stylesheet definitions from file. Syntax is similar to doxygen's
-# configuration file, i.e. a series of assignments. You only have to provide
-# replacements, missing definitions are set to their default value.
-#
-# See also section "Doxygen usage" for information on how to generate the
-# default style sheet that doxygen normally uses.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_STYLESHEET_FILE    =
-
-# Set optional variables used in the generation of an RTF document. Syntax is
-# similar to doxygen's configuration file. A template extensions file can be
-# generated using doxygen -e rtf extensionFile.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_EXTENSIONS_FILE    =
-
-# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
-# with syntax highlighting in the RTF output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_SOURCE_CODE        = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the man page output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
-# classes and files.
-# The default value is: NO.
-
-GENERATE_MAN           = NO
-
-# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it. A directory man3 will be created inside the directory specified by
-# MAN_OUTPUT.
-# The default directory is: man.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_OUTPUT             = man
-
-# The MAN_EXTENSION tag determines the extension that is added to the generated
-# man pages. In case the manual section does not start with a number, the number
-# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
-# optional.
-# The default value is: .3.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_EXTENSION          = .3
-
-# The MAN_SUBDIR tag determines the name of the directory created within
-# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
-# MAN_EXTENSION with the initial . removed.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_SUBDIR             =
-
-# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
-# will generate one additional man file for each entity documented in the real
-# man page(s). These additional files only source the real man page, but without
-# them the man command would be unable to find the correct page.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_LINKS              = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the XML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
-# captures the structure of the code including all documentation.
-# The default value is: NO.
-
-GENERATE_XML           = YES
-
-# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: xml.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_OUTPUT             = xml
-
-# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
-# listings (including syntax highlighting and cross-referencing information) to
-# the XML output. Note that enabling this will significantly increase the size
-# of the XML output.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_PROGRAMLISTING     = YES
-
-# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include
-# namespace members in file scope as well, matching the HTML output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_NS_MEMB_FILE_SCOPE = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the DOCBOOK output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
-# that can be used to generate PDF.
-# The default value is: NO.
-
-GENERATE_DOCBOOK       = NO
-
-# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
-# front of it.
-# The default directory is: docbook.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_OUTPUT         = docbook
-
-# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
-# program listings (including syntax highlighting and cross-referencing
-# information) to the DOCBOOK output. Note that enabling this will significantly
-# increase the size of the DOCBOOK output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_PROGRAMLISTING = NO
-
-#---------------------------------------------------------------------------
-# Configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
-# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
-# the structure of the code including all documentation. Note that this feature
-# is still experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_AUTOGEN_DEF   = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
-# file that captures the structure of the code including all documentation.
-#
-# Note that this feature is still experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_PERLMOD       = NO
-
-# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
-# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
-# output from the Perl module output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_LATEX          = NO
-
-# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
-# formatted so it can be parsed by a human reader. This is useful if you want to
-# understand what is going on. On the other hand, if this tag is set to NO, the
-# size of the Perl module output will be much smaller and Perl will parse it
-# just the same.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_PRETTY         = YES
-
-# The names of the make variables in the generated doxyrules.make file are
-# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
-# so different doxyrules.make files included by the same Makefile don't
-# overwrite each other's variables.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_MAKEVAR_PREFIX =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-
-# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
-# C-preprocessor directives found in the sources and include files.
-# The default value is: YES.
-
-ENABLE_PREPROCESSING   = YES
-
-# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
-# in the source code. If set to NO, only conditional compilation will be
-# performed. Macro expansion can be done in a controlled way by setting
-# EXPAND_ONLY_PREDEF to YES.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-MACRO_EXPANSION        = YES
-
-# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
-# the macro expansion is limited to the macros specified with the PREDEFINED and
-# EXPAND_AS_DEFINED tags.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_ONLY_PREDEF     = NO
-
-# If the SEARCH_INCLUDES tag is set to YES, the include files in the
-# INCLUDE_PATH will be searched if a #include is found.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SEARCH_INCLUDES        = YES
-
-# The INCLUDE_PATH tag can be used to specify one or more directories that
-# contain include files that are not input files but should be processed by the
-# preprocessor.
-# This tag requires that the tag SEARCH_INCLUDES is set to YES.
-
-INCLUDE_PATH           =
-
-# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
-# patterns (like *.h and *.hpp) to filter out the header-files in the
-# directories. If left blank, the patterns specified with FILE_PATTERNS will be
-# used.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-INCLUDE_FILE_PATTERNS  =
-
-# The PREDEFINED tag can be used to specify one or more macro names that are
-# defined before the preprocessor is started (similar to the -D option of e.g.
-# gcc). The argument of the tag is a list of macros of the form: name or
-# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
-# is assumed. To prevent a macro definition from being undefined via #undef or
-# recursively expanded use the := operator instead of the = operator.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-PREDEFINED             =  QUILL_ATTRIBUTE_HOT= \
-                          QUILL_NODISCARD= \
-                          QUILL_ATTRIBUTE_COLD=
-
-# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
-# tag can be used to specify a list of macro names that should be expanded. The
-# macro definition that is found in the sources will be used. Use the PREDEFINED
-# tag if you want to use a different macro definition that overrules the
-# definition found in the source code.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_AS_DEFINED      =
-
-# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
-# remove all references to function-like macros that are alone on a line, have
-# an all uppercase name, and do not end with a semicolon. Such function macros
-# are typically used for boiler-plate code, and will confuse the parser if not
-# removed.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SKIP_FUNCTION_MACROS   = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to external references
-#---------------------------------------------------------------------------
-
-# The TAGFILES tag can be used to specify one or more tag files. For each tag
-# file the location of the external documentation should be added. The format of
-# a tag file without this location is as follows:
-# TAGFILES = file1 file2 ...
-# Adding location for the tag files is done as follows:
-# TAGFILES = file1=loc1 "file2 = loc2" ...
-# where loc1 and loc2 can be relative or absolute paths or URLs. See the
-# section "Linking to external documentation" for more information about the use
-# of tag files.
-# Note: Each tag file must have a unique name (where the name does NOT include
-# the path). If a tag file is not located in the directory in which doxygen is
-# run, you must also specify the path to the tagfile here.
-
-TAGFILES               =
-
-# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
-# tag file that is based on the input files it reads. See section "Linking to
-# external documentation" for more information about the usage of tag files.
-
-GENERATE_TAGFILE       =
-
-# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
-# the class index. If set to NO, only the inherited external classes will be
-# listed.
-# The default value is: NO.
-
-ALLEXTERNALS           = NO
-
-# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
-# in the modules index. If set to NO, only the current project's groups will be
-# listed.
-# The default value is: YES.
-
-EXTERNAL_GROUPS        = YES
-
-# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
-# the related pages index. If set to NO, only the current project's pages will
-# be listed.
-# The default value is: YES.
-
-EXTERNAL_PAGES         = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool
-#---------------------------------------------------------------------------
-
-# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
-# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
-# NO turns the diagrams off. Note that this option also works with HAVE_DOT
-# disabled, but it is recommended to install and use dot, since it yields more
-# powerful graphs.
-# The default value is: YES.
-
-CLASS_DIAGRAMS         = YES
-
-# You can include diagrams made with dia in doxygen documentation. Doxygen will
-# then run dia to produce the diagram and insert it in the documentation. The
-# DIA_PATH tag allows you to specify the directory where the dia binary resides.
-# If left empty dia is assumed to be found in the default search path.
-
-DIA_PATH               =
-
-# If set to YES the inheritance and collaboration graphs will hide inheritance
-# and usage relations if the target is undocumented or is not a class.
-# The default value is: YES.
-
-HIDE_UNDOC_RELATIONS   = YES
-
-# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
-# available from the path. This tool is part of Graphviz (see:
-# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
-# Bell Labs. The other options in this section have no effect if this option is
-# set to NO
-# The default value is: YES.
-
-HAVE_DOT               = YES
-
-# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
-# to run in parallel. When set to 0 doxygen will base this on the number of
-# processors available in the system. You can set it explicitly to a value
-# larger than 0 to get control over the balance between CPU load and processing
-# speed.
-# Minimum value: 0, maximum value: 32, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_NUM_THREADS        = 0
-
-# When you want a differently looking font in the dot files that doxygen
-# generates you can specify the font name using DOT_FONTNAME. You need to make
-# sure dot is able to find the font, which can be done by putting it in a
-# standard location or by setting the DOTFONTPATH environment variable or by
-# setting DOT_FONTPATH to the directory containing the font.
-# The default value is: Helvetica.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTNAME           = Helvetica
-
-# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
-# dot graphs.
-# Minimum value: 4, maximum value: 24, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTSIZE           = 10
-
-# By default doxygen will tell dot to use the default font as specified with
-# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
-# the path where dot can find it using this tag.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTPATH           =
-
-# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
-# each documented class showing the direct and indirect inheritance relations.
-# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CLASS_GRAPH            = YES
-
-# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
-# graph for each documented class showing the direct and indirect implementation
-# dependencies (inheritance, containment, and class references variables) of the
-# class with other documented classes.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-COLLABORATION_GRAPH    = YES
-
-# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
-# groups, showing the direct groups dependencies.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GROUP_GRAPHS           = YES
-
-# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
-# collaboration diagrams in a style similar to the OMG's Unified Modeling
-# Language.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-UML_LOOK               = NO
-
-# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
-# class node. If there are many fields or methods and many nodes the graph may
-# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
-# number of items for each type to make the size more manageable. Set this to 0
-# for no limit. Note that the threshold may be exceeded by 50% before the limit
-# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
-# but if the number exceeds 15, the total amount of fields shown is limited to
-# 10.
-# Minimum value: 0, maximum value: 100, default value: 10.
-# This tag requires that the tag UML_LOOK is set to YES.
-
-UML_LIMIT_NUM_FIELDS   = 10
-
-# If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and
-# methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS
-# tag is set to YES, doxygen will add type and arguments for attributes and
-# methods in the UML graphs. If the DOT_UML_DETAILS tag is set to NONE, doxygen
-# will not generate fields with class member information in the UML graphs. The
-# class diagrams will look similar to the default class diagrams but using UML
-# notation for the relationships.
-# Possible values are: NO, YES and NONE.
-# The default value is: NO.
-# This tag requires that the tag UML_LOOK is set to YES.
-
-DOT_UML_DETAILS        = NO
-
-# The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters
-# to display on a single line. If the actual line length exceeds this threshold
-# significantly it will wrapped across multiple lines. Some heuristics are apply
-# to avoid ugly line breaks.
-# Minimum value: 0, maximum value: 1000, default value: 17.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_WRAP_THRESHOLD     = 17
-
-# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
-# collaboration graphs will show the relations between templates and their
-# instances.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-TEMPLATE_RELATIONS     = NO
-
-# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
-# YES then doxygen will generate a graph for each documented file showing the
-# direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDE_GRAPH          = YES
-
-# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
-# set to YES then doxygen will generate a graph for each documented file showing
-# the direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDED_BY_GRAPH      = YES
-
-# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
-# dependency graph for every global function or class method.
-#
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable call graphs for selected
-# functions only using the \callgraph command. Disabling a call graph can be
-# accomplished by means of the command \hidecallgraph.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALL_GRAPH             = NO
-
-# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
-# dependency graph for every global function or class method.
-#
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable caller graphs for selected
-# functions only using the \callergraph command. Disabling a caller graph can be
-# accomplished by means of the command \hidecallergraph.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALLER_GRAPH           = NO
-
-# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
-# hierarchy of all classes instead of a textual one.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GRAPHICAL_HIERARCHY    = YES
-
-# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
-# dependencies a directory has on other directories in a graphical way. The
-# dependency relations are determined by the #include relations between the
-# files in the directories.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DIRECTORY_GRAPH        = YES
-
-# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
-# generated by dot. For an explanation of the image formats see the section
-# output formats in the documentation of the dot tool (Graphviz (see:
-# http://www.graphviz.org/)).
-# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
-# to make the SVG files visible in IE 9+ (other browsers do not have this
-# requirement).
-# Possible values are: png, png:cairo, png:cairo:cairo, png:cairo:gd, png:gd,
-# png:gd:gd, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, gif, gif:cairo,
-# gif:cairo:gd, gif:gd, gif:gd:gd, svg, png:gd, png:gd:gd, png:cairo,
-# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
-# png:gdiplus:gdiplus.
-# The default value is: png.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_IMAGE_FORMAT       = png
-
-# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
-# enable generation of interactive SVG images that allow zooming and panning.
-#
-# Note that this requires a modern browser other than Internet Explorer. Tested
-# and working are Firefox, Chrome, Safari, and Opera.
-# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
-# the SVG files visible. Older versions of IE do not have SVG support.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INTERACTIVE_SVG        = NO
-
-# The DOT_PATH tag can be used to specify the path where the dot tool can be
-# found. If left blank, it is assumed the dot tool can be found in the path.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_PATH               =
-
-# The DOTFILE_DIRS tag can be used to specify one or more directories that
-# contain dot files that are included in the documentation (see the \dotfile
-# command).
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOTFILE_DIRS           =
-
-# The MSCFILE_DIRS tag can be used to specify one or more directories that
-# contain msc files that are included in the documentation (see the \mscfile
-# command).
-
-MSCFILE_DIRS           =
-
-# The DIAFILE_DIRS tag can be used to specify one or more directories that
-# contain dia files that are included in the documentation (see the \diafile
-# command).
-
-DIAFILE_DIRS           =
-
-# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
-# path where java can find the plantuml.jar file. If left blank, it is assumed
-# PlantUML is not used or called during a preprocessing step. Doxygen will
-# generate a warning when it encounters a \startuml command in this case and
-# will not generate output for the diagram.
-
-PLANTUML_JAR_PATH      =
-
-# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
-# configuration file for plantuml.
-
-PLANTUML_CFG_FILE      =
-
-# When using plantuml, the specified paths are searched for files specified by
-# the !include statement in a plantuml block.
-
-PLANTUML_INCLUDE_PATH  =
-
-# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
-# that will be shown in the graph. If the number of nodes in a graph becomes
-# larger than this value, doxygen will truncate the graph, which is visualized
-# by representing a node as a red box. Note that doxygen if the number of direct
-# children of the root node in a graph is already larger than
-# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
-# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
-# Minimum value: 0, maximum value: 10000, default value: 50.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_GRAPH_MAX_NODES    = 50
-
-# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
-# generated by dot. A depth value of 3 means that only nodes reachable from the
-# root by following a path via at most 3 edges will be shown. Nodes that lay
-# further from the root node will be omitted. Note that setting this option to 1
-# or 2 may greatly reduce the computation time needed for large code bases. Also
-# note that the size of a graph can be further restricted by
-# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
-# Minimum value: 0, maximum value: 1000, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-MAX_DOT_GRAPH_DEPTH    = 0
-
-# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
-# background. This is disabled by default, because dot on Windows does not seem
-# to support this out of the box.
-#
-# Warning: Depending on the platform used, enabling this option may lead to
-# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
-# read).
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_TRANSPARENT        = NO
-
-# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
-# files in one run (i.e. multiple -o and -T options on the command line). This
-# makes dot run faster, but since only newer versions of dot (>1.8.10) support
-# this, this feature is disabled by default.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_MULTI_TARGETS      = NO
-
-# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
-# explaining the meaning of the various boxes and arrows in the dot generated
-# graphs.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GENERATE_LEGEND        = YES
-
-# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate
-# files that are used to generate the various graphs.
-#
-# Note: This setting is not only used for dot files but also for msc and
-# plantuml temporary files.
-# The default value is: YES.
-
-DOT_CLEANUP            = YES
diff --git a/subprojects/quill-4.2.0/docs/conf.py b/subprojects/quill-4.2.0/docs/conf.py
deleted file mode 100644
index ac46f91..0000000
--- a/subprojects/quill-4.2.0/docs/conf.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import subprocess, os
-
-
-def configureDoxyfile(input_dir, output_dir):
-    with open('Doxyfile.in', 'r') as file:
-        filedata = file.read()
-
-    filedata = filedata.replace('@DOXYGEN_INPUT_DIR@', input_dir)
-    filedata = filedata.replace('@DOXYGEN_OUTPUT_DIR@', output_dir)
-
-    with open('Doxyfile', 'w') as file:
-        file.write(filedata)
-
-
-# Check if we're running on Read the Docs' servers
-read_the_docs_build = os.environ.get('READTHEDOCS', None) == 'True'
-
-breathe_projects = {}
-
-if read_the_docs_build:
-    input_dir = '../quill'
-    output_dir = 'build'
-    configureDoxyfile(input_dir, output_dir)
-    subprocess.call('doxygen', shell=True)
-    breathe_projects['Quill'] = output_dir + '/xml'
-
-# Configuration file for the Sphinx documentation builder.
-#
-# For the full list of built-in configuration values, see the documentation:
-# https://www.sphinx-doc.org/en/master/usage/configuration.html
-
-# -- Project information -----------------------------------------------------
-# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
-
-project = 'Quill'
-copyright = '2024, Odysseas Georgoudis'
-author = 'Odysseas Georgoudis'
-release = 'v4.0.0'
-
-# -- General configuration ---------------------------------------------------
-# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
-
-extensions = ["breathe", "sphinx.ext.autosectionlabel"]
-breathe_default_project = "Quill"
-
-templates_path = ['_templates']
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
-
-# -- Options for HTML output -------------------------------------------------
-# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
-
-html_theme = 'sphinx_rtd_theme'
-html_static_path = ['_static']
diff --git a/subprojects/quill-4.2.0/docs/design.drawio b/subprojects/quill-4.2.0/docs/design.drawio
deleted file mode 100644
index b273970..0000000
--- a/subprojects/quill-4.2.0/docs/design.drawio
+++ /dev/null
@@ -1,139 +0,0 @@
-<mxfile host="app.diagrams.net" modified="2024-05-16T00:07:38.477Z" agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36 Edg/124.0.0.0" etag="VW8ihnyupRLc_PgVfbaT" version="22.1.21" type="device">
-  <diagram name="Page-1" id="kLzpoFuRwS6fnHKDuZMH">
-    <mxGraphModel dx="2066" dy="1145" grid="1" gridSize="12" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1000" pageHeight="1200" math="0" shadow="0">
-      <root>
-        <mxCell id="0" />
-        <mxCell id="1" parent="0" />
-        <mxCell id="BmINEKKr7EmUC2mtGokD-1" value="hot thread" style="ellipse;whiteSpace=wrap;html=1;" parent="1" vertex="1">
-          <mxGeometry x="258" y="66" width="100" height="70" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-2" value="hot thread" style="ellipse;whiteSpace=wrap;html=1;" parent="1" vertex="1">
-          <mxGeometry x="653" y="66" width="100" height="70" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-5" value="" style="shape=waypoint;sketch=0;fillStyle=solid;size=6;pointerEvents=1;points=[];fillColor=none;resizable=0;rotatable=0;perimeter=centerPerimeter;snapToPoint=1;" parent="1" vertex="1">
-          <mxGeometry x="498" y="91" width="20" height="20" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-6" value="" style="shape=waypoint;sketch=0;fillStyle=solid;size=6;pointerEvents=1;points=[];fillColor=none;resizable=0;rotatable=0;perimeter=centerPerimeter;snapToPoint=1;" parent="1" vertex="1">
-          <mxGeometry x="576.5" y="91" width="20" height="20" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-7" value="" style="shape=waypoint;sketch=0;fillStyle=solid;size=6;pointerEvents=1;points=[];fillColor=none;resizable=0;rotatable=0;perimeter=centerPerimeter;snapToPoint=1;" parent="1" vertex="1">
-          <mxGeometry x="418" y="91" width="20" height="20" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-10" value="thread local context&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;" style="verticalLabelPosition=middle;verticalAlign=middle;html=1;shape=mxgraph.basic.rect;fillColor2=none;strokeWidth=1;size=26.67;indent=5;labelPosition=center;align=center;" parent="1" vertex="1">
-          <mxGeometry x="108" y="246" width="280" height="190" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-14" value="SPSC queue&lt;br&gt;(bounded or unbounded)" style="verticalLabelPosition=bottom;verticalAlign=top;html=1;shape=mxgraph.basic.donut;dx=25;fillColor=#fff2cc;strokeColor=#000000;container=0;perimeterSpacing=1;labelPosition=center;align=center;whiteSpace=wrap;" parent="1" vertex="1">
-          <mxGeometry x="268" y="291" width="90" height="90" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-15" value="" style="endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;dashed=1;dashPattern=12 12;labelPosition=left;verticalLabelPosition=top;align=right;verticalAlign=bottom;entryX=0.46;entryY=0.026;entryDx=0;entryDy=0;entryPerimeter=0;" parent="1" source="BmINEKKr7EmUC2mtGokD-1" target="BmINEKKr7EmUC2mtGokD-14" edge="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="458" y="306" as="sourcePoint" />
-            <mxPoint x="478" y="266" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-16" value="TransitEvent buffer (unbounded)" style="verticalLabelPosition=bottom;verticalAlign=top;html=1;shape=mxgraph.basic.donut;dx=25;fillColor=#e1d5e7;strokeColor=#000000;container=0;shadow=0;perimeterSpacing=1;whiteSpace=wrap;" parent="1" vertex="1">
-          <mxGeometry x="128" y="291" width="90" height="90" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-19" value="1. A hot thread pushes a header and a copy of (args...) to a queue" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
-          <mxGeometry x="403" y="176" width="210" height="30" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-20" value="Backend logging thread&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;" style="ellipse;whiteSpace=wrap;html=1;shadow=0;sketch=0;strokeColor=#000000;" parent="1" vertex="1">
-          <mxGeometry x="268" y="694" width="520" height="440" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-24" value="thread local context&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;" style="verticalLabelPosition=middle;verticalAlign=middle;html=1;shape=mxgraph.basic.rect;fillColor2=none;strokeWidth=1;size=26.67;indent=5;labelPosition=center;align=center;" parent="1" vertex="1">
-          <mxGeometry x="628" y="246" width="280" height="190" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-25" value="SPSC queue&lt;br&gt;(bounded or unbounded)" style="verticalLabelPosition=bottom;verticalAlign=top;html=1;shape=mxgraph.basic.donut;dx=25;fillColor=#fff2cc;strokeColor=#000000;container=0;perimeterSpacing=1;labelPosition=center;align=center;whiteSpace=wrap;" parent="1" vertex="1">
-          <mxGeometry x="658" y="296" width="90" height="90" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-26" value="TransitEvent buffer (unbounded)" style="verticalLabelPosition=bottom;verticalAlign=top;html=1;shape=mxgraph.basic.donut;dx=25;fillColor=#e1d5e7;strokeColor=#000000;container=0;shadow=0;perimeterSpacing=1;whiteSpace=wrap;" parent="1" vertex="1">
-          <mxGeometry x="788" y="296" width="90" height="90" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-27" value="" style="endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;dashed=1;dashPattern=12 12;labelPosition=left;verticalLabelPosition=top;align=right;verticalAlign=bottom;entryX=0.511;entryY=0.001;entryDx=0;entryDy=0;entryPerimeter=0;" parent="1" source="BmINEKKr7EmUC2mtGokD-2" target="BmINEKKr7EmUC2mtGokD-25" edge="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="388" y="171" as="sourcePoint" />
-            <mxPoint x="340.0857142857144" y="300" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-29" value="" style="shape=waypoint;sketch=0;fillStyle=solid;size=6;pointerEvents=1;points=[];fillColor=none;resizable=0;rotatable=0;perimeter=centerPerimeter;snapToPoint=1;" parent="1" vertex="1">
-          <mxGeometry x="498" y="316" width="20" height="20" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-31" value="" style="shape=waypoint;sketch=0;fillStyle=solid;size=6;pointerEvents=1;points=[];fillColor=none;resizable=0;rotatable=0;perimeter=centerPerimeter;snapToPoint=1;" parent="1" vertex="1">
-          <mxGeometry x="576.5" y="316" width="20" height="20" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-32" value="" style="shape=waypoint;sketch=0;fillStyle=solid;size=6;pointerEvents=1;points=[];fillColor=none;resizable=0;rotatable=0;perimeter=centerPerimeter;snapToPoint=1;" parent="1" vertex="1">
-          <mxGeometry x="418" y="316" width="20" height="20" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-34" value="2. The backend thread pops all messages from all queues, decodes them and stores&amp;nbsp;&lt;br&gt;them in the TransitEvent buffer" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
-          <mxGeometry x="418" y="456" width="194" height="84" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-61" value="" style="rounded=0;whiteSpace=wrap;html=1;shadow=0;sketch=0;strokeColor=#000000;" parent="1" vertex="1">
-          <mxGeometry x="473" y="800" width="110" height="160" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-43" value="3.TransitEvents are processed after all SPSC queues are empty or when a max limit is reached. The TransitEvent with the min timestamp is passed to the all the registered Sinks." style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
-          <mxGeometry x="108" y="648" width="240" height="90" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-46" value="" style="rounded=1;whiteSpace=wrap;html=1;shadow=0;sketch=0;strokeColor=#000000;" parent="1" vertex="1">
-          <mxGeometry x="508" y="910" width="40" height="40" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-45" value="" style="rounded=1;whiteSpace=wrap;html=1;shadow=0;sketch=0;strokeColor=#000000;" parent="1" vertex="1">
-          <mxGeometry x="508" y="826" width="40" height="40" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-48" value="" style="shape=waypoint;sketch=0;fillStyle=solid;size=6;pointerEvents=1;points=[];fillColor=none;resizable=0;rotatable=0;perimeter=centerPerimeter;snapToPoint=1;" parent="1" vertex="1">
-          <mxGeometry x="518" y="870" width="20" height="20" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-49" value="" style="shape=waypoint;sketch=0;fillStyle=solid;size=6;pointerEvents=1;points=[];fillColor=none;resizable=0;rotatable=0;perimeter=centerPerimeter;snapToPoint=1;" parent="1" vertex="1">
-          <mxGeometry x="518" y="890" width="20" height="20" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-52" value="Sinks" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" parent="1" vertex="1">
-          <mxGeometry x="498" y="800" width="60" height="30" as="geometry" />
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-53" value="" style="endArrow=classic;html=1;rounded=0;dashed=1;dashPattern=12 12;strokeColor=default;exitX=0.822;exitY=0.87;exitDx=0;exitDy=0;exitPerimeter=0;entryX=0.419;entryY=0.008;entryDx=0;entryDy=0;entryPerimeter=0;" parent="1" source="BmINEKKr7EmUC2mtGokD-14" target="BmINEKKr7EmUC2mtGokD-20" edge="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="458" y="516" as="sourcePoint" />
-            <mxPoint x="538" y="666" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-54" value="" style="endArrow=classic;html=1;rounded=0;dashed=1;dashPattern=12 12;strokeColor=default;exitX=0.156;exitY=0.862;exitDx=0;exitDy=0;exitPerimeter=0;entryX=0.571;entryY=0;entryDx=0;entryDy=0;entryPerimeter=0;" parent="1" source="BmINEKKr7EmUC2mtGokD-25" target="BmINEKKr7EmUC2mtGokD-20" edge="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="321.98799999999983" y="392" as="sourcePoint" />
-            <mxPoint x="598" y="666" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-56" value="" style="endArrow=classic;html=1;rounded=0;dashed=1;dashPattern=12 12;strokeColor=default;entryX=0.909;entryY=0.826;entryDx=0;entryDy=0;entryPerimeter=0;exitX=0.356;exitY=0.006;exitDx=0;exitDy=0;exitPerimeter=0;" parent="1" source="BmINEKKr7EmUC2mtGokD-20" target="BmINEKKr7EmUC2mtGokD-16" edge="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="518" y="666" as="sourcePoint" />
-            <mxPoint x="508" y="466" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-57" value="" style="endArrow=classic;html=1;rounded=0;dashed=1;dashPattern=12 12;strokeColor=default;entryX=0.17;entryY=0.928;entryDx=0;entryDy=0;entryPerimeter=0;exitX=0.637;exitY=0.003;exitDx=0;exitDy=0;exitPerimeter=0;" parent="1" source="BmINEKKr7EmUC2mtGokD-20" target="BmINEKKr7EmUC2mtGokD-26" edge="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="568" y="656" as="sourcePoint" />
-            <mxPoint x="220.62800000000016" y="375.99199999999996" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-58" value="" style="endArrow=classic;html=1;rounded=0;dashed=1;dashPattern=12 12;strokeColor=default;exitX=0.442;exitY=1.051;exitDx=0;exitDy=0;exitPerimeter=0;entryX=0.25;entryY=0;entryDx=0;entryDy=0;" parent="1" source="BmINEKKr7EmUC2mtGokD-16" target="BmINEKKr7EmUC2mtGokD-61" edge="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="352.6239999999998" y="380.03999999999996" as="sourcePoint" />
-            <mxPoint x="488" y="826" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-59" value="" style="endArrow=classic;html=1;rounded=0;dashed=1;dashPattern=12 12;strokeColor=default;exitX=0.812;exitY=0.899;exitDx=0;exitDy=0;exitPerimeter=0;entryX=0.827;entryY=0.007;entryDx=0;entryDy=0;entryPerimeter=0;" parent="1" source="BmINEKKr7EmUC2mtGokD-26" target="BmINEKKr7EmUC2mtGokD-61" edge="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="177.66400000000021" y="396.692" as="sourcePoint" />
-            <mxPoint x="508" y="826" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-62" value="" style="endArrow=classic;html=1;rounded=0;dashed=1;dashPattern=12 12;strokeColor=default;exitX=0.5;exitY=1;exitDx=0;exitDy=0;" parent="1" source="BmINEKKr7EmUC2mtGokD-61" target="BmINEKKr7EmUC2mtGokD-65" edge="1">
-          <mxGeometry width="50" height="50" relative="1" as="geometry">
-            <mxPoint x="458" y="766" as="sourcePoint" />
-            <mxPoint x="502" y="1036" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
-        <mxCell id="BmINEKKr7EmUC2mtGokD-65" value="4. Sink output&amp;nbsp;" style="rounded=1;whiteSpace=wrap;html=1;shadow=0;sketch=0;strokeColor=#000000;" parent="1" vertex="1">
-          <mxGeometry x="432.5" y="1006" width="191" height="90" as="geometry" />
-        </mxCell>
-      </root>
-    </mxGraphModel>
-  </diagram>
-</mxfile>
diff --git a/subprojects/quill-4.2.0/docs/design.jpg b/subprojects/quill-4.2.0/docs/design.jpg
deleted file mode 100644
index 8945b07..0000000
Binary files a/subprojects/quill-4.2.0/docs/design.jpg and /dev/null differ
diff --git a/subprojects/quill-4.2.0/docs/features.rst b/subprojects/quill-4.2.0/docs/features.rst
deleted file mode 100644
index 2ac6164..0000000
--- a/subprojects/quill-4.2.0/docs/features.rst
+++ /dev/null
@@ -1,86 +0,0 @@
-.. _features:
-
-##############################################################################
-Features
-##############################################################################
-
-Thread Safety
-=============
-
-All components and API offered to the user is intended to be thread-safe without any special work needing to be done.
-
-:cpp:class:`quill::LoggerImpl` are thread safe by default. The same instance can be used to log by any thread.
-Any thread can safely modify the active log level of the logger.
-
-Logging types
-=====================================================
-
-For primitive types, std::string, and std::string_view, the library will perform a deep copy, and all formatting will occur asynchronously in the backend thread.
-However, for standard library types or user-defined types, they need to be converted to a string beforehand before being passed to the logger.
-
-Guaranteed logging
-=======================
-
-Quill employs a thread-local single-producer-single-consumer queue to relay logs to the backend thread,
-ensuring that log messages are never dropped.
-Initially, an unbounded queue with a small size is used for performance optimization.
-However, if the queue reaches full capacity, a new queue will be allocated, incurring a slight performance penalty for the frontend.
-
-The default unbounded queue can expand up to a size of 2GB. Should this limit be reached, the frontend thread will block.
-However, it's possible to alter the queue type within the FrontendOptions.
-
-Customising the queue size and type
---------------------------------------
-
-The queue size and type is configurable in runtime by creating a custom FrontendOptions class.
-
-Flush
-===============================
-
-You can explicitly instruct the frontend thread to wait until the log is flushed.
-
-.. note:: The thread that calls :cpp:func:`flush_log` will **block** until every message up to that point is flushed.
-
-.. doxygenfunction:: flush_log
-
-Application Crash Policy
-========================
-
-When the program is terminated gracefully, quill will go through its destructor where all messages are guaranteed to be logged.
-
-However, if the applications crashes, log messages can be lost.
-
-To avoid losing messages when the application crashes due to a signal interrupt the user must setup it’s own signal
-handler and call :cpp:func:`flush_log` inside the signal handler.
-
-There is a built-in signal handler that offers this crash-safe behaviour and can be enabled in :cpp:func:`start_with_signal_handler<quill::FrontendOptions>`
-
-Log Messages Timestamp Order
-==============================
-
-Quill creates a single worker backend thread which orders the messages in all queues by timestamp before printing them to the log file.
-
-Number of Backend Threads
-============================
-
-Quill focus is on low latency and not high throughput. Therefore, there is only one backend thread that will process all logs.
-
-Latency of the first log message
-====================================
-
-A queue and an internal buffer will be allocated on the first log message of each thread. If the latency of the first
-log message is important it is recommended to call :cpp:func:`quill::preallocate`
-
-.. doxygenfunction:: preallocate()
-
-Configuration
-======================
-
-Quill offers a few customization options, which are also well-documented.
-
-This customization can be applied to either the frontend or the backend.
-
-Frontend configuration occurs at compile time, thus requiring a custom FrontendOptions class to be provided
-:cpp:class:`quill::FrontendOptions`
-
-For customizing the backend, refer to :cpp:class:`quill::BackendOptions`
diff --git a/subprojects/quill-4.2.0/docs/index.rst b/subprojects/quill-4.2.0/docs/index.rst
deleted file mode 100644
index e308666..0000000
--- a/subprojects/quill-4.2.0/docs/index.rst
+++ /dev/null
@@ -1,26 +0,0 @@
-.. _index:
-
-##############################################################################
-Quill - Asynchronous Low Latency Logging Library for C++
-##############################################################################
-
-Quill is an open source, cross platform C++17 logging library designed for latency sensitive applications.
-
-`Github <http://github.com/odygrd/quill>`_
-
-.. toctree::
-   :hidden:
-   :maxdepth: 2
-   :caption: General Information
-
-   install
-   tutorial
-   features
-   usage
-
-.. toctree::
-   :hidden:
-   :maxdepth: 2
-   :caption: API
-
-   users-api
diff --git a/subprojects/quill-4.2.0/docs/install.rst b/subprojects/quill-4.2.0/docs/install.rst
deleted file mode 100644
index 3d8a44e..0000000
--- a/subprojects/quill-4.2.0/docs/install.rst
+++ /dev/null
@@ -1,82 +0,0 @@
-.. _install:
-
-##############################################################################
-Install
-##############################################################################
-
-Package Managers
-=================
-
-====================== ======================= ===================
-Homebrew               vcpkg                   Conan
-====================== ======================= ===================
-``brew install quill`` ``vcpkg install quill`` ``quill/[>=1.2.3]``
-====================== ======================= ===================
-
-CMake-Integration
-=================
-
-External
---------
-
-Building and Installing Quill as Static Library
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. code:: bash
-
-   git clone https://github.com/odygrd/quill.git
-   mkdir cmake_build
-   cd cmake_build
-   cmake ..
-   make install
-
-Note: To install in custom directory invoke cmake with ``-DCMAKE_INSTALL_PREFIX=/quill/install-dir/``
-
-Then use the library from a CMake project, you can locate it directly with ``find_package()``
-
-Directory Structure
-~~~~~~~~~~~~~~~~~~~
-
-::
-
-   my_project/
-   ├── CMakeLists.txt
-   ├── main.cpp
-
-CMakeLists.txt
-~~~~~~~~~~~~~~
-
-.. code:: cmake
-
-   # Set only if needed - quill was installed under a custom non-standard directory
-   set(CMAKE_PREFIX_PATH /test_quill/usr/local/)
-
-   find_package(quill REQUIRED)
-
-   # Linking your project against quill
-   add_executable(example main.cpp)
-   target_link_libraries(example PRIVATE quill::quill)
-
-Embedded
---------
-
-To embed the library directly, copy the source to your project and call ``add_subdirectory()`` in your ``CMakeLists.txt`` file
-
-Directory Structure
-~~~~~~~~~~~~~~~~~~~
-
-::
-
-   my_project/
-   ├── quill/            (source folder)
-   ├── CMakeLists.txt
-   ├── main.cpp
-
-CMakeLists.txt
-~~~~~~~~~~~~~~
-
-.. code:: cmake
-
-   add_subdirectory(quill)
-   add_executable(my_project main.cpp)
-   target_link_libraries(my_project PRIVATE quill::quill)
diff --git a/subprojects/quill-4.2.0/docs/make.bat b/subprojects/quill-4.2.0/docs/make.bat
deleted file mode 100644
index 954237b..0000000
--- a/subprojects/quill-4.2.0/docs/make.bat
+++ /dev/null
@@ -1,35 +0,0 @@
-@ECHO OFF
-
-pushd %~dp0
-
-REM Command file for Sphinx documentation
-
-if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=sphinx-build
-)
-set SOURCEDIR=.
-set BUILDDIR=_build
-
-%SPHINXBUILD% >NUL 2>NUL
-if errorlevel 9009 (
-	echo.
-	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
-	echo.installed, then set the SPHINXBUILD environment variable to point
-	echo.to the full path of the 'sphinx-build' executable. Alternatively you
-	echo.may add the Sphinx directory to PATH.
-	echo.
-	echo.If you don't have Sphinx installed, grab it from
-	echo.https://www.sphinx-doc.org/
-	exit /b 1
-)
-
-if "%1" == "" goto help
-
-%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-goto end
-
-:help
-%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-
-:end
-popd
diff --git a/subprojects/quill-4.2.0/docs/quill_v3_compiler_bench.speedscope.png b/subprojects/quill-4.2.0/docs/quill_v3_compiler_bench.speedscope.png
deleted file mode 100644
index 7470e21..0000000
Binary files a/subprojects/quill-4.2.0/docs/quill_v3_compiler_bench.speedscope.png and /dev/null differ
diff --git a/subprojects/quill-4.2.0/docs/quill_v3_compiler_profile.speedscope.png b/subprojects/quill-4.2.0/docs/quill_v3_compiler_profile.speedscope.png
deleted file mode 100644
index ebb567a..0000000
Binary files a/subprojects/quill-4.2.0/docs/quill_v3_compiler_profile.speedscope.png and /dev/null differ
diff --git a/subprojects/quill-4.2.0/docs/quill_v4_1_compiler_profile.speedscope.png b/subprojects/quill-4.2.0/docs/quill_v4_1_compiler_profile.speedscope.png
deleted file mode 100644
index 55ff525..0000000
Binary files a/subprojects/quill-4.2.0/docs/quill_v4_1_compiler_profile.speedscope.png and /dev/null differ
diff --git a/subprojects/quill-4.2.0/docs/quill_v4_compiler_bench.speedscope.png b/subprojects/quill-4.2.0/docs/quill_v4_compiler_bench.speedscope.png
deleted file mode 100644
index 3005bd3..0000000
Binary files a/subprojects/quill-4.2.0/docs/quill_v4_compiler_bench.speedscope.png and /dev/null differ
diff --git a/subprojects/quill-4.2.0/docs/quill_v4_compiler_profile.speedscope.png b/subprojects/quill-4.2.0/docs/quill_v4_compiler_profile.speedscope.png
deleted file mode 100644
index 3b0efc1..0000000
Binary files a/subprojects/quill-4.2.0/docs/quill_v4_compiler_profile.speedscope.png and /dev/null differ
diff --git a/subprojects/quill-4.2.0/docs/requirements.txt b/subprojects/quill-4.2.0/docs/requirements.txt
deleted file mode 100644
index e2d1c53..0000000
--- a/subprojects/quill-4.2.0/docs/requirements.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-breathe
-sphinx_rtd_theme
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/docs/tutorial.rst b/subprojects/quill-4.2.0/docs/tutorial.rst
deleted file mode 100644
index 0894ba3..0000000
--- a/subprojects/quill-4.2.0/docs/tutorial.rst
+++ /dev/null
@@ -1,525 +0,0 @@
-.. _tutorial:
-
-##############################################################################
-Tutorial
-##############################################################################
-
-Basic Example
-=============
-
-.. code:: cpp
-
-    #include "quill/Backend.h"
-    #include "quill/Frontend.h"
-    #include "quill/LogMacros.h"
-    #include "quill/Logger.h"
-    #include "quill/sinks/ConsoleSink.h"
-
-    int main()
-    {
-      // Start the backend thread
-      quill::Backend::start();
-
-      // Frontend
-      auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-      quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));
-
-      LOG_INFO(logger, "This is a log info example {}", 123);
-    }
-
-In the above example a logger to ``stdout`` is created with it's name set to “root”.
-
-Each :cpp:class:`quill::LoggerImpl` contains a :cpp:class:`quill::PatternFormatter` object which is responsible for the
-formatting of the message.
-
-Moreover, each :cpp:class:`quill::LoggerImpl` contains single or multiple :cpp:class:`quill::Sink` objects. The sink
-objects actually deliver the log message to their output source.
-
-A single backend thread is checking for new log messages periodically.
-
-Starting the backend thread is the responsibility of the user. The backend thread will automatically stop at the end
-of `main` printing every message, as long as the application is terminated gracefully.
-
-Use of macros is unavoidable in order to achieve better runtime performance. The static information of a log
-(such as format string, log level, location) is created in compile time. It is passed along with the type of each
-argument to a decoding function. A template instantiation per log statement is created.
-
-Logging Macros
-================
-
-The following macros are provided for logging:
-
-.. c:macro:: LOG_TRACE_L3(logger, log_message_format, args)
-.. c:macro:: LOG_TRACE_L2(logger, log_message_format, args)
-.. c:macro:: LOG_TRACE_L1(logger, log_message_format, args)
-.. c:macro:: LOG_DEBUG(logger, log_message_format, args)
-.. c:macro:: LOG_INFO(logger, log_message_format, args)
-.. c:macro:: LOG_WARNING(logger, log_message_format, args)
-.. c:macro:: LOG_ERROR(logger, log_message_format, args)
-.. c:macro:: LOG_CRITICAL(logger, log_message_format, args)
-.. c:macro:: LOG_BACKTRACE(logger, log_message_format, args)
-
-Sinks
-========
-
-Sinks are the objects responsible for writing logs to their respective targets.
-
-A :cpp:class:`quill::Sink` object serves as the base class for various sink-derived classes.
-
-Each sink handles outputting logs to a single target, such as a file, console, or database.
-
-Upon creation, a sink object is registered and owned by a central manager object, the quill::detail::SinkManager.
-
-For files, one sink is created per filename, and the file is opened once. If a sink is requested that refers to an already opened file, the existing Sink object is returned. Users can create multiple stdout or stderr handles by providing a unique ID per handle.
-
-When creating a logger, one or more sinks for that logger can be specified. Sinks can only be registered during the logger creation.
-
-Sharing sinks between loggers
-==================================
-
-It is possible to share the same sink object between multiple logger objects.
-For example when all logger objects are writing to the same file. The following code is also thread-safe.
-
-.. code:: cpp
-
-     auto file_sink = Frontend::create_or_get_sink<FileSink>(
-       filename,
-       []()
-       {
-         FileSinkConfig cfg;
-         cfg.set_open_mode('w');
-         return cfg;
-       }(),
-       FileEventNotifier{});
-
-     quill::Logger* logger_a = Frontend::create_or_get_logger("logger_a", file_sink);
-     quill::Logger* logger_b = Frontend::create_or_get_logger("logger_b", file_sink);
-
-Sink Types
-==================================
-
-ConsoleSink
---------------
-
-The ``ConsoleSink`` class sends logging output to streams ``stdout`` or ``stderr``.
-Printing colour codes to terminal or windows console is also supported.
-
-FileHandler
------------
-
-Logging to file
-~~~~~~~~~~~~~~~~~~~~~
-
-.. code:: cpp
-
-    int main()
-    {
-      // Start the backend thread
-      quill::Backend::start();
-
-      // Frontend
-      auto file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(
-        "trivial_logging.log",
-        []()
-        {
-          quill::FileSinkConfig cfg;
-          cfg.set_open_mode('w');
-          cfg.set_filename_append_option(quill::FilenameAppendOption::StartDateTime);
-          return cfg;
-        }(),
-        quill::FileEventNotifier{});
-
-      quill::Logger* logger =
-        quill::Frontend::create_or_get_logger("root", std::move(file_sink));
-
-      LOG_INFO(logger, "log something {}", 123);
-    }
-
-RotatingFileSink
--------------------
-
-Rotating log by size or time
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. code:: cpp
-
-      // Start the backend thread
-      quill::Backend::start();
-
-      // Frontend
-      auto rotating_file_sink = quill::Frontend::create_or_get_sink<quill::RotatingFileSink>(
-        "rotating_file.log",
-        []()
-        {
-          // See RotatingFileSinkConfig for more options
-          quill::RotatingFileSinkConfig cfg;
-          cfg.set_open_mode('w');
-          cfg.set_filename_append_option(quill::FilenameAppendOption::StartDateTime);
-          cfg.set_rotation_time_daily("18:30");
-          cfg.set_rotation_max_file_size(1024);
-          return cfg;
-        }());
-
-      quill::Logger* logger =
-        quill::Frontend::create_or_get_logger("root", std::move(rotating_file_sink));
-
-      for (int i = 0; i < 20; ++i)
-      {
-        LOG_INFO(logger, "Hello from rotating logger, index is {}", i);
-      }
-
-JsonFileSink
------------------------
-
-Json log
-~~~~~~~~~~~~~~~~~~~~~
-
-.. code:: cpp
-
-      // Start the backend thread
-      quill::Backend::start();
-
-      // Frontend
-
-      // Create a json file for output
-      auto json_sink = quill::Frontend::create_or_get_sink<quill::JsonFileSink>(
-        "json_sink_logging.log",
-        []()
-        {
-          quill::JsonFileSinkConfig cfg;
-          cfg.set_open_mode('w');
-          cfg.set_filename_append_option(quill::FilenameAppendOption::StartDateTime);
-          return cfg;
-        }(),
-        quill::FileEventNotifier{});
-
-      // When using the JsonFileSink, it is ideal to set the logging pattern to empty to avoid unnecessary message formatting.
-      quill::Logger* json_logger = quill::Frontend::create_or_get_logger(
-        "json_logger", std::move(json_sink), "", "%H:%M:%S.%Qns", quill::Timezone::GmtTime);
-
-      for (int i = 0; i < 2; ++i)
-      {
-        LOG_INFO(json_logger, "{method} to {endpoint} took {elapsed} ms", "POST", "http://", 10 * i);
-      }
-
-      // It is also possible to create a logger than logs to both the json file and stdout
-      // with the appropriate format
-      auto json_sink_2 = quill::Frontend::get_sink("json_sink_logging.log");
-      auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("console_sink_id_1");
-
-      // We set a custom format pattern here to also include the named_args
-      quill::Logger* hybrid_logger = quill::Frontend::create_or_get_logger(
-        "hybrid_logger", {std::move(json_sink_2), std::move(console_sink)},
-        "%(time) [%(thread_id)] %(short_source_location:<28) LOG_%(log_level:<9) %(logger:<20) "
-        "%(message) [%(named_args)]");
-
-      for (int i = 2; i < 4; ++i)
-      {
-        LOG_INFO(hybrid_logger, "{method} to {endpoint} took {elapsed} ms", "POST", "http://", 10 * i);
-      }
-
-Filters
-==================================
-
-A Filter class that can be used for filtering log records in the backend working thread.
-
-This is a simple way to ensure that a logger or sink will only output desired log messages.
-
-One or several :cpp:class:`quill::Filter` can be added to a :cpp:class:`quill::Sink` instance using the
-:cpp:func:`void add_filter(std::unique_ptr<Filter> filter)`
-
-The sink stores all added filters in a vector. The final log message is logged if all filters of the sink return `true`.
-
-Filtering per sink
------------------------
-
-The below example logs all WARNING and higher log level messages to console and all INFO and lower level messages to a file.
-
-.. code:: cpp
-
-        // Filter class for our file sink
-        class FileFilter : public quill::Filter
-        {
-        public:
-          FileFilter() : quill::Filter("FileFilter"){};
-
-          QUILL_NODISCARD bool filter(quill::MacroMetadata const* log_metadata, uint64_t log_timestamp, std::string_view thread_id,
-                                      std::string_view thread_name, std::string_view logger_name,
-                                      quill::LogLevel log_level, std::string_view log_message) noexcept override
-          {
-            if (log_metadata->log_level() < quill::LogLevel::Warning)
-            {
-              return true;
-            }
-            return false;
-          }
-        };
-
-        // Filter for the stdout sink
-        class StdoutFilter : public quill::Filter
-        {
-        public:
-          StdoutFilter() : quill::Filter("StdoutFilter"){};
-
-          QUILL_NODISCARD bool filter(quill::MacroMetadata const* log_metadata, uint64_t log_timestamp, std::string_view thread_id,
-                                      std::string_view thread_name, std::string_view logger_name,
-                                      quill::LogLevel log_level, std::string_view log_message) noexcept override
-          {
-            if (log_metadata->log_level() >= quill::LogLevel::Warning)
-            {
-              return true;
-            }
-            return false;
-          }
-        };
-
-        int main()
-        {
-          // Start the logging backend thread
-          quill::Backend::start();
-
-          // Get a sink to the file
-          // The first time this function is called a file sink is created for this filename.
-          // Calling the function with the same filename will return the existing sink
-          auto file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(
-            "example_filters.log",
-            []()
-            {
-              quill::FileSinkConfig cfg;
-              cfg.set_open_mode('w');
-              cfg.set_filename_append_option(quill::FilenameAppendOption::StartDateTime);
-              return cfg;
-            }(),
-            quill::FileEventNotifier{});
-
-          // Create and add the filter to our sink
-          file_sink->add_filter(std::make_unique<FileFilter>());
-
-          // Also create an stdout sink
-          auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-
-          // Create and add the filter to our sink
-          console_sink->add_filter(std::make_unique<StdoutFilter>());
-
-          // Create a logger using this sink
-          quill::Logger* logger = quill::Frontend::create_or_get_logger("logger", {std::move(file_sink), std::move(console_sink)});
-
-          LOG_INFO(logger, "test");
-          LOG_ERROR(logger, "test");
-        }
-
-Formatters
-==================================
-The :cpp:class:`quill::PatternFormatter` specifies the layout of log records in the final output.
-
-Each :cpp:class:`quill::LoggerImpl` object owns a PatternFormatter object.
-This means that each Logger can be customised to output in a different format.
-
-Customising the format output only be done during the creation of the logger.
-
-If no custom format is set each newly created Sink uses the same formatting as the default logger.
-
-The format output can be customised by providing a string of certain
-attributes.
-
-+-------------------------+--------------------------+----------------------------------------+
-| Name                    | Format                   | Description                            |
-+=========================+==========================+========================================+
-| time                    | %(time)                  | Human-readable time when the LogRecord |
-|                         |                          | was created. By default this is of the |
-|                         |                          | form '2003-07-08 16:49:45.896' (the    |
-|                         |                          | numbers after the period are the       |
-|                         |                          | millisecond portion of the time).      |
-+-------------------------+--------------------------+----------------------------------------+
-| file_name               | %(file_name)             | Filename portion of pathname.          |
-+-------------------------+--------------------------+----------------------------------------+
-| full_path               | %(full_path)             | Full path of the source file where the |
-|                         |                          | logging call was issued.               |
-+-------------------------+--------------------------+----------------------------------------+
-| caller_function         | %(caller_function)       | Name of function containing the        |
-|                         |                          | logging call.                          |
-+-------------------------+--------------------------+----------------------------------------+
-| log_level               | %(log_level)             | Text logging level for the message     |
-|                         |                          | (‘TRACEL3’, ‘TRACEL2’, ‘TRACEL1’,      |
-|                         |                          | ‘DEBUG’, ‘INFO’, ‘WARNING’, ‘ERROR’,   |
-|                         |                          | ‘CRITICAL’, ‘BACKTRACE’).              |
-+-------------------------+--------------------------+----------------------------------------+
-| log_level_id            | %(log_level_id)          | Abbreviated level name (‘T3’, ‘T2’,    |
-|                         |                          | ‘T1’, ‘D’, ‘I’, ‘W’, ‘E’, ‘C’, ‘BT’).  |
-+-------------------------+--------------------------+----------------------------------------+
-| line_number             | %(line_number)           | Source line number where the logging   |
-|                         |                          | call was issued (if available).        |
-+-------------------------+--------------------------+----------------------------------------+
-| logger                  | %(logger)                | Name of the logger used to log the     |
-|                         |                          | call.                                  |
-+-------------------------+--------------------------+----------------------------------------+
-| message                 | %(message)               | The logged message, computed as msg %  |
-|                         |                          | args. This is set when Formatter.      |
-|                         |                          | format() is invoked.                   |
-+-------------------------+--------------------------+----------------------------------------+
-| thread_id               | %(thread_id)             | Thread ID (if available).              |
-+-------------------------+--------------------------+----------------------------------------+
-| thread_name             | %(thread_name)           | Thread name if set. The name of the    |
-|                         |                          | thread must be set prior to issuing    |
-|                         |                          | any log statement on that thread.      |
-+-------------------------+--------------------------+----------------------------------------+
-| process_id              | %(process_id)            | Process ID                             |
-+-------------------------+--------------------------+----------------------------------------+
-| source_location         | %(source_location)       | Full source file path and line number  |
-|                         |                          | as a single string                     |
-+-------------------------+--------------------------+----------------------------------------+
-| short_source_location   | %(short_source_location) | Full source file path and line         |
-|                         |                          | number as a single string              |
-+-------------------------+--------------------------+----------------------------------------+
-| tags                    | %(tags)                  | Additional custom tags appended to the |
-|                         |                          | message when _WITH_TAGS macros are     |
-|                         |                          | used.                                  |
-+-------------------------+--------------------------+----------------------------------------+
-| named_args              | %(named_args)            | Key-value pairs appended to the        |
-|                         |                          | message. Only applicable with          |
-|                         |                          | for a named args log format;           |
-|                         |                          | remains empty otherwise.               |
-+-------------------------+--------------------------+----------------------------------------+
-
-
-Customising the timestamp
------------------------------
-
-The timestamp is customisable by :
-
-- Format. Same format specifiers as ``strftime(...)`` format without the additional ``.Qms`` ``.Qus`` ``.Qns`` arguments.
-- Local timezone or GMT timezone. Local timezone is used by default.
-- Fractional second precision. Using the additional fractional second specifiers in the timestamp format string.
-
-========= ============
-Specifier Description
-========= ============
-%Qms      Milliseconds
-%Qus      Microseconds
-%Qns      Nanoseconds
-========= ============
-
-By default ``"%H:%M:%S.%Qns"`` is used.
-
-.. note:: MinGW does not support all ``strftime(...)`` format specifiers and you might get a ``bad alloc`` if the format specifier is not supported
-
-Setting a custom format for logging to stdout
-----------------------------------------------------------
-
-.. code:: cpp
-
-  quill::Logger* logger =
-    quill::Frontend::create_or_get_logger("root", std::move(sink),
-                                          "%(time) [%(thread_id)] %(short_source_location:<28) "
-                                          "LOG_%(log_level:<9) %(logger:<12) %(message)",
-                                          "%H:%M:%S.%Qns", quill::Timezone::GmtTime);
-
-Logger
------------------------------
-
-Logger instances can be created by the user with the desired name, sinks and formatter.
-The logger object are never instantiated directly. Instead they first have to get created
-
-:cpp:func:`Frontend::create_or_get_logger(std::string const& logger_name, std::shared_ptr<Sink> sink, std::string const& format_pattern = "%(time) [%(thread_id)] %(short_source_location:<28) LOG_%(log_level:<9) %(logger:<12) %(message)", std::string const& time_pattern = "%H:%M:%S.%Qns", Timezone timestamp_timezone = Timezone::LocalTime, ClockSourceType clock_source = ClockSourceType::Tsc, UserClockSource* user_clock = nullptr)`
-
-:cpp:func:`Frontend::create_or_get_logger(std::string const& logger_name, std::initializer_list<std::shared_ptr<Sink>> sinks, std::string const& format_pattern = "%(time) [%(thread_id)] %(short_source_location:<28) LOG_%(log_level:<9) %(logger:<12) %(message)", std::string const& time_pattern = "%H:%M:%S.%Qns", Timezone timestamp_timezone = Timezone::LocalTime, ClockSourceType clock_source = ClockSourceType::Tsc, UserClockSource* user_clock = nullptr)`
-
-Logger access
------------------------------
-
-:cpp:func:`Frontend::get_logger(std::string const& name)`
-
-Logger creation
------------------------------
-
-.. code:: cpp
-
-     auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-
-     quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));
-
-     LOG_INFO(logger, "Hello from {}", "library foo");
-
-Avoiding the use of Logger objects
----------------------------------------
-For some applications the use of the single root logger might be enough. In that case passing the logger everytime
-to the macro becomes inconvenient. The solution is to store the created Logger as a static variable and create your
-own macros. See `example <https://github.com/odygrd/quill/blob/master/examples/recommended_usage/quill_wrapper/include/quill_wrapper/overwrite_macros.h>`_
-
-Backtrace Logging
-====================
-
-Backtrace logging enables log messages to be stored in a ring buffer and either
-
-- displayed later on demand or
-- when a high severity log message is logged
-
-Backtrace logging needs to be enabled first on the instance of :cpp:class:`quill::LoggerImpl`
-
-.. doxygenfunction:: init_backtrace
-.. doxygenfunction:: flush_backtrace
-
-.. note:: Backtrace log messages store the original timestamp of the message. Since they are kept and flushed later the
-timestamp in the log file will be out of order.
-
-.. note:: Backtrace log messages are still pushed to the SPSC queue from the frontend to the backend.
-
-Store messages in the ring buffer and display them when ``LOG_ERROR`` is logged
---------------------------------------------------------------------------------------------------------------------
-
-.. code:: cpp
-
-    // a LOG_ERROR(...) or higher severity log message occurs via this logger.
-    // Enable the backtrace with a max ring buffer size of 2 messages which will get flushed when
-    // Backtrace has to be enabled only once in the beginning before calling LOG_BACKTRACE(...) for the first time.
-    logger->init_backtrace(2, quill::LogLevel::Error);
-
-    LOG_INFO(logger, "BEFORE backtrace Example {}", 1);
-
-    LOG_BACKTRACE(logger, "Backtrace log {}", 1);
-    LOG_BACKTRACE(logger, "Backtrace log {}", 2);
-    LOG_BACKTRACE(logger, "Backtrace log {}", 3);
-    LOG_BACKTRACE(logger, "Backtrace log {}", 4);
-
-    // Backtrace is not flushed yet as we requested to flush on errors
-    LOG_INFO(logger, "AFTER backtrace Example {}", 1);
-
-    // log message with severity error - This will also flush_sink the backtrace which has 2 messages
-    LOG_ERROR(logger, "An error has happened, Backtrace is also flushed.");
-
-    // The backtrace is flushed again after LOG_ERROR but in this case it is empty
-    LOG_ERROR(logger, "An second error has happened, but backtrace is now empty.");
-
-    // Log more backtrace messages
-    LOG_BACKTRACE(logger, "Another Backtrace log {}", 1);
-    LOG_BACKTRACE(logger, "Another Backtrace log {}", 2);
-
-    // Nothing is logged at the moment
-    LOG_INFO(logger, "Another log info");
-
-    // Still nothing logged - the error message is on a different logger object
-    quill::LoggerImpl* logger_2 = quill::get_logger("example_1_1");
-
-    LOG_CRITICAL(logger_2, "A critical error from different logger.");
-
-    // The new backtrace is flushed again due to LOG_CRITICAL
-    LOG_CRITICAL(logger, "A critical error from the logger we had a backtrace.");
-
-Store messages in the ring buffer and display them on demand
---------------------------------------------------------------------------------------------------------------------
-
-.. code:: cpp
-       // Store maximum of two log messages. By default they will never be flushed since no LogLevel severity is specified
-       logger->init_backtrace(2);
-
-       LOG_INFO(logger, "BEFORE backtrace Example {}", 2);
-
-       LOG_BACKTRACE(logger, "Backtrace log {}", 100);
-       LOG_BACKTRACE(logger, "Backtrace log {}", 200);
-       LOG_BACKTRACE(logger, "Backtrace log {}", 300);
-
-       LOG_INFO(logger, "AFTER backtrace Example {}", 2);
-
-       // an error has happened - flush_log_messages the backtrace manually
-       logger->flush_backtrace();
-
diff --git a/subprojects/quill-4.2.0/docs/usage.rst b/subprojects/quill-4.2.0/docs/usage.rst
deleted file mode 100644
index f6087ac..0000000
--- a/subprojects/quill-4.2.0/docs/usage.rst
+++ /dev/null
@@ -1,91 +0,0 @@
-.. _usage:
-
-##############################################################################
-Usage
-##############################################################################
-
-Quickstart
-===========
-
-.. code:: cpp
-
-    #include "quill/Backend.h"
-    #include "quill/Frontend.h"
-    #include "quill/LogMacros.h"
-    #include "quill/Logger.h"
-    #include "quill/sinks/ConsoleSink.h"
-
-    #include <string>
-    #include <utility>
-
-    /**
-     * Trivial logging example to console
-     */
-
-    int main()
-    {
-      // Start the backend thread
-      quill::BackendOptions backend_options;
-      quill::Backend::start(backend_options);
-
-      // Frontend
-      auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-      quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));
-
-      // Change the LogLevel to print everything
-      logger->set_log_level(quill::LogLevel::TraceL3);
-
-      LOG_TRACE_L3(logger, "This is a log trace l3 example {}", 1);
-      LOG_TRACE_L2(logger, "This is a log trace l2 example {} {}", 2, 2.3);
-      LOG_TRACE_L1(logger, "This is a log trace l1 {} example", "string");
-      LOG_DEBUG(logger, "This is a log debug example {}", 4);
-      LOG_INFO(logger, "This is a log info example {}", sizeof(std::string));
-      LOG_WARNING(logger, "This is a log warning example {}", sizeof(std::string));
-      LOG_ERROR(logger, "This is a log error example {}", sizeof(std::string));
-      LOG_CRITICAL(logger, "This is a log critical example {}", sizeof(std::string));
-    }
-
-
-Log to file
-======================
-
-.. code:: cpp
-
-    #include "quill/Backend.h"
-    #include "quill/Frontend.h"
-    #include "quill/LogMacros.h"
-    #include "quill/Logger.h"
-    #include "quill/sinks/FileSink.h"
-
-    #include <utility>
-
-    int main()
-    {
-      // Start the backend thread
-      quill::BackendOptions backend_options;
-      quill::Backend::start(backend_options);
-
-      // Frontend
-      auto file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(
-        "trivial_logging.log",
-        []()
-        {
-          quill::FileSinkConfig cfg;
-          cfg.set_open_mode('w');
-          cfg.set_filename_append_option(quill::FilenameAppendOption::StartDateTime);
-          return cfg;
-        }(),
-        quill::FileEventNotifier{});
-
-      quill::Logger* logger =
-        quill::Frontend::create_or_get_logger("root", std::move(file_sink),
-                                              "%(time) [%(thread_id)] %(short_source_location:<28) "
-                                              "LOG_%(log_level:<9) %(logger:<12) %(message)",
-                                              "%H:%M:%S.%Qns", quill::Timezone::GmtTime);
-
-      // set the log level of the logger to debug (default is info)
-      logger->set_log_level(quill::LogLevel::Debug);
-
-      LOG_INFO(logger, "log something {}", 123);
-      LOG_DEBUG(logger, "something else {}", 456);
-    }
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/docs/users-api.rst b/subprojects/quill-4.2.0/docs/users-api.rst
deleted file mode 100644
index da4d2c8..0000000
--- a/subprojects/quill-4.2.0/docs/users-api.rst
+++ /dev/null
@@ -1,70 +0,0 @@
-.. _users-api:
-
-##############################################################################
-User's API
-##############################################################################
-
-Backend Options
-=====================
-
-.. doxygenstruct:: quill::BackendOptions
-   :members:
-
-Backend Class
-=====================
-
-.. doxygenclass:: quill::Backend
-   :members:
-
-Frontend Options
-=====================
-
-.. doxygenstruct:: quill::FrontendOptions
-   :members:
-
-Frontend Class
-=====================
-
-.. doxygenclass:: quill::FrontendImpl
-   :members:
-
-Log Levels
-=====================
-
-.. doxygenenum:: quill::LogLevel
-
-Logger Class
-=====================
-
-.. doxygenclass:: quill::LoggerImpl
-   :members:
-
-PatternFormatter Class
-=========================
-
-.. doxygenclass:: quill::PatternFormatter
-   :members:
-
-Sink Class
-=====================
-
-.. doxygenclass:: quill::Sink
-   :members:
-
-Filter Class
-=====================
-
-.. doxygenclass:: quill::Filter
-   :members:
-
-FileSinkConfig Class
-=====================
-
-.. doxygenclass:: quill::FileSinkConfig
-   :members:
-
-RotatingFileSinkConfig Class
-==============================
-
-.. doxygenclass:: quill::RotatingFileSinkConfig
-   :members:
diff --git a/subprojects/quill-4.2.0/examples/CMakeLists.txt b/subprojects/quill-4.2.0/examples/CMakeLists.txt
deleted file mode 100644
index 1ccf640..0000000
--- a/subprojects/quill-4.2.0/examples/CMakeLists.txt
+++ /dev/null
@@ -1,74 +0,0 @@
-add_subdirectory(recommended_usage)
-add_subdirectory(advanced)
-
-add_executable(quill_example_backend_thread_notify backend_thread_notify.cpp)
-set_common_compile_options(quill_example_backend_thread_notify)
-target_link_libraries(quill_example_backend_thread_notify quill)
-
-add_executable(quill_example_backtrace_logging backtrace_logging.cpp)
-set_common_compile_options(quill_example_backtrace_logging)
-target_link_libraries(quill_example_backtrace_logging quill)
-
-add_executable(quill_example_bounded_dropping_queue_frontend bounded_dropping_queue_frontend.cpp)
-set_common_compile_options(quill_example_bounded_dropping_queue_frontend)
-target_link_libraries(quill_example_bounded_dropping_queue_frontend quill)
-
-add_executable(quill_example_console_logging console_logging.cpp)
-set_common_compile_options(quill_example_console_logging)
-target_link_libraries(quill_example_console_logging quill)
-
-add_executable(quill_example_custom_console_colours custom_console_colours.cpp)
-set_common_compile_options(quill_example_custom_console_colours)
-target_link_libraries(quill_example_custom_console_colours quill)
-
-add_executable(quill_example_rotating_file_logging rotating_file_logging.cpp)
-set_common_compile_options(quill_example_rotating_file_logging)
-target_link_libraries(quill_example_rotating_file_logging quill)
-
-add_executable(quill_example_signal_handler signal_handler.cpp)
-set_common_compile_options(quill_example_signal_handler)
-target_link_libraries(quill_example_signal_handler quill)
-
-add_executable(quill_example_logger_removal_with_file_event_notifier logger_removal_with_file_event_notifier.cpp)
-set_common_compile_options(quill_example_logger_removal_with_file_event_notifier)
-target_link_libraries(quill_example_logger_removal_with_file_event_notifier quill)
-
-add_executable(quill_example_custom_frontend_options custom_frontend_options.cpp)
-set_common_compile_options(quill_example_custom_frontend_options)
-target_link_libraries(quill_example_custom_frontend_options quill)
-
-add_executable(quill_example_file_logging file_logging.cpp)
-set_common_compile_options(quill_example_file_logging)
-target_link_libraries(quill_example_file_logging quill)
-
-add_executable(quill_example_filter_logging filter_logging.cpp)
-set_common_compile_options(quill_example_filter_logging)
-target_link_libraries(quill_example_filter_logging quill)
-
-add_executable(quill_example_system_clock_logging system_clock_logging.cpp)
-set_common_compile_options(quill_example_system_clock_logging)
-target_link_libraries(quill_example_system_clock_logging quill)
-
-add_executable(quill_example_user_clock_source user_clock_source.cpp)
-set_common_compile_options(quill_example_user_clock_source)
-target_link_libraries(quill_example_user_clock_source quill)
-
-add_executable(quill_example_user_defined_filter user_defined_filter.cpp)
-set_common_compile_options(quill_example_user_defined_filter)
-target_link_libraries(quill_example_user_defined_filter quill)
-
-add_executable(quill_example_user_defined_sink user_defined_sink.cpp)
-set_common_compile_options(quill_example_user_defined_sink)
-target_link_libraries(quill_example_user_defined_sink quill)
-
-add_executable(quill_example_tags_logging tags_logging.cpp)
-set_common_compile_options(quill_example_tags_logging)
-target_link_libraries(quill_example_tags_logging quill)
-
-add_executable(quill_example_json_sink_logging json_sink_logging.cpp)
-set_common_compile_options(quill_example_json_sink_logging)
-target_link_libraries(quill_example_json_sink_logging quill)
-
-add_executable(quill_example_user_defined_types_logging user_defined_types_logging.cpp)
-set_common_compile_options(quill_example_user_defined_types_logging)
-target_link_libraries(quill_example_user_defined_types_logging quill)
diff --git a/subprojects/quill-4.2.0/examples/advanced/CMakeLists.txt b/subprojects/quill-4.2.0/examples/advanced/CMakeLists.txt
deleted file mode 100644
index b20d1e2..0000000
--- a/subprojects/quill-4.2.0/examples/advanced/CMakeLists.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-add_subdirectory(quill_wrapper)
-
-add_executable(quill_example_advanced advanced.cpp)
-set_common_compile_options(quill_example_advanced)
-target_link_libraries(quill_example_advanced quill_wrapper_advanced)
diff --git a/subprojects/quill-4.2.0/examples/advanced/advanced.cpp b/subprojects/quill-4.2.0/examples/advanced/advanced.cpp
deleted file mode 100644
index 5c22589..0000000
--- a/subprojects/quill-4.2.0/examples/advanced/advanced.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- * This example showcases passing user-defined types as arguments to the logger, with their
- * formatting deferred asynchronously to the backend. It's particularly useful in scenarios where
- * string formatting latency is unacceptable and the code operates on the critical path.
- *
- * For a more straightforward approach, it's generally recommended to pass these types as strings,
- * formatting them in the frontend, as demonstrated in the 'user_defined_types_logging.cpp' example.
- */
-
-// Include our wrapper lib for setup_quill
-#include "quill_wrapper/quill_wrapper.h"
-
-// Header required for quill::Frontend::get_logger
-#include "quill/Frontend.h"
-
-// We need only these two headers in order to log
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-
-// user defined type header
-#include "user.h"
-
-// user defined type codec header
-#include "user_quill_codec.h"
-
-// Required only when passing to logger std::vector<User> for offloading the formatting to the backend
-#include "quill/std/Vector.h"
-
-int main()
-{
-  setup_quill("recommended_usage.log");
-  quill::Logger* logger = quill::Frontend::get_logger("root");
-
-  User user;
-  user.name = "Quill";
-  user.surname = "Library";
-  user.age = 4;
-  user.favorite_colors[0] = "red";
-  user.favorite_colors[1] = "green";
-  user.favorite_colors[2] = "blue";
-
-  LOG_INFO(logger, "The user is {}", user);
-
-  std::vector<User> const users = {{"Alice", "Doe", 25, {"red", "green"}},
-                                   {"Bob", "Smith", 30, {"blue", "yellow"}},
-                                   {"Charlie", "Johnson", 35, {"green", "orange"}},
-                                   {"David", "Brown", 40, {"red", "blue", "yellow"}}};
-
-  LOG_INFO(logger, "The users are {}", users);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/advanced/quill_wrapper/CMakeLists.txt b/subprojects/quill-4.2.0/examples/advanced/quill_wrapper/CMakeLists.txt
deleted file mode 100644
index 34e90b8..0000000
--- a/subprojects/quill-4.2.0/examples/advanced/quill_wrapper/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-set(LIB_NAME quill_wrapper_advanced)
-
-add_library(${LIB_NAME} STATIC
-        include/quill_wrapper/quill_wrapper.h
-        include/quill_wrapper/quill_wrapper.cpp)
-
-# Add include directories for this library
-target_include_directories(${LIB_NAME}
-        PUBLIC
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-        $<INSTALL_INTERFACE:include>
-        PRIVATE
-        ${CMAKE_CURRENT_SOURCE_DIR})
-
-# Link quill dependency
-target_link_libraries(${LIB_NAME} PUBLIC quill::quill)
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/advanced/quill_wrapper/include/quill_wrapper/quill_wrapper.cpp b/subprojects/quill-4.2.0/examples/advanced/quill_wrapper/include/quill_wrapper/quill_wrapper.cpp
deleted file mode 100644
index ebe3016..0000000
--- a/subprojects/quill-4.2.0/examples/advanced/quill_wrapper/include/quill_wrapper/quill_wrapper.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "quill_wrapper.h"
-
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/Logger.h"
-#include "quill/sinks/ConsoleSink.h"
-
-void setup_quill(char const* log_file)
-{
-  // Start the backend thread
-  quill::Backend::start();
-
-  // Setup sink and logger
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("console_sink");
-
-  // Create and store the logger
-  quill::Frontend::create_or_get_logger("root", std::move(console_sink),
-                                        "%(time) [%(thread_id)] %(short_source_location:<28) "
-                                        "LOG_%(log_level:<9) %(logger:<12) %(message)",
-                                        "%H:%M:%S.%Qns", quill::Timezone::GmtTime);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/advanced/quill_wrapper/include/quill_wrapper/quill_wrapper.h b/subprojects/quill-4.2.0/examples/advanced/quill_wrapper/include/quill_wrapper/quill_wrapper.h
deleted file mode 100644
index c71a95e..0000000
--- a/subprojects/quill-4.2.0/examples/advanced/quill_wrapper/include/quill_wrapper/quill_wrapper.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#pragma once
-
-void setup_quill(char const* log_file);
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/advanced/user.h b/subprojects/quill-4.2.0/examples/advanced/user.h
deleted file mode 100644
index eaadd9f..0000000
--- a/subprojects/quill-4.2.0/examples/advanced/user.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-#include <array>
-#include <cstdint>
-#include <string>
-
-/**
- * User defined type
- */
-struct User
-{
-  std::string name;
-  std::string surname;
-  uint32_t age;
-  std::array<std::string, 3> favorite_colors;
-};
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/advanced/user_quill_codec.h b/subprojects/quill-4.2.0/examples/advanced/user_quill_codec.h
deleted file mode 100644
index 2be4329..0000000
--- a/subprojects/quill-4.2.0/examples/advanced/user_quill_codec.h
+++ /dev/null
@@ -1,85 +0,0 @@
-#pragma once
-
-// Always required
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-
-// To serialise the std::array member of User you need Array.h otherwise you don't need to include this
-#include "quill/std/Array.h"
-
-#include "user.h"
-
-#include <utility> // for declval only required if you do the decoding manualy and use declval
-
-/***/
-template <>
-struct fmtquill::formatter<User>
-{
-  template <typename FormatContext>
-  constexpr auto parse(FormatContext& ctx)
-  {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(::User const& user, FormatContext& ctx) const
-  {
-    return fmtquill::format_to(ctx.out(), "Name: {}, Surname: {}, Age: {}, Favorite Colors: {}",
-                               user.name, user.surname, user.age, user.favorite_colors);
-  }
-};
-
-/***/
-template <>
-struct quill::detail::ArgSizeCalculator<User>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache, ::User const& user) noexcept
-  {
-    // pass as arguments the class members you want to serialize
-    return calculate_total_size(conditional_arg_size_cache, user.name, user.surname, user.age, user.favorite_colors);
-  }
-};
-
-/***/
-template <>
-struct quill::detail::Encoder<User>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index, ::User const& user) noexcept
-  {
-    // You must encode the same members and in the same order as in the ArgSizeCalculator::calculate
-    encode_members(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, user.name,
-                   user.surname, user.age, user.favorite_colors);
-  }
-};
-
-/***/
-template <>
-struct quill::detail::Decoder<User>
-{
-  static ::User decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    // You must decode the same members and in the same order as in the Encoder::encode
-    ::User user;
-    decode_and_assign_members(buffer, args_store, user, user.name, user.surname, user.age, user.favorite_colors);
-    return user;
-
-    // note:
-    // If the object is not default constructible you have to do it manually without
-    // decode_members helper
-
-    // auto name = Decoder<decltype(std::declval<::User>().name)>::decode(buffer, nullptr);
-    // auto surname = Decoder<decltype(std::declval<::User>().surname)>::decode(buffer, nullptr);
-    // auto age = Decoder<decltype(std::declval<::User>().age)>::decode(buffer, nullptr);
-    // auto favorite_colors = Decoder<decltype(std::declval<::User>().favorite_colors)>::decode(buffer, nullptr);
-
-    // ::User user{name, surname, age, favorite_colors};
-
-    // if (args_store)
-    // {
-    //  args_store->push_back(user);
-    // }
-
-    // return user;
-  }
-};
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/backend_thread_notify.cpp b/subprojects/quill-4.2.0/examples/backend_thread_notify.cpp
deleted file mode 100644
index 1aba32c..0000000
--- a/subprojects/quill-4.2.0/examples/backend_thread_notify.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <chrono>
-#include <iostream>
-#include <thread>
-#include <utility>
-
-/**
- * This example demonstrates how to manually wake up the backend thread when configuring
- * it with a longer sleep duration.
- *
- * Note: It's generally advised not to set the sleep duration higher than 1 second.
- * However, it's still possible to do so.
- * The only practical use case for this is when you want to prevent the backend thread
- * from waking up periodically to conserve CPU cycles.
- */
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  backend_options.sleep_duration = std::chrono::hours{24};
-  quill::Backend::start(backend_options);
-
-  // To demonstrate the example we have to wait for the backend thread to start and then
-  // go into sleep as there will be nothing to log, so we wait here a bit
-  std::this_thread::sleep_for(std::chrono::seconds{1});
-
-  // Frontend
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-  quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));
-
-  LOG_INFO(logger, "This is a log info example {}", 5);
-  LOG_WARNING(logger, "This is a log warning example {}", 6);
-  LOG_ERROR(logger, "This is a log error example {}", 7);
-
-  // sleep for 5 seconds, the backend thread will also be sleeping so no logs are displayed
-  std::cout << "waiting for the backend thread..." << std::endl;
-  std::this_thread::sleep_for(std::chrono::seconds{5});
-  std::cout << "notifying for the backend thread..." << std::endl;
-  quill::Backend::notify();
-  std::this_thread::sleep_for(std::chrono::seconds{1}); // let backend sleep again
-
-  LOG_INFO(logger, "This is a log info example {}", 15);
-  LOG_WARNING(logger, "This is a log warning example {}", 16);
-  LOG_ERROR(logger, "This is a log error example {}", 17);
-
-  std::cout << "waiting for the backend thread..." << std::endl;
-  std::this_thread::sleep_for(std::chrono::seconds{5});
-  std::cout << "notifying for the backend thread..." << std::endl;
-  quill::Backend::notify();
-  std::this_thread::sleep_for(std::chrono::seconds{1}); // let backend sleep again
-
-  LOG_INFO(logger, "Done, backend thread will always wake up and log on destruction");
-}
diff --git a/subprojects/quill-4.2.0/examples/backtrace_logging.cpp b/subprojects/quill-4.2.0/examples/backtrace_logging.cpp
deleted file mode 100644
index 02abf89..0000000
--- a/subprojects/quill-4.2.0/examples/backtrace_logging.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <utility>
-
-/**
- * This example showcases the usage of LOG_BACKTRACE macros. Log messages generated using these
- * macros are enqueued from the frontend to the backend. However, the backend will only log them if
- * a specific condition is met or if they are manually flushed using flush_backtrace().
- */
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  // Frontend
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-  quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));
-  logger->set_log_level(quill::LogLevel::Debug);
-
-  // Enable the backtrace with a ring buffer capacity of 2 messages to get flushed when
-  // a LOG_ERROR(...) or higher severity log message occurs via this logger.
-  // Backtrace has to be enabled only once in the beginning before calling LOG_BACKTRACE(...) for the first time.
-  logger->init_backtrace(2u, quill::LogLevel::Error);
-
-  LOG_INFO(logger, "Begin example {}", 1);
-
-  LOG_BACKTRACE(logger, "Backtrace log {}", 1);
-  LOG_BACKTRACE(logger, "Backtrace log {}", 2);
-  LOG_BACKTRACE(logger, "Backtrace log {}", 3);
-  LOG_BACKTRACE(logger, "Backtrace log {}", 4);
-
-  LOG_INFO(logger, "Backtrace is not flushed yet as we requested to flush on errors {}", 1);
-
-  // log message with severity error - This will also flush the backtrace which has 2 messages
-  LOG_ERROR(logger, "An error has happened, Backtrace is also flushed.");
-
-  // The backtrace is flushed again after LOG_ERROR but in this case it is empty
-  LOG_ERROR(logger,
-            "Another second error has happened, backtrace is flushed again but it is now empty.");
-
-  // Log more backtrace messages
-  LOG_BACKTRACE(logger, "Another Backtrace log {}", 1);
-  LOG_BACKTRACE(logger, "Another Backtrace log {}", 2);
-
-  LOG_DEBUG(logger, "No backtrace logs yet");
-  LOG_INFO(logger, "Manually flush backtrace");
-
-  logger->flush_backtrace();
-}
diff --git a/subprojects/quill-4.2.0/examples/bounded_dropping_queue_frontend.cpp b/subprojects/quill-4.2.0/examples/bounded_dropping_queue_frontend.cpp
deleted file mode 100644
index 37ae366..0000000
--- a/subprojects/quill-4.2.0/examples/bounded_dropping_queue_frontend.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <cstdint>
-#include <utility>
-
-/**
- * This example demonstrates how to change the type of the Single Producer Single Consumer (SPSC)
- * queue used by the frontend.
- *
- * By default, the library uses an UnboundedBlocking queue, which starts small with
- * initial_queue_capacity and reallocates up to 2GB as needed.
- */
-
-/**
- * Create a custom frontend config
- */
-struct CustomFrontendOptions
-{
-  // Set the queue to BoundedDropping
-  static constexpr quill::QueueType queue_type = quill::QueueType::BoundedDropping;
-
-  // Set small capacity to demonstrate dropping messages in this example
-  static constexpr uint32_t initial_queue_capacity = 256;
-
-  static constexpr uint32_t blocking_queue_retry_interval_ns = 800;
-  static constexpr bool huge_pages_enabled = false;
-};
-
-/**
- * A new Frontend and Logger should be defined to use the custom frontend options.
- */
-using CustomFrontend = quill::FrontendImpl<CustomFrontendOptions>;
-using CustommLogger = quill::LoggerImpl<CustomFrontendOptions>;
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  // Frontend
-  auto console_sink = CustomFrontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-  CustommLogger* logger = CustomFrontend::create_or_get_logger("root", std::move(console_sink));
-
-  for (int i = 0; i < 32; ++i)
-  {
-    LOG_INFO(logger, "Bounded queue example log message num {}", i);
-  }
-}
diff --git a/subprojects/quill-4.2.0/examples/console_logging.cpp b/subprojects/quill-4.2.0/examples/console_logging.cpp
deleted file mode 100644
index 3c98461..0000000
--- a/subprojects/quill-4.2.0/examples/console_logging.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <string>
-#include <utility>
-
-/**
- * Trivial logging example to console
- */
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  // Frontend
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-  quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));
-
-  // Change the LogLevel to print everything
-  logger->set_log_level(quill::LogLevel::TraceL3);
-
-  LOG_TRACE_L3(logger, "This is a log trace l3 example {}", 1);
-  LOG_TRACE_L2(logger, "This is a log trace l2 example {} {}", 2, 2.3);
-  LOG_TRACE_L1(logger, "This is a log trace l1 {} example", "string");
-  LOG_DEBUG(logger, "This is a log debug example {}", 4);
-  LOG_INFO(logger, "This is a log info example {}", sizeof(std::string));
-  LOG_WARNING(logger, "This is a log warning example {}", sizeof(std::string));
-  LOG_ERROR(logger, "This is a log error example {}", sizeof(std::string));
-  LOG_CRITICAL(logger, "This is a log critical example {}", sizeof(std::string));
-
-  // libfmt format specification mini language is supported
-  // note: named arguments are not supported
-  LOG_INFO(logger, "Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
-  LOG_INFO(logger, "Easy padding in numbers like {:08d}", 12);
-  LOG_INFO(logger, "{:>30}", "right aligned");
-  LOG_INFO(logger, "Positional arguments {1} {2} {0} ", "too", "are", "supported");
-  LOG_INFO(logger, "Support for precision {:.4f}", 1.23456);
-
-  // To log with a different format to the same sink, just create another logger
-  auto console_sink_2 = quill::Frontend::get_sink("sink_id_1"); // get the created sink
-  quill::Logger* logger_2 = quill::Frontend::create_or_get_logger(
-    "logger_2", std::move(console_sink_2), "%(time) %(log_level:<9) %(logger:<12) %(message)");
-
-  logger_2->set_log_level(quill::LogLevel::TraceL3);
-
-  LOG_TRACE_L3(logger_2, "This is a log trace l3 example {}", 1);
-  LOG_TRACE_L2(logger_2, "This is a log trace l2 example {} {}", 2, 2.3);
-  LOG_TRACE_L1(logger_2, "This is a log trace l1 {} example", "string");
-  LOG_DEBUG(logger_2, "This is a log debug example {}", 4);
-  LOG_INFO(logger_2, "This is a log info example {}", sizeof(std::string));
-  LOG_WARNING(logger_2, "This is a log warning example {}", sizeof(std::string));
-  LOG_ERROR(logger_2, "This is a log error example {}", sizeof(std::string));
-  LOG_CRITICAL(logger_2, "This is a log critical example {}", sizeof(std::string));
-}
diff --git a/subprojects/quill-4.2.0/examples/custom_console_colours.cpp b/subprojects/quill-4.2.0/examples/custom_console_colours.cpp
deleted file mode 100644
index 5de6286..0000000
--- a/subprojects/quill-4.2.0/examples/custom_console_colours.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <string>
-#include <utility>
-
-/**
- * The example demonstrates how to customise the console colours
- */
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  // Frontend
-  quill::ConsoleColours custom_console_colours;
-  custom_console_colours.set_default_colours();
-  custom_console_colours.set_colour(quill::LogLevel::Info, quill::ConsoleColours::blue); // overwrite the colour for INFO
-
-  // Create the sink
-  auto console_sink =
-    quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1", custom_console_colours);
-
-  quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));
-
-  // Change the LogLevel to print everything
-  logger->set_log_level(quill::LogLevel::TraceL3);
-
-  LOG_TRACE_L3(logger, "This is a log trace l3 example {}", 1);
-  LOG_TRACE_L2(logger, "This is a log trace l2 example {} {}", 2, 2.3);
-  LOG_TRACE_L1(logger, "This is a log trace l1 {} example", "string");
-  LOG_DEBUG(logger, "This is a log debug example {}", 4);
-  LOG_INFO(logger, "This is a log info example {}", sizeof(std::string));
-  LOG_WARNING(logger, "This is a log warning example {}", sizeof(std::string));
-  LOG_ERROR(logger, "This is a log error example {}", sizeof(std::string));
-  LOG_CRITICAL(logger, "This is a log critical example {}", sizeof(std::string));
-}
diff --git a/subprojects/quill-4.2.0/examples/custom_frontend_options.cpp b/subprojects/quill-4.2.0/examples/custom_frontend_options.cpp
deleted file mode 100644
index 88ea1c5..0000000
--- a/subprojects/quill-4.2.0/examples/custom_frontend_options.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-/**
- * This example demonstrates defining and utilizing custom FrontendOptions.
- * It's useful when you need to modify the queue type or capacity.
- * FrontendOptions are compile-time options and must be passed as a template argument.
- */
-
-// Backend - required to start the backend thread
-#include "quill/Backend.h"
-
-#include "quill/Frontend.h"
-#include "quill/sinks/ConsoleSink.h"
-
-// Include only Logger, LogMacros as they are the minimal required files for logging functionality
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-
-#include <utility>
-
-// define your own FrontendOptions, see "core/FrontendOptions.h" for details
-struct CustomFrontendOptions
-{
-  static constexpr quill::QueueType queue_type = quill::QueueType::BoundedDropping;
-  static constexpr uint32_t initial_queue_capacity = 131'072;
-  static constexpr uint32_t blocking_queue_retry_interval_ns = 800;
-  static constexpr bool huge_pages_enabled = false;
-};
-
-// To utilize our custom FrontendOptions, we define a Frontend class using CustomFrontendOptions
-using CustomFrontend = quill::FrontendImpl<CustomFrontendOptions>;
-
-// The Logger type must also be defined
-using CustomLogger = quill::LoggerImpl<CustomFrontendOptions>;
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options); // or quill::Backend::start_with_signal_handler<CustomFrontendOptions>();
-
-  // All frontend operations must utilize CustomFrontend instead of quill::Frontend
-  auto console_sink = CustomFrontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-  CustomLogger* logger = CustomFrontend::create_or_get_logger("root", std::move(console_sink));
-
-  // log something
-  LOG_INFO(logger, "This is a log info example {}", 123);
-  LOG_WARNING(logger, "This is a log warning example {}", 123);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/file_logging.cpp b/subprojects/quill-4.2.0/examples/file_logging.cpp
deleted file mode 100644
index a4763ec..0000000
--- a/subprojects/quill-4.2.0/examples/file_logging.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/FileSink.h"
-
-#include <utility>
-
-/**
- * Logging to the same file using multiple loggers
- */
-
-void log_from_new_logger()
-{
-  // Obtain the existing created sink, and create a new logger to log
-  auto file_sink = quill::Frontend::get_sink("example_file_logging.log");
-  quill::Logger* logger_2 = quill::Frontend::create_or_get_logger("root", std::move(file_sink));
-
-  LOG_INFO(logger_2, "log from new logger {}", 123);
-}
-
-void log_from_existing_logger()
-{
-  // Obtain existing logger to log
-  quill::Logger* logger = quill::Frontend::get_logger("root");
-  LOG_INFO(logger, "log again {}", 123312);
-}
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  // Frontend
-  auto file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(
-    "example_file_logging.log",
-    []()
-    {
-      quill::FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      cfg.set_filename_append_option(quill::FilenameAppendOption::StartDateTime);
-      return cfg;
-    }(),
-    quill::FileEventNotifier{});
-
-  quill::Logger* logger =
-    quill::Frontend::create_or_get_logger("root", std::move(file_sink),
-                                          "%(time) [%(thread_id)] %(short_source_location:<28) "
-                                          "LOG_%(log_level:<9) %(logger:<12) %(message)",
-                                          "%H:%M:%S.%Qns", quill::Timezone::GmtTime);
-
-  // set the log level of the logger to debug (default is info)
-  logger->set_log_level(quill::LogLevel::Debug);
-
-  LOG_INFO(logger, "log something {}", 123);
-  LOG_DEBUG(logger, "something else {}", 456);
-
-  log_from_new_logger();
-  log_from_existing_logger();
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/filter_logging.cpp b/subprojects/quill-4.2.0/examples/filter_logging.cpp
deleted file mode 100644
index 321958a..0000000
--- a/subprojects/quill-4.2.0/examples/filter_logging.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <string>
-#include <utility>
-
-/**
- * This example demonstrates the usage of the built-in filter, which can filter log levels.
- * When a filter is applied, log messages are still enqueued from the frontend to the backend.
- * Subsequently, the backend dynamically filters them based on a given condition.
- */
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  // Frontend
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-
-  // Set a filter for the sink
-  console_sink->set_log_level_filter(quill::LogLevel::Info);
-
-  quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));
-
-  // Change the LogLevel to send everything
-  logger->set_log_level(quill::LogLevel::TraceL3);
-
-  LOG_TRACE_L3(logger, "This is a log trace l3 example {}", 1);
-  LOG_TRACE_L2(logger, "This is a log trace l2 example {} {}", 2, 2.3);
-  LOG_TRACE_L1(logger, "This is a log trace l1 {} example", "string");
-  LOG_DEBUG(logger, "This is a log debug example {}", 4);
-  LOG_INFO(logger, "This is a log info example {}", sizeof(std::string));
-  LOG_WARNING(logger, "This is a log warning example {}", sizeof(std::string));
-  LOG_ERROR(logger, "This is a log error example {}", sizeof(std::string));
-  LOG_CRITICAL(logger, "This is a log critical example {}", sizeof(std::string));
-}
diff --git a/subprojects/quill-4.2.0/examples/json_sink_logging.cpp b/subprojects/quill-4.2.0/examples/json_sink_logging.cpp
deleted file mode 100644
index 8d8fa44..0000000
--- a/subprojects/quill-4.2.0/examples/json_sink_logging.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/ConsoleSink.h"
-#include "quill/sinks/JsonFileSink.h"
-
-#include <utility>
-
-/**
- * This example showcases the usage of the JsonFileSink to generate JSON-formatted logs.
- * Additionally, it demonstrates how to simultaneously log in both the standard logger output
- * format, e.g., to console and the corresponding JSON format to a JSON output sink.
- *
- * For successful JSON logging, it's essential to use named placeholders within the provided
- * format string, such as "{method}" and "{endpoint}".
- */
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  // Frontend
-
-  // Create a json file for output
-  auto json_sink = quill::Frontend::create_or_get_sink<quill::JsonFileSink>(
-    "json_sink_logging.log",
-    []()
-    {
-      quill::JsonFileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      cfg.set_filename_append_option(quill::FilenameAppendOption::StartDateTime);
-      return cfg;
-    }(),
-    quill::FileEventNotifier{});
-
-  // When using the JsonFileSink, it is ideal to set the logging pattern to empty to avoid unnecessary message formatting.
-  quill::Logger* json_logger = quill::Frontend::create_or_get_logger(
-    "json_logger", std::move(json_sink), "", "%H:%M:%S.%Qns", quill::Timezone::GmtTime);
-
-  for (int i = 0; i < 2; ++i)
-  {
-    LOG_INFO(json_logger, "{method} to {endpoint} took {elapsed} ms", "POST", "http://", 10 * i);
-  }
-
-  // It is also possible to create a logger than logs to both the json file and stdout
-  // with the appropriate format
-  auto json_sink_2 = quill::Frontend::get_sink("json_sink_logging.log");
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("console_sink_id_1");
-
-  // We set a custom format pattern here to also include the named_args
-  quill::Logger* hybrid_logger = quill::Frontend::create_or_get_logger(
-    "hybrid_logger", {std::move(json_sink_2), std::move(console_sink)},
-    "%(time) [%(thread_id)] %(short_source_location:<28) LOG_%(log_level:<9) %(logger:<20) "
-    "%(message) [%(named_args)]");
-
-  for (int i = 2; i < 4; ++i)
-  {
-    LOG_INFO(hybrid_logger, "{method} to {endpoint} took {elapsed} ms", "POST", "http://", 10 * i);
-  }
-}
diff --git a/subprojects/quill-4.2.0/examples/logger_removal_with_file_event_notifier.cpp b/subprojects/quill-4.2.0/examples/logger_removal_with_file_event_notifier.cpp
deleted file mode 100644
index c4bf633..0000000
--- a/subprojects/quill-4.2.0/examples/logger_removal_with_file_event_notifier.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/FileSink.h"
-
-#include <chrono>
-#include <iostream>
-#include <string>
-#include <thread>
-#include <utility>
-
-/**
- * This example demonstrates the creation and removal of a logger object for each instance of the Session class.
- * Each session instance logs to a new log file using a unique logger.
- * When the session ends, the logger is removed, and the associated file is closed.
- * Additionally, it showcases the usage of the FileEventNotifier, which provides notifications for file changes.
- */
-
-class Session
-{
-public:
-  explicit Session(std::string const& unique_name)
-  {
-    // Set up a FileEventNotifier so we are notified on file changes
-    quill::FileEventNotifier file_notifier;
-
-    file_notifier.before_open = [](quill::fs::path const& filename)
-    { std::cout << "file_notifier - preparing to open file " << filename << std::endl; };
-
-    file_notifier.after_open = [](quill::fs::path const& filename, FILE* f)
-    { std::cout << "file_notifier - opened file " << filename << std::endl; };
-
-    file_notifier.before_close = [](quill::fs::path const& filename, FILE* f)
-    { std::cout << "file_notifier - preparing to close file " << filename << std::endl; };
-
-    file_notifier.after_close = [](quill::fs::path const& filename)
-    { std::cout << "file_notifier - closed file " << filename << std::endl; };
-
-    // Create a new log file for this session
-    auto file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(
-      std::string{"session_"} + unique_name + ".log",
-      []()
-      {
-        quill::FileSinkConfig cfg;
-        cfg.set_open_mode('w');
-        cfg.set_filename_append_option(quill::FilenameAppendOption::None);
-        return cfg;
-      }(),
-      file_notifier);
-
-    // Create a session specific logger for the current session
-    _logger = quill::Frontend::create_or_get_logger(unique_name, std::move(file_sink));
-
-    LOG_INFO(_logger, "Hello from session {}", unique_name);
-  }
-
-  ~Session()
-  {
-    // Remove the logger when the session is done. That will also remove the associated file_handler
-    // and close the file as long as no other logger is using that file_handler
-    quill::Frontend::remove_logger(_logger);
-  }
-
-private:
-  quill::Logger* _logger{nullptr};
-};
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  {
-    Session session_1 = Session{"SessionA"};
-    std::this_thread::sleep_for(std::chrono::seconds{3});
-
-    Session session_2 = Session{"SessionB"};
-    std::this_thread::sleep_for(std::chrono::seconds{3});
-  }
-  std::this_thread::sleep_for(std::chrono::seconds{3});
-
-  {
-    Session session_3 = Session{"SessionC"};
-    std::this_thread::sleep_for(std::chrono::seconds{3});
-  }
-  std::this_thread::sleep_for(std::chrono::seconds{3});
-
-  Session session_4 = Session{"SessionD"};
-  std::this_thread::sleep_for(std::chrono::seconds{3});
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/recommended_usage/CMakeLists.txt b/subprojects/quill-4.2.0/examples/recommended_usage/CMakeLists.txt
deleted file mode 100644
index 197b908..0000000
--- a/subprojects/quill-4.2.0/examples/recommended_usage/CMakeLists.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-add_subdirectory(quill_wrapper)
-
-add_executable(quill_example_recommended_usage recommended_usage.cpp)
-set_common_compile_options(quill_example_recommended_usage)
-target_link_libraries(quill_example_recommended_usage quill_wrapper_recommended)
-
-add_executable(quill_example_use_overwrite_macros use_overwrite_macros.cpp)
-set_common_compile_options(quill_example_use_overwrite_macros)
-target_link_libraries(quill_example_use_overwrite_macros quill_wrapper_recommended)
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/recommended_usage/quill_wrapper/CMakeLists.txt b/subprojects/quill-4.2.0/examples/recommended_usage/quill_wrapper/CMakeLists.txt
deleted file mode 100644
index 2c7a0c8..0000000
--- a/subprojects/quill-4.2.0/examples/recommended_usage/quill_wrapper/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-set(LIB_NAME quill_wrapper_recommended)
-
-add_library(${LIB_NAME} STATIC
-        include/quill_wrapper/overwrite_macros.h
-        include/quill_wrapper/quill_wrapper.h
-        include/quill_wrapper/quill_wrapper.cpp)
-
-# Add include directories for this library
-target_include_directories(${LIB_NAME}
-        PUBLIC
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-        $<INSTALL_INTERFACE:include>
-        PRIVATE
-        ${CMAKE_CURRENT_SOURCE_DIR})
-
-# Link quill dependency
-target_link_libraries(${LIB_NAME} PUBLIC quill::quill)
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/recommended_usage/quill_wrapper/include/quill_wrapper/overwrite_macros.h b/subprojects/quill-4.2.0/examples/recommended_usage/quill_wrapper/include/quill_wrapper/overwrite_macros.h
deleted file mode 100644
index 808d042..0000000
--- a/subprojects/quill-4.2.0/examples/recommended_usage/quill_wrapper/include/quill_wrapper/overwrite_macros.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#pragma once
-
-/**
- * This file is optional and demonstrates how users can replace the library macros with their own.
- *
- * It becomes useful when opting for a single Logger object over several logger objects.
- *
- * However, using multiple logger objects provides greater flexibility in applications with multiple
- * components. With multiple loggers, it's easier to control the log level of each component
- * individually, whereas using a single logger, as shown in this example, may present limitations.
- */
-
-/**
- * By defining QUILL_DISABLE_NON_PREFIXED_MACROS before including LogMacros, we disable the
- * default 'LOG_' and then create our own macros using the global logger.
- */
-#define QUILL_DISABLE_NON_PREFIXED_MACROS
-
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-
-// The logger we defined in quill_wrapper.cpp
-extern quill::Logger* global_logger_a;
-
-// Define custom log macros using global_logger_a. Two examples are provided here for demonstration.
-#define LOG_INFO(fmt, ...) QUILL_LOG_INFO(global_logger_a, fmt, ##__VA_ARGS__)
-#define LOG_WARNING(fmt, ...) QUILL_LOG_WARNING(global_logger_a, fmt, ##__VA_ARGS__)
-// etc ..
diff --git a/subprojects/quill-4.2.0/examples/recommended_usage/quill_wrapper/include/quill_wrapper/quill_wrapper.cpp b/subprojects/quill-4.2.0/examples/recommended_usage/quill_wrapper/include/quill_wrapper/quill_wrapper.cpp
deleted file mode 100644
index af057c9..0000000
--- a/subprojects/quill-4.2.0/examples/recommended_usage/quill_wrapper/include/quill_wrapper/quill_wrapper.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "quill_wrapper.h"
-
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/Logger.h"
-#include "quill/sinks/FileSink.h"
-
-// Define a global variable for a logger to avoid looking up the logger each time.
-// Additional global variables can be defined for additional loggers if needed.
-quill::Logger* global_logger_a;
-
-void setup_quill(char const* log_file)
-{
-  // Start the backend thread
-  quill::Backend::start();
-
-  // Setup sink and logger
-  auto file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(
-    log_file,
-    []()
-    {
-      quill::FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      cfg.set_filename_append_option(quill::FilenameAppendOption::StartDateTime);
-      return cfg;
-    }(),
-    quill::FileEventNotifier{});
-
-  // Create and store the logger
-  global_logger_a =
-    quill::Frontend::create_or_get_logger("root", std::move(file_sink),
-                                          "%(time) [%(thread_id)] %(short_source_location:<28) "
-                                          "LOG_%(log_level:<9) %(logger:<12) %(message)",
-                                          "%H:%M:%S.%Qns", quill::Timezone::GmtTime);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/recommended_usage/quill_wrapper/include/quill_wrapper/quill_wrapper.h b/subprojects/quill-4.2.0/examples/recommended_usage/quill_wrapper/include/quill_wrapper/quill_wrapper.h
deleted file mode 100644
index c71a95e..0000000
--- a/subprojects/quill-4.2.0/examples/recommended_usage/quill_wrapper/include/quill_wrapper/quill_wrapper.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#pragma once
-
-void setup_quill(char const* log_file);
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/recommended_usage/recommended_usage.cpp b/subprojects/quill-4.2.0/examples/recommended_usage/recommended_usage.cpp
deleted file mode 100644
index a4cfd23..0000000
--- a/subprojects/quill-4.2.0/examples/recommended_usage/recommended_usage.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/**
- * This example demonstrates the recommended setup for the Quill library.
- *
- * It is advisable to encapsulate the header-only library into a static library, which
- * you build once and link to your main  application.
- * This library should include `quill/backend` in the .cpp files.
- *
- * In your application, include only the following headers for logging:
- *
- * - For logger lookup or creation:
- *   #include "quill/Frontend.h"
- *
- * - For sink creation:
- *   #include "quill/sinks/.."
- *
- * - For logging:
- *   #include "quill/Logger.h"
- *   #include "quill/LogMacros.h"
- */
-
-// Include our wrapper lib
-#include "quill_wrapper/quill_wrapper.h"
-
-// We need only those two headers in order to log
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-
-// We utilize the global_logger_a from the quill_wrapper library.
-// The use of a global logger is optional.
-// Alternatively, we could include "quill/Frontend.h" and use `quill::Frontend::get_logger(..)`
-// to obtain the created logger, or we could store it as a class member.
-extern quill::Logger* global_logger_a;
-
-int main()
-{
-  setup_quill("recommended_usage.log");
-
-  // Change the LogLevel to print everything
-  global_logger_a->set_log_level(quill::LogLevel::TraceL3);
-
-  LOG_TRACE_L3(global_logger_a, "This is a log trace l3 example {}", 1);
-  LOG_TRACE_L2(global_logger_a, "This is a log trace l2 example {} {}", 2, 2.3);
-  LOG_TRACE_L1(global_logger_a, "This is a log trace l1 {} example", "string");
-  LOG_DEBUG(global_logger_a, "This is a log debug example {}", 4);
-  LOG_INFO(global_logger_a, "This is a log info example {}", 5);
-  LOG_WARNING(global_logger_a, "This is a log warning example {}", 6);
-  LOG_ERROR(global_logger_a, "This is a log error example {}", 7);
-  LOG_CRITICAL(global_logger_a, "This is a log critical example {}", 118);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/recommended_usage/use_overwrite_macros.cpp b/subprojects/quill-4.2.0/examples/recommended_usage/use_overwrite_macros.cpp
deleted file mode 100644
index 6c68933..0000000
--- a/subprojects/quill-4.2.0/examples/recommended_usage/use_overwrite_macros.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include "quill_wrapper/overwrite_macros.h"
-#include "quill_wrapper/quill_wrapper.h"
-
-int main()
-{
-  setup_quill("use_overwrite_macros.log");
-
-  // Change the LogLevel to print everything
-  global_logger_a->set_log_level(quill::LogLevel::TraceL3);
-
-  LOG_INFO("This is a log info example {}", 5);
-  LOG_WARNING("This is a log warning example {}", 6);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/rotating_file_logging.cpp b/subprojects/quill-4.2.0/examples/rotating_file_logging.cpp
deleted file mode 100644
index da3c173..0000000
--- a/subprojects/quill-4.2.0/examples/rotating_file_logging.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/RotatingFileSink.h"
-
-#include <utility>
-
-/**
- * This example demonstrates how to create a RotatingFileSink with daily rotation and automatic rotation based on maximum file size.
- * For additional configuration options, refer to RotatingFileSinkConfig.
- */
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  // Frontend
-  auto rotating_file_sink = quill::Frontend::create_or_get_sink<quill::RotatingFileSink>(
-    "rotating_file.log",
-    []()
-    {
-      // See RotatingFileSinkConfig for more options
-      quill::RotatingFileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      cfg.set_filename_append_option(quill::FilenameAppendOption::StartDateTime);
-      cfg.set_rotation_time_daily("18:30");
-      cfg.set_rotation_max_file_size(1024); // small value to demonstrate the example
-      return cfg;
-    }());
-
-  quill::Logger* logger =
-    quill::Frontend::create_or_get_logger("root", std::move(rotating_file_sink),
-                                          "%(time) [%(thread_id)] %(short_source_location:<28) "
-                                          "LOG_%(log_level:<9) %(logger:<12) %(message)",
-                                          "%H:%M:%S.%Qns", quill::Timezone::GmtTime);
-
-  for (int i = 0; i < 20; ++i)
-  {
-    LOG_INFO(logger, "Hello from rotating logger, index is {}", i);
-  }
-}
diff --git a/subprojects/quill-4.2.0/examples/signal_handler.cpp b/subprojects/quill-4.2.0/examples/signal_handler.cpp
deleted file mode 100644
index 9dda2b6..0000000
--- a/subprojects/quill-4.2.0/examples/signal_handler.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <chrono>
-#include <csignal>
-#include <cstdint>
-#include <thread>
-#include <utility>
-#include <vector>
-
-void cause_segfault(quill::Logger* logger)
-{
-  LOG_INFO(logger, "Crashing");
-
-  int* p = (int*)0x12345678;
-  *p = 0;
-}
-
-void infinite_loop(quill::Logger* logger)
-{
-  LOG_INFO(logger, "Crashing");
-
-  /* break out with ctrl+c to test SIGINT handling */
-  while (1)
-  {
-  };
-}
-
-void illegal_instruction(quill::Logger* logger)
-{
-  LOG_INFO(logger, "Crashing");
-  raise(SIGILL);
-}
-
-/**
- * Signal handler example
- * The signal handler flushes the log when the application crashes or gets terminated
- */
-
-int main()
-{
-#if defined(_WIN32)
-  // NOTE: On windows a signal handler must be installed on each new thread
-  quill::init_signal_handler<quill::FrontendOptions>();
-#endif
-
-  // Start the logging backend thread with a signal handler
-  // On Linux/Macos one signal handler is set to handle POSIX style signals
-  // On Windows an exception handler and a Ctrl-C handler is set.
-  quill::Backend::start_with_signal_handler<quill::FrontendOptions>();
-
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-  quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));
-
-  // create threads that will cause a segfault
-  std::vector<std::thread> threads;
-  for (size_t i = 0; i < 4; ++i)
-  {
-    threads.emplace_back(
-      [logger]()
-      {
-#if defined(_WIN32)
-        // NOTE: On windows the signal handler must be installed on each new thread
-        quill::init_signal_handler<quill::FrontendOptions>();
-#endif
-        // sleep for 1 second so all threads are ready
-        std::this_thread::sleep_for(std::chrono::seconds{1});
-
-        for (size_t i = 0; i < 10; ++i)
-        {
-          // log 10 messages
-          LOG_INFO(logger, "Log from thread {}", i);
-        }
-
-        // After 10 messages Crash - Uncomment any of the below :
-        
-        // illegal_instruction(logger);
-        // cause_segfault(logger);
-      });
-  }
-
-  for (uint32_t cnt{0}; cnt < 1000; ++cnt)
-  {
-    std::this_thread::sleep_for(std::chrono::milliseconds{300});
-    LOG_INFO(logger, "Log from main {}", cnt);
-  }
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/system_clock_logging.cpp b/subprojects/quill-4.2.0/examples/system_clock_logging.cpp
deleted file mode 100644
index d5d2cf1..0000000
--- a/subprojects/quill-4.2.0/examples/system_clock_logging.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <string>
-#include <utility>
-
-/**
- * Trivial logging example to console using std::chrono::now for timestamps instead of the
- * default rdtsc clock
- */
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  // Frontend
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-
-  quill::Logger* logger = quill::Frontend::create_or_get_logger(
-    "root", std::move(console_sink), "%(time) [%(process_id)] [%(thread_id)] %(logger) - %(message)",
-    "%D %H:%M:%S.%Qms %z", quill::Timezone::GmtTime, quill::ClockSourceType::System);
-
-  // Change the LogLevel to print everything
-  logger->set_log_level(quill::LogLevel::TraceL3);
-
-  LOG_TRACE_L3(logger, "This is a log trace l3 example {}", 1);
-  LOG_TRACE_L2(logger, "This is a log trace l2 example {} {}", 2, 2.3);
-  LOG_TRACE_L1(logger, "This is a log trace l1 {} example", "string");
-  LOG_DEBUG(logger, "This is a log debug example {}", 4);
-  LOG_INFO(logger, "This is a log info example {}", sizeof(std::string));
-  LOG_WARNING(logger, "This is a log warning example {}", sizeof(std::string));
-  LOG_ERROR(logger, "This is a log error example {}", sizeof(std::string));
-  LOG_CRITICAL(logger, "This is a log critical example {}", sizeof(std::string));
-}
diff --git a/subprojects/quill-4.2.0/examples/tags_logging.cpp b/subprojects/quill-4.2.0/examples/tags_logging.cpp
deleted file mode 100644
index 9ad192a..0000000
--- a/subprojects/quill-4.2.0/examples/tags_logging.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/Utility.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <cstdint>
-#include <string>
-#include <string_view>
-#include <utility>
-
-/**
- * This example showcases the usage of the _WITH_TAGS macros, which allow for logging additional
- * tags with each log message.
- *
- * The example demonstrates the construction of custom tags at compile time using
- * the quill::CustomTags interface.
- *
- * One important limitation to note is that quill::CustomTags instances must be constructed
- * at compile time.
- */
-
-class MyTagsA : public quill::Tags
-{
-public:
-  constexpr MyTagsA(char const* tag_a, uint32_t tag_b) : _tag_a(tag_a), _tag_b(tag_b) {}
-
-  void format(std::string& out) const override
-  {
-    out.append(_tag_a);
-    out.append(":");
-    out.append(std::to_string(_tag_b));
-  }
-
-private:
-  char const* _tag_a;
-  uint32_t _tag_b;
-};
-
-// Define another CustomTags class
-class MyTagsB : public quill::Tags
-{
-public:
-  constexpr MyTagsB(char const* tag_a, uint32_t tag_b) : _tag_a(tag_a), _tag_b(tag_b) {}
-
-  void format(std::string& out) const override
-  {
-    out.append(_tag_a);
-    out.append(":");
-    out.append(std::to_string(_tag_b));
-  }
-
-private:
-  char const* _tag_a;
-  uint32_t _tag_b;
-};
-
-static constexpr MyTagsA tags_a{"CUSTOM_TAG_A", 12};
-static constexpr MyTagsB tags_b{"CUSTOM_TAG_B", 23};
-
-// Combine different tags
-static constexpr quill::utility::CombinedTags<MyTagsA, MyTagsB> tags_ab{tags_a, tags_b};
-
-static constexpr quill::utility::CombinedTags<MyTagsA, MyTagsB> tags_ab_custom_format_delimiter{
-  tags_a, tags_b, " -- "};
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-
-  // It is important to change the default logging pattern to include the custom tags
-  quill::Logger* logger = quill::Frontend::create_or_get_logger(
-    "root", std::move(console_sink),
-    "%(time) [%(thread_id)] %(short_source_location:<28) %(log_level:<9) %(logger:<16) "
-    "[%(custom_tags)] %(message)",
-    "%Y-%m-%d %H:%M:%S.%Qms", quill::Timezone::GmtTime);
-
-  LOG_TRACE_L3_WITH_TAGS(logger, tags_a, "TraceL3 with custom tags");
-  LOG_TRACE_L2_WITH_TAGS(logger, tags_b, "TraceL2 with custom tags");
-  LOG_TRACE_L1_WITH_TAGS(logger, tags_b, "TraceL1 with custom tags");
-  LOG_DEBUG_WITH_TAGS(logger, tags_a, "Debug with custom tags");
-  LOG_INFO_WITH_TAGS(logger, tags_a, "Info with custom tags");
-  LOG_WARNING_WITH_TAGS(logger, tags_b, "Warning with custom tags");
-  LOG_ERROR_WITH_TAGS(logger, tags_a, "Error with custom tags");
-
-  LOG_INFO_WITH_TAGS(logger, tags_ab, "Info with combined custom tags");
-
-  LOG_INFO_WITH_TAGS(logger, tags_ab_custom_format_delimiter,
-                     "Combined custom tags custom delimiter");
-
-  LOG_INFO(logger, "Without custom tags");
-}
diff --git a/subprojects/quill-4.2.0/examples/user_clock_source.cpp b/subprojects/quill-4.2.0/examples/user_clock_source.cpp
deleted file mode 100644
index 102911a..0000000
--- a/subprojects/quill-4.2.0/examples/user_clock_source.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/UserClockSource.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <atomic>
-#include <chrono>
-#include <cstdint>
-#include <utility>
-
-/**
- * Example demonstrating custom clock usage for logging. This is particularly useful
- * when simulating events from a specific time period, allowing logs to align with
- * the simulated time.
- */
-
-/**
- * This class needs to be thread-safe, unless only a single thread in the application calling
- * LOG_ macros from the same logger
- */
-class SimulatedClock : public quill::UserClockSource
-{
-public:
-  SimulatedClock() = default;
-
-  /**
-   * Required by TimestampClock
-   * @return current time now, in nanoseconds since epoch
-   */
-  uint64_t now() const override { return _timestamp_ns.load(std::memory_order_relaxed); }
-
-  /**
-   * set custom timestamp
-   * @param time_since_epoch timestamp
-   */
-  void set_timestamp(std::chrono::seconds time_since_epoch)
-  {
-    // always convert to nanos
-    _timestamp_ns.store(static_cast<uint64_t>(std::chrono::nanoseconds{time_since_epoch}.count()),
-                        std::memory_order_relaxed);
-  }
-
-private:
-  std::atomic<uint64_t> _timestamp_ns{0}; // time since epoch - must always be in nanoseconds
-};
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  // Create a simulated timestamp class. Quill takes a pointer to this class,
-  // and the user is responsible for its lifetime.
-  // Ensure that the instance of this class remains alive for as long as the logger
-  // object exists, until the logger is removed.
-  SimulatedClock simulated_clock;
-
-  // Get the console sink and also create a logger using the simulated clock
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-
-  quill::Logger* logger = quill::Frontend::create_or_get_logger(
-    "root", std::move(console_sink),
-    "%(time) %(short_source_location:<28) LOG_%(log_level:<9) %(logger:<12) %(message)",
-    "%D %H:%M:%S.%Qns", quill::Timezone::LocalTime, quill::ClockSourceType::User, &simulated_clock);
-
-  // Change the LogLevel to print everything
-  logger->set_log_level(quill::LogLevel::TraceL3);
-
-  // Set our timestamp to Sunday 12 June 2022
-  simulated_clock.set_timestamp(std::chrono::seconds{1655007309});
-  LOG_TRACE_L3(logger, "This is a log trace l3 example {}", 1);
-  LOG_TRACE_L2(logger, "This is a log trace l2 example {} {}", 2, 2.3);
-
-  // update our timestamp
-  simulated_clock.set_timestamp(std::chrono::seconds{1655039000});
-  LOG_INFO(logger, "This is a log info {} example", "string");
-  LOG_DEBUG(logger, "This is a log debug example {}", 4);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/user_defined_filter.cpp b/subprojects/quill-4.2.0/examples/user_defined_filter.cpp
deleted file mode 100644
index 573ded9..0000000
--- a/subprojects/quill-4.2.0/examples/user_defined_filter.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/filters/Filter.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <cstdint>
-#include <string>
-#include <string_view>
-#include <utility>
-
-/**
- * This example demonstrates the creation usage of a user defined filter.
- * When a filter is applied, log messages are still enqueued from the frontend to the backend.
- * Subsequently, the backend dynamically filters them based on a given condition.
- */
-
-class UserFilter : public quill::Filter
-{
-public:
-  UserFilter() : quill::Filter("filter_1"){};
-
-  bool filter(quill::MacroMetadata const* log_metadata, uint64_t log_timestamp,
-              std::string_view thread_id, std::string_view thread_name, std::string_view logger_name,
-              quill::LogLevel log_level, std::string_view log_message) noexcept override
-  {
-    // for example filter out lines 47 and 48 of any file
-    return (std::stoi(log_metadata->line()) != 47) && (std::stoi(log_metadata->line()) != 48);
-  }
-};
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  // Frontend
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-
-  // Add the filter - adding filters is thread safe and can be called anytime
-  console_sink->add_filter(std::make_unique<UserFilter>());
-
-  quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));
-
-  // Change the LogLevel to send everything
-  logger->set_log_level(quill::LogLevel::TraceL3);
-
-  LOG_TRACE_L3(logger, "This is a log trace l3 example {}", 1);
-  LOG_TRACE_L2(logger, "This is a log trace l2 example {} {}", 2, 2.3);
-  LOG_TRACE_L1(logger, "This is a log trace l1 {} example", "string");
-  LOG_DEBUG(logger, "This is a log debug example {}", 4);
-  LOG_INFO(logger, "This is a log info example {}", sizeof(std::string));
-  LOG_WARNING(logger, "This is a log warning example {}", sizeof(std::string));
-  LOG_ERROR(logger, "This is a log error example {}", sizeof(std::string));
-  LOG_CRITICAL(logger, "This is a log critical example {}", sizeof(std::string));
-}
diff --git a/subprojects/quill-4.2.0/examples/user_defined_sink.cpp b/subprojects/quill-4.2.0/examples/user_defined_sink.cpp
deleted file mode 100644
index 98aaa5d..0000000
--- a/subprojects/quill-4.2.0/examples/user_defined_sink.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/Sink.h"
-
-#include <cstdint>
-#include <iostream>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-/**
- * This example demonstrates how to implement a custom Sink
- */
-
-class UserSink final : public quill::Sink
-{
-public:
-  UserSink() = default;
-
-  /***/
-  void write_log_message(quill::MacroMetadata const* log_metadata, uint64_t log_timestamp,
-                         std::string_view thread_id, std::string_view thread_name,
-                         std::string_view logger_name, quill::LogLevel log_level,
-                         std::vector<std::pair<std::string, std::string>> const* named_args,
-                         std::string_view log_message) override
-  {
-    // Called by the logger backend worker thread for each LOG_* macro
-    // last character is '\n' and we exclude it using size() - 1
-    _messages.push_back(std::string{log_message.data(), log_message.size() - 1});
-  }
-
-  /***/
-  void flush_sink() noexcept override
-  {
-    // This is not called for each LOG_* invocation like the write function, instead it is called
-    // periodically or when there are no more LOG_* writes left to process or when logger->flush()
-    for (auto const& message : _messages)
-    {
-      std::cout << message << std::endl;
-    }
-    _messages.clear();
-  }
-
-  /***/
-  void run_periodic_tasks() noexcept override
-  {
-    // Executes periodic user-defined tasks. This function is frequently invoked by the backend thread's main loop.
-    // Avoid including heavy tasks here to prevent slowing down the backend thread.
-  }
-
-private:
-  std::vector<std::string> _messages;
-};
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  // Frontend
-  auto file_sink = quill::Frontend::create_or_get_sink<UserSink>("sink_id_1");
-
-  quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(file_sink));
-
-  logger->set_log_level(quill::LogLevel::Debug);
-
-  LOG_INFO(logger, "Hello from {}", "sink example");
-  LOG_DEBUG(logger, "Invoking user sink flush");
-
-  logger->flush_log();
-
-  LOG_INFO(logger, "Log more {}", 123);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/examples/user_defined_types_logging.cpp b/subprojects/quill-4.2.0/examples/user_defined_types_logging.cpp
deleted file mode 100644
index 7c0b617..0000000
--- a/subprojects/quill-4.2.0/examples/user_defined_types_logging.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Logger.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <cstdint>
-#include <sstream>
-#include <string>
-#include <utility>
-
-/**
- * This example illustrates logging user-defined types.
- *
- * Starting from version 4.0.0, direct passing of user-defined and standard library types to the
- * 'LOG_' macros is no longer supported. Instead, these types must be converted to strings
- * before being passed to the logger.
- *
- * In this example, std::ostringstream is used for simplicity, but it's recommended to use modern
- * formatting libraries such as std::format or fmt::format.
- */
-
-class User
-{
-public:
-  User(std::string name, std::string surname, uint32_t age)
-    : name(std::move(name)), surname(std::move(surname)), age(age){};
-
-  friend std::ostream& operator<<(std::ostream& os, User const& obj)
-  {
-    os << "name: " << obj.name << ", surname: " << obj.surname << ", age: " << obj.age;
-    return os;
-  }
-
-private:
-  std::string name;
-  std::string surname;
-  uint32_t age;
-};
-
-// Helper to convert to string
-template <typename T>
-std::string to_string(T const& obj)
-{
-  std::ostringstream oss;
-  oss << obj;
-  return oss.str();
-}
-
-int main()
-{
-  // Start the backend thread
-  quill::BackendOptions backend_options;
-  quill::Backend::start(backend_options);
-
-  // Frontend
-  auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
-  quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));
-
-  User user_1{"Super", "User", 1};
-
-  LOG_INFO(logger, "User is [{}]", to_string(user_1));
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/meson.build b/subprojects/quill-4.2.0/meson.build
deleted file mode 100644
index ce04047..0000000
--- a/subprojects/quill-4.2.0/meson.build
+++ /dev/null
@@ -1,21 +0,0 @@
-project('quill', 'cpp', version : '4.2.0', default_options : ['warning_level=3', 'cpp_std=c++17'])
-
-inc_dirs = include_directories('quill/include', is_system: true)
-
-# Conditional compiler arguments for specific compiler
-interface_compile_args = meson.get_compiler('cpp').get_supported_arguments('-Wno-gnu-zero-variadic-macro-arguments')
-
-quill_dep = declare_dependency(include_directories : inc_dirs,
-                               dependencies : [dependency('threads')],
-                               compile_args : interface_compile_args)
-
-install_subdir('quill/include/quill', install_dir: get_option('includedir'), install_tag: 'devel')
-
-pkg_mod = import('pkgconfig')
-pkg_mod.generate(
-    name : 'quill',
-    filebase : 'quill',
-    description : 'Asynchronous Low Latency C++ Logging Library',
-    subdirs : 'quill'
-)
-
diff --git a/subprojects/quill-4.2.0/quill/CMakeLists.txt b/subprojects/quill-4.2.0/quill/CMakeLists.txt
deleted file mode 100644
index c33ae10..0000000
--- a/subprojects/quill-4.2.0/quill/CMakeLists.txt
+++ /dev/null
@@ -1,248 +0,0 @@
-if (NOT QUILL_MASTER_PROJECT)
-    find_package(Threads REQUIRED)
-endif ()
-
-# library name
-set(TARGET_NAME quill)
-
-# header files
-set(HEADER_FILES
-        include/quill/backend/BackendManager.h
-        include/quill/backend/BackendOptions.h
-        include/quill/backend/BackendWorker.h
-        include/quill/backend/BacktraceStorage.h
-        include/quill/backend/PatternFormatter.h
-        include/quill/backend/RdtscClock.h
-        include/quill/backend/SignalHandler.h
-        include/quill/backend/StringFromTime.h
-        include/quill/backend/TimestampFormatter.h
-        include/quill/backend/TransitEvent.h
-        include/quill/backend/TransitEventBuffer.h
-        include/quill/backend/BackendUtilities.h
-
-        include/quill/bundled/fmt/args.h
-        include/quill/bundled/fmt/chrono.h
-        include/quill/bundled/fmt/color.h
-        include/quill/bundled/fmt/compile.h
-        include/quill/bundled/fmt/core.h
-        include/quill/bundled/fmt/format.h
-        include/quill/bundled/fmt/format-inl.h
-        include/quill/bundled/fmt/os.h
-        include/quill/bundled/fmt/ostream.h
-        include/quill/bundled/fmt/printf.h
-        include/quill/bundled/fmt/ranges.h
-        include/quill/bundled/fmt/std.h
-        include/quill/bundled/fmt/xchar.h
-
-        include/quill/core/Attributes.h
-        include/quill/core/BoundedSPSCQueue.h
-        include/quill/core/Common.h
-        include/quill/core/DynamicFormatArgStore.h
-        include/quill/core/Codec.h
-        include/quill/core/Filesystem.h
-        include/quill/core/FormatBuffer.h
-        include/quill/core/FrontendOptions.h
-        include/quill/core/LoggerBase.h
-        include/quill/core/LoggerManager.h
-        include/quill/core/LogLevel.h
-        include/quill/core/MacroMetadata.h
-        include/quill/core/MathUtils.h
-        include/quill/core/QuillError.h
-        include/quill/core/Rdtsc.h
-        include/quill/core/SinkManager.h
-        include/quill/core/ThreadContextManager.h
-        include/quill/core/ThreadUtilities.h
-        include/quill/core/TimeUtilities.h
-        include/quill/core/UnboundedSPSCQueue.h
-
-        include/quill/filters/Filter.h
-
-        include/quill/sinks/ConsoleSink.h
-        include/quill/sinks/FileSink.h
-        include/quill/sinks/JsonConsoleSink.h
-        include/quill/sinks/JsonFileSink.h
-        include/quill/sinks/NullSink.h
-        include/quill/sinks/RotatingFileSink.h
-        include/quill/sinks/Sink.h
-        include/quill/sinks/StreamSink.h
-
-        include/quill/std/Array.h
-        include/quill/std/Deque.h
-        include/quill/std/FilesystemPath.h
-        include/quill/std/ForwardList.h
-        include/quill/std/List.h
-        include/quill/std/Map.h
-        include/quill/std/Optional.h
-        include/quill/std/Pair.h
-        include/quill/std/Set.h
-        include/quill/std/Tuple.h
-        include/quill/std/UnorderedMap.h
-        include/quill/std/UnorderedSet.h
-        include/quill/std/Vector.h
-
-        include/quill/Backend.h
-        include/quill/BackendTscClock.h
-        include/quill/Frontend.h
-        include/quill/Logger.h
-        include/quill/LogMacros.h
-        include/quill/UserClockSource.h
-        include/quill/Utility.h
-)
-
-# Add as a library
-add_library(${TARGET_NAME} INTERFACE)
-add_library(${TARGET_NAME}::${TARGET_NAME} ALIAS ${TARGET_NAME})
-
-if (QUILL_NO_EXCEPTIONS)
-    target_compile_definitions(${TARGET_NAME} PUBLIC INTERFACE -DQUILL_NO_EXCEPTIONS)
-
-    if (NOT MSVC)
-        target_compile_options(${TARGET_NAME} PUBLIC INTERFACE -fno-exceptions)
-    endif ()
-endif ()
-
-if (QUILL_NO_THREAD_NAME_SUPPORT)
-    target_compile_definitions(${TARGET_NAME} PUBLIC INTERFACE -DQUILL_NO_THREAD_NAME_SUPPORT)
-endif ()
-
-if (QUILL_X86ARCH)
-    target_compile_definitions(${TARGET_NAME} PUBLIC INTERFACE -DQUILL_X86ARCH)
-endif ()
-
-if (QUILL_DISABLE_NON_PREFIXED_MACROS)
-    target_compile_definitions(${TARGET_NAME} PUBLIC INTERFACE -DQUILL_DISABLE_NON_PREFIXED_MACROS)
-endif ()
-
-# Add target sources
-target_sources(${TARGET_NAME} PRIVATE ${HEADER_FILES})
-
-# Link dependencies
-target_link_libraries(${TARGET_NAME} PUBLIC INTERFACE Threads::Threads)
-
-if (MINGW)
-    # strftime requires this when using MinGw to correctly format the time ..
-    target_link_libraries(${TARGET_NAME} PUBLIC INTERFACE ucrtbase)
-endif ()
-
-if (CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.0)
-    target_link_libraries(${TARGET_NAME} PUBLIC INTERFACE stdc++fs)
-endif ()
-
-# Add include directories for this library
-target_include_directories(${TARGET_NAME}
-        INTERFACE
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-        $<INSTALL_INTERFACE:include>)
-
-# Properties
-set_target_properties(${TARGET_NAME} PROPERTIES VERSION ${QUILL_VERSION} SOVERSION ${QUILL_VERSION})
-
-# ---- Tests ---- #
-if (QUILL_BUILD_TESTS AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/test)
-    add_subdirectory(test)
-endif ()
-
-if (QUILL_MASTER_PROJECT OR QUILL_ENABLE_INSTALL)
-    # ---- Install ---- #
-    include(GNUInstallDirs)
-    include(CMakePackageConfigHelpers)
-
-    set(version_config ${PROJECT_BINARY_DIR}/quill-config-version.cmake)
-    set(project_config ${PROJECT_BINARY_DIR}/quill-config.cmake)
-    set(pkgconfig ${PROJECT_BINARY_DIR}/quill.pc)
-    set(targets_export_name quill-targets)
-
-    set(QUILL_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/quill CACHE STRING
-            "Installation directory for cmake files, relative to ${CMAKE_INSTALL_PREFIX}.")
-
-    set(QUILL_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE STRING
-            "Installation directory for libraries, relative to ${CMAKE_INSTALL_PREFIX}.")
-
-    set(QUILL_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE STRING
-            "Installation directory for include files, relative to ${CMAKE_INSTALL_PREFIX}.")
-
-    set(QUILL_PKGCONFIG_DIR ${CMAKE_INSTALL_PREFIX}/pkgconfig CACHE PATH
-            "Installation directory for pkgconfig (.pc) files, relative to ${CMAKE_INSTALL_PREFIX}.")
-
-    # Generate pkgconfig
-    configure_file(
-            "${CMAKE_CURRENT_LIST_DIR}/cmake/quill.pc.in"
-            "${pkgconfig}"
-            @ONLY)
-
-    # Copy pkgconfig
-    install(FILES "${pkgconfig}" DESTINATION "${QUILL_PKGCONFIG_DIR}")
-
-    # Generate the version, config and target files into the build directory.
-    write_basic_package_version_file(
-            ${version_config}
-            VERSION ${QUILL_VERSION}
-            COMPATIBILITY AnyNewerVersion)
-
-    configure_package_config_file(
-            ${CMAKE_CURRENT_LIST_DIR}/cmake/quill-config.cmake.in
-            ${project_config}
-            INSTALL_DESTINATION ${QUILL_CMAKE_DIR})
-
-    # Install version, config files
-    install(FILES ${project_config} ${version_config}
-            DESTINATION ${QUILL_CMAKE_DIR})
-
-    # Install the headers
-    install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/include/quill DESTINATION ${QUILL_INC_DIR})
-
-    # Install the library
-    install(TARGETS ${TARGET_NAME} EXPORT ${targets_export_name}
-            LIBRARY DESTINATION ${QUILL_LIB_DIR}
-            ARCHIVE DESTINATION ${QUILL_LIB_DIR}
-            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-
-    # Export the library
-    install(EXPORT ${targets_export_name} DESTINATION ${QUILL_CMAKE_DIR}
-            NAMESPACE quill::)
-
-    # Install the examples
-    if (QUILL_BUILD_EXAMPLES)
-        install(TARGETS
-                quill_example_use_overwrite_macros
-                quill_example_recommended_usage
-                quill_example_backend_thread_notify
-                quill_example_backtrace_logging
-                quill_example_bounded_dropping_queue_frontend
-                quill_example_console_logging
-                quill_example_custom_console_colours
-                quill_example_rotating_file_logging
-                quill_example_signal_handler
-                quill_example_logger_removal_with_file_event_notifier
-                quill_example_custom_frontend_options
-                quill_example_file_logging
-                quill_example_filter_logging
-                quill_example_system_clock_logging
-                quill_example_user_clock_source
-                quill_example_user_defined_filter
-                quill_example_user_defined_sink
-                quill_example_tags_logging
-                quill_example_json_sink_logging
-                quill_example_user_defined_types_logging
-                RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-    endif ()
-
-    # ---- Packaging ---- #
-    set(CPACK_GENERATOR ZIP)
-    set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY 0)
-    set(CPACK_INSTALL_CMAKE_PROJECTS "${CMAKE_BINARY_DIR}" "${PROJECT_NAME}" ALL .)
-    set(CPACK_PROJECT_URL "https://github.com/odygrd/quill")
-    set(CPACK_PACKAGE_VENDOR "Odysseas Georgoudis")
-    set(CPACK_PACKAGE_CONTACT "Odysseas Odysseas <odygrd@hotmail.com>")
-    set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Asynchronous Low Latency C++ Logging Library")
-    set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
-    set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
-    set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
-    set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH})
-    set(CPACK_PACKAGE_RELOCATABLE ON)
-    set(CPACK_RPM_PACKAGE_LICENSE "MIT")
-    set(CPACK_RPM_PACKAGE_GROUP "System Environment/Libraries")
-    set(CPACK_RPM_PACKAGE_URL ${CPACK_PROJECT_URL})
-    set(CPACK_RPM_PACKAGE_DESCRIPTION "Asynchronous Low Latency C++ Logging Library")
-    include(CPack)
-endif ()
diff --git a/subprojects/quill-4.2.0/quill/cmake/CodeCoverage.cmake b/subprojects/quill-4.2.0/quill/cmake/CodeCoverage.cmake
deleted file mode 100644
index 2d719c3..0000000
--- a/subprojects/quill-4.2.0/quill/cmake/CodeCoverage.cmake
+++ /dev/null
@@ -1,157 +0,0 @@
-# 2012-01-31, Lars Bilke
-# - Enable Code Coverage
-#
-# 2013-09-17, Joakim Söderberg
-# - Added support for Clang.
-# - Some additional usage instructions.
-#
-# 2018-03-31, Bendik Samseth
-# - Relax debug output.
-# - Keep a copy of the coverage output for later use.
-# - Updated coverage exclude patterns.
-#
-# 2018-01-03, HenryRLee
-# - Allow for *Clang compiler names, not just Clang.
-#
-# 2018-01-03, Bendik Samseth
-# - Only check compiler compatibility if in a coverage build.
-#
-#
-# USAGE:
-
-# 0. (Mac only) If you use Xcode 5.1 make sure to patch geninfo as described here:
-#      http://stackoverflow.com/a/22404544/80480
-#
-# 1. Copy this file into your cmake modules path.
-#
-# 2. Add the following line to your CMakeLists.txt:
-#      INCLUDE(CodeCoverage)
-#
-# 3. Set compiler flags to turn off optimization and enable coverage:
-#    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
-#	 SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
-#
-# 3. Use the function SETUP_TARGET_FOR_COVERAGE to create a custom make target
-#    which runs your test executable and produces a lcov code coverage report:
-#    Example:
-#	 SETUP_TARGET_FOR_COVERAGE(
-#				my_coverage_target  # Name for custom target.
-#				test_driver         # Name of the test driver executable that runs the tests.
-#									# NOTE! This should always have a ZERO as exit code
-#									# otherwise the coverage generation will not complete.
-#				coverage            # Name of output directory.
-#				)
-#
-# 4. Build a Debug build:
-#	 cmake -DCMAKE_BUILD_TYPE=Debug ..
-#	 make
-#	 make my_coverage_target
-#
-#
-
-
-# Param _targetname     The name of new the custom make target
-# Param _testrunner     The name of the target which runs the tests.
-#						MUST return ZERO always, even on errors.
-#						If not, no coverage report will be created!
-# Param _outputname     lcov output is generated as _outputname.info
-#                       HTML report is generated in _outputname/index.html
-# Optional fourth parameter is passed as arguments to _testrunner
-#   Pass them in list form, e.g.: "-j;2" for -j 2
-FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
-
-    IF (NOT LCOV_PATH)
-        MESSAGE(FATAL_ERROR "lcov not found! Aborting...")
-    ENDIF () # NOT LCOV_PATH
-
-    IF (NOT GENHTML_PATH)
-        MESSAGE(FATAL_ERROR "genhtml not found! Aborting...")
-    ENDIF () # NOT GENHTML_PATH
-
-    # Setup target
-    ADD_CUSTOM_TARGET(${_targetname}
-
-            # Cleanup lcov
-            ${LCOV_PATH} --directory . --zerocounters
-
-            # Run tests
-            COMMAND ${_testrunner} ${ARGV3}
-
-            # Capturing lcov counters and generating report
-            COMMAND ${LCOV_PATH} --directory . --capture --output-file ${_outputname}.info
-
-            COMMAND ${LCOV_PATH} --remove ${_outputname}.info '*/tests/*' '/usr/*' '*/external/*' '/Applications/*' --output-file ${_outputname}.info.cleaned
-            COMMAND ${GENHTML_PATH} -o ${_outputname} ${_outputname}.info.cleaned
-            COMMAND ${LCOV_PATH} --list ${_outputname}.info.cleaned
-
-            WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-            COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
-            )
-
-    # Show info where to find the report
-    ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
-            COMMAND ;
-            COMMENT "${BoldMagenta}Open ./${_outputname}/index.html in your browser to view the coverage report.${ColourReset}"
-            )
-
-ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE
-
-
-string(TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_tolower)
-if (cmake_build_type_tolower STREQUAL "coverage")
-
-
-    # Check prereqs
-    FIND_PROGRAM(GCOV_PATH gcov)
-    FIND_PROGRAM(LCOV_PATH lcov)
-    FIND_PROGRAM(GENHTML_PATH genhtml)
-    FIND_PROGRAM(GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/tests)
-
-    IF (NOT GCOV_PATH)
-        MESSAGE(FATAL_ERROR "gcov not found! Aborting...")
-    ENDIF () # NOT GCOV_PATH
-
-    IF (NOT CMAKE_COMPILER_IS_GNUCXX)
-        IF (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES ".*Clang")
-            MESSAGE(FATAL_ERROR "Compiler is not GNU gcc or Clang! Aborting...")
-        ENDIF ()
-    ENDIF () # NOT CMAKE_COMPILER_IS_GNUCXX
-
-    SET(CMAKE_CXX_FLAGS_COVERAGE
-            "-g -O0 -fprofile-arcs -ftest-coverage"
-            CACHE STRING "Flags used by the C++ compiler during coverage builds."
-            FORCE)
-    SET(CMAKE_C_FLAGS_COVERAGE
-            "-g -O0 -fprofile-arcs -ftest-coverage"
-            CACHE STRING "Flags used by the C compiler during coverage builds."
-            FORCE)
-    SET(CMAKE_EXE_LINKER_FLAGS_COVERAGE
-            ""
-            CACHE STRING "Flags used for linking binaries during coverage builds."
-            FORCE)
-    SET(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
-            ""
-            CACHE STRING "Flags used by the shared libraries linker during coverage builds."
-            FORCE)
-    MARK_AS_ADVANCED(
-            CMAKE_CXX_FLAGS_COVERAGE
-            CMAKE_C_FLAGS_COVERAGE
-            CMAKE_EXE_LINKER_FLAGS_COVERAGE
-            CMAKE_SHARED_LINKER_FLAGS_COVERAGE)
-
-
-    # If unwanted files are included in the coverage reports, you can
-    # adjust the exclude patterns on line 83.
-    SETUP_TARGET_FOR_COVERAGE(
-            coverage            # Name for custom target.
-            ${TEST_NAME}        # Name of the test driver executable that runs the tests.
-            # NOTE! This should always have a ZERO as exit code
-            # otherwise the coverage generation will not complete.
-            coverage_out        # Name of output directory.
-    )
-else ()
-    add_custom_target(coverage
-            COMMAND echo "${Red}Code coverage only available in coverage builds."
-            COMMAND echo "${Green}Make a new build directory and rerun cmake with -DCMAKE_BUILD_TYPE=Coverage to enable this target.${ColorReset}"
-            )
-endif ()
diff --git a/subprojects/quill-4.2.0/quill/cmake/Utility.cmake b/subprojects/quill-4.2.0/quill/cmake/Utility.cmake
deleted file mode 100644
index d6df539..0000000
--- a/subprojects/quill-4.2.0/quill/cmake/Utility.cmake
+++ /dev/null
@@ -1,24 +0,0 @@
-# Get Quill version from include/quill/Version.h and store it as QUILL_VERSION
-function(quill_extract_version)
-    file(READ "${CMAKE_CURRENT_LIST_DIR}/quill/include/quill/Backend.h" file_contents)
-
-    string(REGEX MATCH "constexpr uint32_t VersionMajor{([0-9]+)}" _ "${file_contents}")
-    if (NOT CMAKE_MATCH_COUNT EQUAL 1)
-        message(FATAL_ERROR "Failed to extract major version number from quill/Backend.h")
-    endif ()
-    set(version_major ${CMAKE_MATCH_1})
-
-    string(REGEX MATCH "constexpr uint32_t VersionMinor{([0-9]+)}" _ "${file_contents}")
-    if (NOT CMAKE_MATCH_COUNT EQUAL 1)
-        message(FATAL_ERROR "Failed to extract minor version number from quill/Backend.h")
-    endif ()
-    set(version_minor ${CMAKE_MATCH_1})
-
-    string(REGEX MATCH "constexpr uint32_t VersionPatch{([0-9]+)}" _ "${file_contents}")
-    if (NOT CMAKE_MATCH_COUNT EQUAL 1)
-        message(FATAL_ERROR "Failed to extract patch version number from quill/Backend.h")
-    endif ()
-    set(version_patch ${CMAKE_MATCH_1})
-
-    set(QUILL_VERSION "${version_major}.${version_minor}.${version_patch}" PARENT_SCOPE)
-endfunction()
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/cmake/quill-config.cmake.in b/subprojects/quill-4.2.0/quill/cmake/quill-config.cmake.in
deleted file mode 100644
index 25f8ee5..0000000
--- a/subprojects/quill-4.2.0/quill/cmake/quill-config.cmake.in
+++ /dev/null
@@ -1,6 +0,0 @@
-@PACKAGE_INIT@
-
-find_package(Threads REQUIRED)
-
-include(${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake)
-check_required_components(quill)
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/cmake/quill.pc.in b/subprojects/quill-4.2.0/quill/cmake/quill.pc.in
deleted file mode 100644
index 69646d0..0000000
--- a/subprojects/quill-4.2.0/quill/cmake/quill.pc.in
+++ /dev/null
@@ -1,10 +0,0 @@
-libdir=@CMAKE_INSTALL_FULL_LIBDIR@
-includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
-
-Name: quill
-Description: Low Latency C++ Logging Library
-URL: https://github.com/odygrd/quill
-Version: @QUILL_VERSION@
-CFlags: -I${includedir}
-Libs: -L${libdir} -lquill -lpthread
-Requires: @PKG_CONFIG_REQUIRES@
diff --git a/subprojects/quill-4.2.0/quill/include/quill/Backend.h b/subprojects/quill-4.2.0/quill/include/quill/Backend.h
deleted file mode 100644
index 3f1dffe..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/Backend.h
+++ /dev/null
@@ -1,173 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/backend/BackendManager.h"
-#include "quill/backend/BackendOptions.h"
-#include "quill/backend/SignalHandler.h"
-#include "quill/core/Attributes.h"
-
-#include <atomic>
-#include <csignal>
-#include <cstdint>
-#include <cstdlib>
-#include <initializer_list>
-#include <mutex>
-
-/** Version Info **/
-constexpr uint32_t VersionMajor{4};
-constexpr uint32_t VersionMinor{2};
-constexpr uint32_t VersionPatch{0};
-constexpr uint32_t Version{VersionMajor * 10000 + VersionMinor * 100 + VersionPatch};
-
-namespace quill
-{
-class Backend
-{
-public:
-  /**
-   * Starts the backend thread.
-   * @param options Backend options to configure the backend behavior.
-   */
-  QUILL_ATTRIBUTE_COLD static void start(BackendOptions const& options = BackendOptions{})
-  {
-    std::call_once(detail::BackendManager::instance().get_start_once_flag(),
-                   [options]()
-                   {
-                     // Run the backend worker thread, we wait here until the thread enters the main loop
-                     detail::BackendManager::instance().start_backend_thread(options);
-
-                     // Setup an exit handler to call stop when the main application exits.
-                     // always call stop on destruction to log everything. std::atexit seems to be
-                     // working better with dll on windows compared to using ~LogManagerSingleton().
-                     std::atexit([]() { detail::BackendManager::instance().stop_backend_thread(); });
-                   });
-  }
-
-  /**
-   * Starts the backend thread and initialises a signal handler
-   *
-   * @param options Backend options to configure the backend behavior.
-   * @param catchable_signals List of signals that the backend should catch if with_signal_handler
-   * is enabled.
-   * @param signal_handler_timeout_seconds This variable defines the timeout duration in seconds for
-   * the signal handler alarm. It is only available on Linux, as Windows does not support the alarm
-   * function. The signal handler sets up an alarm to ensure that the process will terminate if it
-   * does not complete within the specified time frame. This is particularly useful to prevent the
-   * process from hanging indefinitely in case the signal handler encounters an issue.
-   *
-   * @note When using the SignalHandler on Linux/MacOS, ensure that each spawned thread in your
-   * application has performed one of the following actions:
-   * i) Logged at least once.
-   * ii) Called Frontend::preallocate().
-   * iii) Blocked signals on that thread to prevent the signal handler from running on it.
-   * This requirement is because the built-in signal handler utilizes a lock-free queue to issue log
-   * statements and await the log flushing. The queue is constructed on its first use with `new()`.
-   * Failing to meet any of the above criteria means the queue was never used, and it will be
-   * constructed inside the signal handler. The `new` operation is not an async signal-safe function
-   * and may lead to potential issues. However, when the queue is already created, no `new` call is
-   * made, and the remaining functions invoked internally by the built-in signal handler are async
-   * safe.
-   */
-  template <typename TFrontendOptions>
-  QUILL_ATTRIBUTE_COLD static void start_with_signal_handler(
-    BackendOptions const& options = BackendOptions{},
-    QUILL_MAYBE_UNUSED std::initializer_list<int> const& catchable_signals =
-      std::initializer_list<int>{SIGTERM, SIGINT, SIGABRT, SIGFPE, SIGILL, SIGSEGV},
-    uint32_t signal_handler_timeout_seconds = 20u)
-  {
-    std::call_once(detail::BackendManager::instance().get_start_once_flag(),
-                   [options, catchable_signals, signal_handler_timeout_seconds]()
-                   {
-#if defined(_WIN32)
-                     (void)catchable_signals;
-                     detail::init_exception_handler<TFrontendOptions>();
-#else
-        // We do not want signal handler to run in the backend worker thread
-        // Block signals in the main thread so when we spawn the backend worker thread it inherits
-        // the master
-        sigset_t set, oldset;
-        sigfillset(&set);
-        sigprocmask(SIG_SETMASK, &set, &oldset);
-        detail::init_signal_handler<TFrontendOptions>(catchable_signals);
-#endif
-
-                     // Run the backend worker thread, we wait here until the thread enters the main loop
-                     detail::BackendManager::instance().start_backend_thread(options);
-
-                     detail::SignalHandlerContext::instance().signal_handler_timeout_seconds.store(
-                       signal_handler_timeout_seconds);
-
-                     // We need to update the signal handler with some backend thread details
-                     detail::SignalHandlerContext::instance().backend_thread_id.store(
-                       detail::BackendManager::instance().get_backend_thread_id());
-
-#if defined(_WIN32)
-      // nothing to do
-#else
-        // Unblock signals in the main thread so subsequent threads do not inherit the blocked mask
-        sigprocmask(SIG_SETMASK, &oldset, nullptr);
-#endif
-
-                     // Set up an exit handler to call stop when the main application exits.
-                     // always call stop on destruction to log everything. std::atexit seems to be
-                     // working better with dll on windows compared to using ~LogManagerSingleton().
-                     std::atexit([]() { detail::BackendManager::instance().stop_backend_thread(); });
-                   });
-  }
-
-  /**
-   * Stops the backend thread.
-   * @note thread-safe
-   */
-  QUILL_ATTRIBUTE_COLD static void stop() noexcept
-  {
-    detail::BackendManager::instance().stop_backend_thread();
-  }
-
-  /**
-   * Notifies the backend thread to wake up.
-   * It is possible to use a long backend sleep_duration and then notify the backend to wake up
-   * from any frontend thread.
-   *
-   * @note thread-safe
-   */
-  static void notify() noexcept { detail::BackendManager::instance().notify_backend_thread(); }
-
-  /**
-   * Checks if the backend is currently running.
-   * @return True if the backend is running, false otherwise.
-   */
-  QUILL_NODISCARD static bool is_running() noexcept
-  {
-    return detail::BackendManager::instance().is_backend_thread_running();
-  }
-
-  /**
-   * Retrieves the ID of the backend thread.
-   * @return The ID of the backend thread.
-   */
-  QUILL_NODISCARD static uint32_t get_thread_id() noexcept
-  {
-    return detail::BackendManager::instance().get_backend_thread_id();
-  }
-
-  /**
-   * Converts an rdtsc value to epoch time.
-   * This function uses the same clock as the backend and can be called from any frontend thread.
-   * It is useful when using a logger with ClockSourceType::Tsc and you want to obtain a timestamp
-   * synchronized with the log files generated by the backend.
-   *
-   * Alternatively you can use the Clock class from backend/Clock.h
-   * @param rdtsc_value The RDTSC value to convert.
-   * @return The epoch time corresponding to the RDTSC value.
-   */
-  QUILL_NODISCARD static uint64_t convert_rdtsc_to_epoch_time(uint64_t rdtsc_value) noexcept
-  {
-    return detail::BackendManager::instance().convert_rdtsc_to_epoch_time(rdtsc_value);
-  }
-};
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/BackendTscClock.h b/subprojects/quill-4.2.0/quill/include/quill/BackendTscClock.h
deleted file mode 100644
index a213297..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/BackendTscClock.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/backend/BackendManager.h"
-#include "quill/core/Attributes.h"
-#include "quill/core/Rdtsc.h"
-
-#include <chrono>
-#include <cstdint>
-
-namespace quill
-{
-/**
- * @brief A utility class for accessing the Time Stamp Counter (TSC) clock used by the backend logging thread.
- *
- * This class provides access to the TSC clock maintained by the backend logging thread,
- * allowing for synchronized timestamp retrieval.
- *
- * Other threads can obtain timestamps synchronized with the TSC clock of the backend logging
- * thread, ensuring synchronization with log statement timestamps.
- *
- * If `ClockSourceType::Tsc` is not used by any Logger, this class reverts to using the system clock
- * for providing a timestamp.
- *
- * @note For more accurate timestamps, consider reducing `rdtsc_resync_interval` in `BackendOptions`.
- * @note All methods of the class are thread-safe.
- */
-class BackendTscClock
-{
-public:
-  class RdtscVal
-  {
-  public:
-    RdtscVal(RdtscVal const& other) = default;
-    RdtscVal(RdtscVal&& other) noexcept = default;
-    RdtscVal& operator=(RdtscVal const& other) = default;
-    RdtscVal& operator=(RdtscVal&& other) noexcept = default;
-
-    QUILL_NODISCARD QUILL_ATTRIBUTE_HOT uint64_t value() const noexcept { return _value; }
-
-  private:
-    RdtscVal() noexcept : _value(detail::rdtsc()) {}
-    friend BackendTscClock;
-
-    uint64_t _value;
-  };
-
-public:
-  using duration = std::chrono::nanoseconds;
-  using rep = duration::rep;
-  using period = duration::period;
-  using time_point = std::chrono::time_point<BackendTscClock, duration>;
-  static constexpr bool is_steady = false;
-
-  /**
-   * Provides the current synchronized timestamp obtained using the TSC clock maintained by the backend logging thread.
-   * @return A wall clock timestamp in nanoseconds since epoch, synchronized with the backend logging thread's TSC clock.
-   */
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT static time_point now() noexcept
-  {
-    uint64_t const ts = detail::BackendManager::instance().convert_rdtsc_to_epoch_time(detail::rdtsc());
-
-    return ts ? time_point{std::chrono::nanoseconds{ts}}
-              : time_point{std::chrono::nanoseconds{
-                  std::chrono::time_point_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now())
-                    .time_since_epoch()
-                    .count()}};
-  }
-
-  /**
-   * Returns the current value of the TSC timer maintained by the backend logging thread.
-   * @return The current value of the TSC timer.
-   */
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT static RdtscVal rdtsc() noexcept { return RdtscVal{}; }
-
-  /**
-   * Converts a TSC counter value obtained from the backend logging thread's TSC timer to a wall
-   * clock timestamp.
-   *
-   * @param rdtsc The TSC counter value obtained from the backend logging thread's TSC timer.
-   * @warning This function will return `0` when TimestampClockType::Tsc is not enabled in Config.h.
-   * @return Time since epoch in nanoseconds.
-   */
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT static time_point to_time_point(RdtscVal rdtsc) noexcept
-  {
-    return time_point{std::chrono::nanoseconds{
-      detail::BackendManager::instance().convert_rdtsc_to_epoch_time(rdtsc.value())}};
-  }
-};
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/Frontend.h b/subprojects/quill-4.2.0/quill/include/quill/Frontend.h
deleted file mode 100644
index 3dd98a2..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/Frontend.h
+++ /dev/null
@@ -1,211 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/Logger.h"
-#include "quill/UserClockSource.h"
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/FrontendOptions.h"
-#include "quill/core/LoggerManager.h"
-#include "quill/core/QuillError.h"
-#include "quill/core/SinkManager.h"
-#include "quill/core/ThreadContextManager.h"
-#include "quill/sinks/Sink.h"
-
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <initializer_list>
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace quill
-{
-template <typename TFrontendOptions>
-class FrontendImpl
-{
-public:
-  using frontend_options_t = TFrontendOptions;
-  using logger_t = LoggerImpl<frontend_options_t>;
-
-  /**
-   * @brief Pre-allocates the thread-local data needed for the current thread.
-   *
-   * Although optional, it is recommended to invoke this function during the thread initialization
-   * phase before the first log message.
-   */
-  QUILL_ATTRIBUTE_COLD static void preallocate()
-  {
-    QUILL_MAYBE_UNUSED uint32_t const volatile spsc_queue_capacity =
-      detail::get_local_thread_context<TFrontendOptions>()
-        ->template get_spsc_queue<TFrontendOptions::queue_type>()
-        .capacity();
-  }
-
-  /**
-   * @brief Creates a new sink or retrieves an existing one with the specified name.
-   *
-   * @param sink_name The name of the sink.
-   * @param args The arguments to pass to the sink constructor.
-   * @return std::shared_ptr<Sink> A shared pointer to the created or retrieved sink.
-   */
-  template <typename TSink, typename... Args>
-  static std::shared_ptr<Sink> create_or_get_sink(std::string const& sink_name, Args&&... args)
-  {
-    return detail::SinkManager::instance().create_or_get_sink<TSink>(sink_name, static_cast<Args&&>(args)...);
-  }
-
-  /**
-   * @brief Retrieves an existing sink with the specified name.
-   *
-   * @param sink_name The name of the sink.
-   * @return std::shared_ptr<Sink> A shared pointer to the retrieved sink, or nullptr if not found.
-   */
-  QUILL_NODISCARD static std::shared_ptr<Sink> get_sink(std::string const& sink_name)
-  {
-    return detail::SinkManager::instance().get_sink(sink_name);
-  }
-
-  /**
-   * @brief Creates a new logger or retrieves an existing one with the specified name.
-   *
-   * @param logger_name The name of the logger.
-   * @param sink A shared pointer to the sink to associate with the logger.
-   * @param format_pattern The format pattern for log messages.
-   * @param time_pattern The time pattern for log timestamps.
-   * @param timestamp_timezone The timezone for log timestamps.
-   * @param clock_source The clock source for log timestamps.
-   * @param user_clock A pointer to a custom user clock.
-   * @return Logger* A pointer to the created or retrieved logger.
-   */
-  static logger_t* create_or_get_logger(
-    std::string const& logger_name, std::shared_ptr<Sink> sink,
-    std::string const& format_pattern =
-      "%(time) [%(thread_id)] %(short_source_location:<28) LOG_%(log_level:<9) %(logger:<12) "
-      "%(message)",
-    std::string const& time_pattern = "%H:%M:%S.%Qns", Timezone timestamp_timezone = Timezone::LocalTime,
-    ClockSourceType clock_source = ClockSourceType::Tsc, UserClockSource* user_clock = nullptr)
-  {
-    std::vector<std::shared_ptr<Sink>> sinks;
-    sinks.push_back(static_cast<std::shared_ptr<Sink>&&>(sink));
-
-    return _cast_to_logger(detail::LoggerManager::instance().create_or_get_logger<logger_t>(
-      logger_name, static_cast<std::vector<std::shared_ptr<Sink>>&&>(sinks), format_pattern,
-      time_pattern, timestamp_timezone, clock_source, user_clock));
-  }
-
-  /**
-   * @brief Creates a new logger or retrieves an existing one with the specified name and multiple sinks.
-   *
-   * @param logger_name The name of the logger.
-   * @param sinks An initializer list of shared pointers to sinks to associate with the logger.
-   * @param format_pattern The format pattern for log messages.
-   * @param time_pattern The time pattern for log timestamps.
-   * @param timestamp_timezone The timezone for log timestamps.
-   * @param clock_source The clock source for log timestamps.
-   * @param user_clock A pointer to a custom user clock.
-   * @return Logger* A pointer to the created or retrieved logger.
-   */
-  static logger_t* create_or_get_logger(
-    std::string const& logger_name, std::initializer_list<std::shared_ptr<Sink>> sinks,
-    std::string const& format_pattern =
-      "%(time) [%(thread_id)] %(short_source_location:<28) LOG_%(log_level:<9) %(logger:<12) "
-      "%(message)",
-    std::string const& time_pattern = "%H:%M:%S.%Qns", Timezone timestamp_timezone = Timezone::LocalTime,
-    ClockSourceType clock_source = ClockSourceType::Tsc, UserClockSource* user_clock = nullptr)
-  {
-    return _cast_to_logger(detail::LoggerManager::instance().create_or_get_logger<logger_t>(
-      logger_name, std::vector<std::shared_ptr<Sink>>{sinks}, format_pattern, time_pattern,
-      timestamp_timezone, clock_source, user_clock));
-  }
-
-  /**
-   * @brief Asynchronously removes the specified logger.
-   * When a logger is removed, any files associated with its sinks are also closed.
-   *
-   * @note Thread-safe
-   * @param logger A pointer to the logger to remove.
-   */
-  static void remove_logger(detail::LoggerBase* logger)
-  {
-    detail::LoggerManager::instance().remove_logger(logger);
-  }
-
-  /**
-   * @brief Retrieves an existing logger with the specified name.
-   *
-   * @param logger_name The name of the logger.
-   * @return Logger* A pointer to the retrieved logger, or nullptr if not found.
-   */
-  QUILL_NODISCARD static logger_t* get_logger(std::string const& logger_name)
-  {
-    detail::LoggerBase* logger = detail::LoggerManager::instance().get_logger(logger_name);
-    return logger ? _cast_to_logger(logger) : nullptr;
-  }
-
-  /**
-   * @brief Retrieves a map of all registered valid loggers.
-   * @note If `remove_logger()` is called from this or another thread, the return value
-   *       of this function will become invalid.
-   * @return A vector containing all registered loggers.
-   */
-  QUILL_NODISCARD static std::vector<logger_t*> get_all_loggers()
-  {
-    std::vector<detail::LoggerBase*> logger_bases = detail::LoggerManager::instance().get_all_loggers();
-
-    std::vector<logger_t*> loggers;
-
-    for (auto const& logger_base : logger_bases)
-    {
-      loggers.push_back(_cast_to_logger(logger_base));
-    }
-
-    return loggers;
-  }
-
-  /**
-   * Returns the first valid logger that is found. This is useful when you do not want to use the
-   * std::vector<logger_t*> return value of get_all_loggers.
-   *
-   * @return A pointer to the first valid logger, or nullptr if no valid logger is found.
-   */
-  QUILL_NODISCARD static logger_t* get_valid_logger() noexcept
-  {
-    detail::LoggerBase* logger = detail::LoggerManager::instance().get_valid_logger();
-    return logger ? _cast_to_logger(logger) : nullptr;
-  }
-
-  /**
-   * @brief Counts the number of existing loggers, including any invalidated loggers.
-   * This function can be useful for verifying if a logger has been removed after calling
-   * remove_logger() by the backend, as removal occurs asynchronously.
-   * @return The number of loggers.
-   */
-  QUILL_NODISCARD static size_t get_number_of_loggers() noexcept
-  {
-    return detail::LoggerManager::instance().get_number_of_loggers();
-  }
-
-private:
-  QUILL_NODISCARD static logger_t* _cast_to_logger(detail::LoggerBase* logger_base)
-  {
-    assert(logger_base);
-
-    auto* logger = dynamic_cast<logger_t*>(logger_base);
-
-    if (QUILL_UNLIKELY(!logger))
-    {
-      QUILL_THROW(QuillError{"Failed to cast logger. Invalid logger type."});
-    }
-
-    return logger;
-  }
-};
-
-using Frontend = FrontendImpl<FrontendOptions>;
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/LogMacros.h b/subprojects/quill-4.2.0/quill/include/quill/LogMacros.h
deleted file mode 100644
index d2e3836..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/LogMacros.h
+++ /dev/null
@@ -1,284 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/LogLevel.h"
-#include "quill/core/MacroMetadata.h"
-
-/**
- * Allows compile-time filtering of log messages to completely compile out log levels,
- * resulting in zero-cost logging.
- *
- * Macros like LOG_TRACE_L3(..), LOG_TRACE_L2(..) will expand to empty statements,
- * reducing branches in compiled code and the number of MacroMetadata constexpr instances.
- *
- * The default value of -1 enables all log levels.
- * Specify a logging level to disable all levels equal to or higher than the specified level.
- *
- * For example to only log warnings and above you can use:
- *   add_compile_definitions(-DQUILL_COMPILE_ACTIVE_LOG_LEVEL=QUILL_COMPILE_ACTIVE_LOG_LEVEL_WARNING)
- * or
- *   target_compile_definitions(${TARGET} PRIVATE -DQUILL_COMPILE_ACTIVE_LOG_LEVEL=QUILL_COMPILE_ACTIVE_LOG_LEVEL_WARNING)
- **/
-#define QUILL_COMPILE_ACTIVE_LOG_LEVEL_TRACE_L3 0
-#define QUILL_COMPILE_ACTIVE_LOG_LEVEL_TRACE_L2 1
-#define QUILL_COMPILE_ACTIVE_LOG_LEVEL_TRACE_L1 2
-#define QUILL_COMPILE_ACTIVE_LOG_LEVEL_DEBUG 3
-#define QUILL_COMPILE_ACTIVE_LOG_LEVEL_INFO 4
-#define QUILL_COMPILE_ACTIVE_LOG_LEVEL_WARNING 5
-#define QUILL_COMPILE_ACTIVE_LOG_LEVEL_ERROR 6
-#define QUILL_COMPILE_ACTIVE_LOG_LEVEL_CRITICAL 7
-
-#if !defined(QUILL_COMPILE_ACTIVE_LOG_LEVEL)
-  #define QUILL_COMPILE_ACTIVE_LOG_LEVEL -1
-#endif
-
-#define QUILL_DEFINE_MACRO_METADATA(caller_function, fmt, tags, log_level)                         \
-  static constexpr quill::MacroMetadata macro_metadata                                             \
-  {                                                                                                \
-    __FILE__ ":" QUILL_STRINGIFY(__LINE__), caller_function, fmt, tags, log_level,                 \
-      quill::MacroMetadata::Event::Log                                                             \
-  }
-
-#define QUILL_LOGGER_CALL(likelyhood, logger, log_level, fmt, ...)                                 \
-  do                                                                                               \
-  {                                                                                                \
-    if (likelyhood(logger->template should_log_message<log_level>()))                              \
-    {                                                                                              \
-      QUILL_DEFINE_MACRO_METADATA(__FUNCTION__, fmt, nullptr, log_level);                          \
-                                                                                                   \
-      logger->log_message(quill::LogLevel::None, &macro_metadata, ##__VA_ARGS__);                  \
-    }                                                                                              \
-  } while (0)
-
-#define QUILL_LOGGER_CALL_WITH_TAGS(likelyhood, logger, log_level, tags, fmt, ...)                 \
-  do                                                                                               \
-  {                                                                                                \
-    if (likelyhood(logger->template should_log_message<log_level>()))                              \
-    {                                                                                              \
-      QUILL_DEFINE_MACRO_METADATA(__FUNCTION__, fmt, &tags, log_level);                            \
-                                                                                                   \
-      logger->log_message(quill::LogLevel::None, &macro_metadata, ##__VA_ARGS__);                  \
-    }                                                                                              \
-  } while (0)
-
-#define QUILL_LOGGER_CALL_LIMIT(min_interval, likelyhood, logger, log_level, fmt, ...)             \
-  do                                                                                               \
-  {                                                                                                \
-    if (likelyhood(logger->template should_log_message<log_level>()))                              \
-    {                                                                                              \
-      thread_local std::chrono::time_point<std::chrono::steady_clock> next_log_time;               \
-      auto const now = std::chrono::steady_clock::now();                                           \
-                                                                                                   \
-      if (now < next_log_time)                                                                     \
-      {                                                                                            \
-        break;                                                                                     \
-      }                                                                                            \
-                                                                                                   \
-      next_log_time = now + min_interval;                                                          \
-      QUILL_LOGGER_CALL(likelyhood, logger, log_level, fmt, ##__VA_ARGS__);                        \
-    }                                                                                              \
-  } while (0)
-
-#define QUILL_BACKTRACE_LOGGER_CALL(logger, fmt, ...)                                              \
-  do                                                                                               \
-  {                                                                                                \
-    if (QUILL_LIKELY(logger->template should_log_message<quill::LogLevel::Backtrace>()))           \
-    {                                                                                              \
-      QUILL_DEFINE_MACRO_METADATA(__FUNCTION__, fmt, nullptr, quill::LogLevel::Backtrace);         \
-                                                                                                   \
-      logger->log_message(quill::LogLevel::None, &macro_metadata, ##__VA_ARGS__);                  \
-    }                                                                                              \
-  } while (0)
-
-/**
- * Dynamic runtime log level with a tiny overhead
- * @Note: Prefer using the compile time log level macros
- */
-#define QUILL_DYNAMIC_LOG_CALL(logger, log_level, fmt, ...)                                        \
-  do                                                                                               \
-  {                                                                                                \
-    if (logger->should_log_message(log_level))                                                     \
-    {                                                                                              \
-      QUILL_DEFINE_MACRO_METADATA(__FUNCTION__, fmt, nullptr, quill::LogLevel::Dynamic);           \
-                                                                                                   \
-      logger->log_message(log_level, &macro_metadata, ##__VA_ARGS__);                              \
-    }                                                                                              \
-  } while (0)
-
-#define QUILL_DYNAMIC_LOG(logger, log_level, fmt, ...)                                             \
-  QUILL_DYNAMIC_LOG_CALL(logger, log_level, fmt, ##__VA_ARGS__)
-
-#if QUILL_COMPILE_ACTIVE_LOG_LEVEL <= QUILL_COMPILE_ACTIVE_LOG_LEVEL_TRACE_L3
-  #define QUILL_LOG_TRACE_L3(logger, fmt, ...)                                                     \
-    QUILL_LOGGER_CALL(QUILL_UNLIKELY, logger, quill::LogLevel::TraceL3, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_TRACE_L3_LIMIT(min_interval, logger, fmt, ...)                                 \
-    QUILL_LOGGER_CALL_LIMIT(min_interval, QUILL_UNLIKELY, logger, quill::LogLevel::TraceL3, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_TRACE_L3_WITH_TAGS(logger, tags, fmt, ...)                                     \
-    QUILL_LOGGER_CALL_WITH_TAGS(QUILL_UNLIKELY, logger, quill::LogLevel::TraceL3, tags, fmt, ##__VA_ARGS__)
-#else
-  #define QUILL_LOG_TRACE_L3(logger, fmt, ...) (void)0
-  #define QUILL_LOG_TRACE_L3_LIMIT(min_interval, logger, fmt, ...) (void)0
-  #define QUILL_LOG_TRACE_L3_WITH_TAGS(logger, tags, fmt, ...) (void)0
-#endif
-
-#if QUILL_COMPILE_ACTIVE_LOG_LEVEL <= QUILL_COMPILE_ACTIVE_LOG_LEVEL_TRACE_L2
-  #define QUILL_LOG_TRACE_L2(logger, fmt, ...)                                                     \
-    QUILL_LOGGER_CALL(QUILL_UNLIKELY, logger, quill::LogLevel::TraceL2, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_TRACE_L2_LIMIT(min_interval, logger, fmt, ...)                                 \
-    QUILL_LOGGER_CALL_LIMIT(min_interval, QUILL_UNLIKELY, logger, quill::LogLevel::TraceL2, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_TRACE_L2_WITH_TAGS(logger, tags, fmt, ...)                                     \
-    QUILL_LOGGER_CALL_WITH_TAGS(QUILL_UNLIKELY, logger, quill::LogLevel::TraceL2, tags, fmt, ##__VA_ARGS__)
-#else
-  #define QUILL_LOG_TRACE_L2(logger, fmt, ...) (void)0
-  #define QUILL_LOG_TRACE_L2_LIMIT(min_interval, logger, fmt, ...) (void)0
-  #define QUILL_LOG_TRACE_L2_WITH_TAGS(logger, tags, fmt, ...) (void)0
-#endif
-
-#if QUILL_COMPILE_ACTIVE_LOG_LEVEL <= QUILL_COMPILE_ACTIVE_LOG_LEVEL_TRACE_L1
-  #define QUILL_LOG_TRACE_L1(logger, fmt, ...)                                                     \
-    QUILL_LOGGER_CALL(QUILL_UNLIKELY, logger, quill::LogLevel::TraceL1, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_TRACE_L1_LIMIT(min_interval, logger, fmt, ...)                                 \
-    QUILL_LOGGER_CALL_LIMIT(min_interval, QUILL_UNLIKELY, logger, quill::LogLevel::TraceL1, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_TRACE_L1_WITH_TAGS(logger, tags, fmt, ...)                                     \
-    QUILL_LOGGER_CALL_WITH_TAGS(QUILL_UNLIKELY, logger, quill::LogLevel::TraceL1, tags, fmt, ##__VA_ARGS__)
-#else
-  #define QUILL_LOG_TRACE_L1(logger, fmt, ...) (void)0
-  #define QUILL_LOG_TRACE_L1_LIMIT(min_interval, logger, fmt, ...) (void)0
-  #define QUILL_LOG_TRACE_L1_WITH_TAGS(logger, tags, fmt, ...) (void)0
-#endif
-
-#if QUILL_COMPILE_ACTIVE_LOG_LEVEL <= QUILL_COMPILE_ACTIVE_LOG_LEVEL_DEBUG
-  #define QUILL_LOG_DEBUG(logger, fmt, ...)                                                        \
-    QUILL_LOGGER_CALL(QUILL_UNLIKELY, logger, quill::LogLevel::Debug, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_DEBUG_LIMIT(min_interval, logger, fmt, ...)                                    \
-    QUILL_LOGGER_CALL_LIMIT(min_interval, QUILL_UNLIKELY, logger, quill::LogLevel::Debug, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_DEBUG_WITH_TAGS(logger, tags, fmt, ...)                                        \
-    QUILL_LOGGER_CALL_WITH_TAGS(QUILL_UNLIKELY, logger, quill::LogLevel::Debug, tags, fmt, ##__VA_ARGS__)
-#else
-  #define QUILL_LOG_DEBUG(logger, fmt, ...) (void)0
-  #define QUILL_LOG_DEBUG_LIMIT(min_interval, logger, fmt, ...) (void)0
-  #define QUILL_LOG_DEBUG_WITH_TAGS(logger, tags, fmt, ...) (void)0
-#endif
-
-#if QUILL_COMPILE_ACTIVE_LOG_LEVEL <= QUILL_COMPILE_ACTIVE_LOG_LEVEL_INFO
-  #define QUILL_LOG_INFO(logger, fmt, ...)                                                         \
-    QUILL_LOGGER_CALL(QUILL_LIKELY, logger, quill::LogLevel::Info, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_INFO_LIMIT(min_interval, logger, fmt, ...)                                     \
-    QUILL_LOGGER_CALL_LIMIT(min_interval, QUILL_LIKELY, logger, quill::LogLevel::Info, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_INFO_WITH_TAGS(logger, tags, fmt, ...)                                         \
-    QUILL_LOGGER_CALL_WITH_TAGS(QUILL_LIKELY, logger, quill::LogLevel::Info, tags, fmt, ##__VA_ARGS__)
-#else
-  #define QUILL_LOG_INFO(logger, fmt, ...) (void)0
-  #define QUILL_LOG_INFO_LIMIT(min_interval, logger, fmt, ...) (void)0
-  #define QUILL_LOG_INFO_WITH_TAGS(logger, tags, fmt, ...) (void)0
-#endif
-
-#if QUILL_COMPILE_ACTIVE_LOG_LEVEL <= QUILL_COMPILE_ACTIVE_LOG_LEVEL_WARNING
-  #define QUILL_LOG_WARNING(logger, fmt, ...)                                                      \
-    QUILL_LOGGER_CALL(QUILL_LIKELY, logger, quill::LogLevel::Warning, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_WARNING_LIMIT(min_interval, logger, fmt, ...)                                  \
-    QUILL_LOGGER_CALL_LIMIT(min_interval, QUILL_LIKELY, logger, quill::LogLevel::Warning, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_WARNING_WITH_TAGS(logger, tags, fmt, ...)                                      \
-    QUILL_LOGGER_CALL_WITH_TAGS(QUILL_LIKELY, logger, quill::LogLevel::Warning, tags, fmt, ##__VA_ARGS__)
-#else
-  #define QUILL_LOG_WARNING(logger, fmt, ...) (void)0
-  #define QUILL_LOG_WARNING_LIMIT(min_interval, logger, fmt, ...) (void)0
-  #define QUILL_LOG_WARNING_WITH_TAGS(logger, tags, fmt, ...) (void)0
-#endif
-
-#if QUILL_COMPILE_ACTIVE_LOG_LEVEL <= QUILL_COMPILE_ACTIVE_LOG_LEVEL_ERROR
-  #define QUILL_LOG_ERROR(logger, fmt, ...)                                                        \
-    QUILL_LOGGER_CALL(QUILL_LIKELY, logger, quill::LogLevel::Error, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_ERROR_LIMIT(min_interval, logger, fmt, ...)                                    \
-    QUILL_LOGGER_CALL_LIMIT(min_interval, QUILL_LIKELY, logger, quill::LogLevel::Error, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_ERROR_WITH_TAGS(logger, tags, fmt, ...)                                        \
-    QUILL_LOGGER_CALL_WITH_TAGS(QUILL_LIKELY, logger, quill::LogLevel::Error, tags, fmt, ##__VA_ARGS__)
-#else
-  #define QUILL_LOG_ERROR(logger, fmt, ...) (void)0
-  #define QUILL_LOG_ERROR_LIMIT(min_interval, logger, fmt, ...) (void)0
-  #define QUILL_LOG_ERROR_WITH_TAGS(logger, tags, fmt, ...) (void)0
-#endif
-
-#if QUILL_COMPILE_ACTIVE_LOG_LEVEL <= QUILL_COMPILE_ACTIVE_LOG_LEVEL_CRITICAL
-  #define QUILL_LOG_CRITICAL(logger, fmt, ...)                                                     \
-    QUILL_LOGGER_CALL(QUILL_LIKELY, logger, quill::LogLevel::Critical, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_CRITICAL_LIMIT(min_interval, logger, fmt, ...)                                 \
-    QUILL_LOGGER_CALL_LIMIT(min_interval, QUILL_LIKELY, logger, quill::LogLevel::Critical, fmt, ##__VA_ARGS__)
-
-  #define QUILL_LOG_CRITICAL_WITH_TAGS(logger, tags, fmt, ...)                                     \
-    QUILL_LOGGER_CALL_WITH_TAGS(QUILL_LIKELY, logger, quill::LogLevel::Critical, tags, fmt, ##__VA_ARGS__)
-#else
-  #define QUILL_LOG_CRITICAL(logger, fmt, ...) (void)0
-  #define QUILL_LOG_CRITICAL_LIMIT(min_interval, logger, fmt, ...) (void)0
-  #define QUILL_LOG_CRITICAL_WITH_TAGS(logger, tags, fmt, ...) (void)0
-#endif
-
-#define QUILL_LOG_BACKTRACE(logger, fmt, ...)                                                      \
-  QUILL_BACKTRACE_LOGGER_CALL(logger, fmt, ##__VA_ARGS__)
-
-#if !defined(QUILL_DISABLE_NON_PREFIXED_MACROS)
-  #define LOG_TRACE_L3(logger, fmt, ...) QUILL_LOG_TRACE_L3(logger, fmt, ##__VA_ARGS__)
-  #define LOG_TRACE_L2(logger, fmt, ...) QUILL_LOG_TRACE_L2(logger, fmt, ##__VA_ARGS__)
-  #define LOG_TRACE_L1(logger, fmt, ...) QUILL_LOG_TRACE_L1(logger, fmt, ##__VA_ARGS__)
-  #define LOG_DEBUG(logger, fmt, ...) QUILL_LOG_DEBUG(logger, fmt, ##__VA_ARGS__)
-  #define LOG_INFO(logger, fmt, ...) QUILL_LOG_INFO(logger, fmt, ##__VA_ARGS__)
-  #define LOG_WARNING(logger, fmt, ...) QUILL_LOG_WARNING(logger, fmt, ##__VA_ARGS__)
-  #define LOG_ERROR(logger, fmt, ...) QUILL_LOG_ERROR(logger, fmt, ##__VA_ARGS__)
-  #define LOG_CRITICAL(logger, fmt, ...) QUILL_LOG_CRITICAL(logger, fmt, ##__VA_ARGS__)
-  #define LOG_BACKTRACE(logger, fmt, ...) QUILL_LOG_BACKTRACE(logger, fmt, ##__VA_ARGS__)
-  #define LOG_DYNAMIC(logger, log_level, fmt, ...)                                                 \
-    QUILL_DYNAMIC_LOG(logger, log_level, fmt, ##__VA_ARGS__)
-
-  #define LOG_TRACE_L3_LIMIT(min_interval, logger, fmt, ...)                                       \
-    QUILL_LOG_TRACE_L3_LIMIT(min_interval, logger, fmt, ##__VA_ARGS__)
-  #define LOG_TRACE_L2_LIMIT(min_interval, logger, fmt, ...)                                       \
-    QUILL_LOG_TRACE_L2_LIMIT(min_interval, logger, fmt, ##__VA_ARGS__)
-  #define LOG_TRACE_L1_LIMIT(min_interval, logger, fmt, ...)                                       \
-    QUILL_LOG_TRACE_L1_LIMIT(min_interval, logger, fmt, ##__VA_ARGS__)
-  #define LOG_DEBUG_LIMIT(min_interval, logger, fmt, ...)                                          \
-    QUILL_LOG_DEBUG_LIMIT(min_interval, logger, fmt, ##__VA_ARGS__)
-  #define LOG_INFO_LIMIT(min_interval, logger, fmt, ...)                                           \
-    QUILL_LOG_INFO_LIMIT(min_interval, logger, fmt, ##__VA_ARGS__)
-  #define LOG_WARNING_LIMIT(min_interval, logger, fmt, ...)                                        \
-    QUILL_LOG_WARNING_LIMIT(min_interval, logger, fmt, ##__VA_ARGS__)
-  #define LOG_ERROR_LIMIT(min_interval, logger, fmt, ...)                                          \
-    QUILL_LOG_ERROR_LIMIT(min_interval, logger, fmt, ##__VA_ARGS__)
-  #define LOG_CRITICAL_LIMIT(min_interval, logger, fmt, ...)                                       \
-    QUILL_LOG_CRITICAL_LIMIT(min_interval, logger, fmt, ##__VA_ARGS__)
-
-  #define LOG_TRACE_L3_WITH_TAGS(logger, tags, fmt, ...)                                           \
-    QUILL_LOG_TRACE_L3_WITH_TAGS(logger, tags, fmt, ##__VA_ARGS__)
-  #define LOG_TRACE_L2_WITH_TAGS(logger, tags, fmt, ...)                                           \
-    QUILL_LOG_TRACE_L2_WITH_TAGS(logger, tags, fmt, ##__VA_ARGS__)
-  #define LOG_TRACE_L1_WITH_TAGS(logger, tags, fmt, ...)                                           \
-    QUILL_LOG_TRACE_L1_WITH_TAGS(logger, tags, fmt, ##__VA_ARGS__)
-  #define LOG_DEBUG_WITH_TAGS(logger, tags, fmt, ...)                                              \
-    QUILL_LOG_DEBUG_WITH_TAGS(logger, tags, fmt, ##__VA_ARGS__)
-  #define LOG_INFO_WITH_TAGS(logger, tags, fmt, ...)                                               \
-    QUILL_LOG_INFO_WITH_TAGS(logger, tags, fmt, ##__VA_ARGS__)
-  #define LOG_WARNING_WITH_TAGS(logger, tags, fmt, ...)                                            \
-    QUILL_LOG_WARNING_WITH_TAGS(logger, tags, fmt, ##__VA_ARGS__)
-  #define LOG_ERROR_WITH_TAGS(logger, tags, fmt, ...)                                              \
-    QUILL_LOG_ERROR_WITH_TAGS(logger, tags, fmt, ##__VA_ARGS__)
-  #define LOG_CRITICAL_WITH_TAGS(logger, tags, fmt, ...)                                           \
-    QUILL_LOG_CRITICAL_WITH_TAGS(logger, tags, fmt, ##__VA_ARGS__)
-#endif
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/Logger.h b/subprojects/quill-4.2.0/quill/include/quill/Logger.h
deleted file mode 100644
index f59b3e1..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/Logger.h
+++ /dev/null
@@ -1,320 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/UserClockSource.h"
-#include "quill/core/Attributes.h"
-#include "quill/core/Codec.h"
-#include "quill/core/Common.h"
-#include "quill/core/FrontendOptions.h"
-#include "quill/core/LogLevel.h"
-#include "quill/core/LoggerBase.h"
-#include "quill/core/MacroMetadata.h"
-#include "quill/core/Rdtsc.h"
-#include "quill/core/ThreadContextManager.h"
-
-#include <atomic>
-#include <cassert>
-#include <chrono>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <memory>
-#include <string>
-#include <thread>
-#include <vector>
-
-namespace quill
-{
-
-/** Forward Declarations **/
-class Sink;
-
-namespace detail
-{
-class LoggerManager;
-class BackendWorker;
-} // namespace detail
-
-/**
- * @brief Thread safe logger.
- *
- * Logger must be obtained from create_or_get_logger(), therefore constructors are private
- */
-template <typename TFrontendOptions>
-class LoggerImpl : public detail::LoggerBase
-{
-public:
-  using frontend_options_t = TFrontendOptions;
-
-  /***/
-  LoggerImpl(LoggerImpl const&) = delete;
-  LoggerImpl& operator=(LoggerImpl const&) = delete;
-
-  ~LoggerImpl() override = default;
-
-  /**
-   * Push a log message to the spsc queue to be logged by the backend thread.
-   * One spsc queue per caller thread. This function is enabled only when all arguments are
-   * fundamental types.
-   * This is the fastest way possible to log
-   * @note This function is thread-safe.
-   * @param dynamic_log_level dynamic log level
-   * @param macro_metadata metadata of the log message
-   * @param fmt_args arguments
-   *
-   * @return true if the message is written to the queue, false if it is dropped (when a dropping queue is used)
-   */
-  template <typename... Args>
-  QUILL_ATTRIBUTE_HOT bool log_message(LogLevel dynamic_log_level,
-                                       MacroMetadata const* macro_metadata, Args&&... fmt_args)
-  {
-    assert(valid.load(std::memory_order_acquire) && "Invalidated loggers can not log");
-
-    // Store the timestamp of the log statement at the start of the call. This gives more accurate
-    // timestamp especially if the queue is full
-    uint64_t const current_timestamp = (clock_source == ClockSourceType::Tsc) ? detail::rdtsc()
-      : (clock_source == ClockSourceType::System)
-      ? static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
-                                std::chrono::system_clock::now().time_since_epoch())
-                                .count())
-      : user_clock->now();
-
-    detail::ThreadContext* const thread_context =
-      quill::detail::get_local_thread_context<frontend_options_t>();
-
-    // Need to reserve additional space as we will be aligning the pointer
-    size_t total_size = sizeof(current_timestamp) + (sizeof(uintptr_t) * 3) +
-      detail::calculate_args_size_and_populate_string_lengths(
-                          thread_context->get_conditional_arg_size_cache(), fmt_args...);
-
-    if (dynamic_log_level != LogLevel::None)
-    {
-      // For the dynamic log level we want to add to the total size to store the dynamic log level
-      total_size += sizeof(dynamic_log_level);
-    }
-
-    constexpr bool is_unbounded_queue = (frontend_options_t::queue_type == QueueType::UnboundedUnlimited) ||
-      (frontend_options_t::queue_type == QueueType::UnboundedBlocking) ||
-      (frontend_options_t::queue_type == QueueType::UnboundedDropping);
-
-    std::byte* write_buffer;
-
-    if constexpr (is_unbounded_queue)
-    {
-      write_buffer = thread_context->get_spsc_queue<frontend_options_t::queue_type>().prepare_write(
-        static_cast<uint32_t>(total_size), frontend_options_t::queue_type);
-    }
-    else
-    {
-      write_buffer = thread_context->get_spsc_queue<frontend_options_t::queue_type>().prepare_write(
-        static_cast<uint32_t>(total_size));
-    }
-
-    if constexpr (frontend_options_t::queue_type == QueueType::UnboundedUnlimited)
-    {
-      assert(write_buffer &&
-             "Unbounded unlimited queue will always allocate and have enough capacity");
-    }
-    else if constexpr ((frontend_options_t::queue_type == QueueType::BoundedDropping) ||
-                       (frontend_options_t::queue_type == QueueType::UnboundedDropping))
-    {
-      if (QUILL_UNLIKELY(write_buffer == nullptr))
-      {
-        // not enough space to push to queue message is dropped
-        thread_context->increment_failure_counter();
-        return false;
-      }
-    }
-    else if constexpr ((frontend_options_t::queue_type == QueueType::BoundedBlocking) ||
-                       (frontend_options_t::queue_type == QueueType::UnboundedBlocking))
-    {
-      if (QUILL_UNLIKELY(write_buffer == nullptr))
-      {
-        thread_context->increment_failure_counter();
-
-        do
-        {
-          if constexpr (frontend_options_t::blocking_queue_retry_interval_ns > 0)
-          {
-            std::this_thread::sleep_for(std::chrono::nanoseconds{frontend_options_t::blocking_queue_retry_interval_ns});
-          }
-
-          // not enough space to push to queue, keep trying
-          if constexpr (is_unbounded_queue)
-          {
-            write_buffer = thread_context->get_spsc_queue<frontend_options_t::queue_type>().prepare_write(
-              static_cast<uint32_t>(total_size), frontend_options_t::queue_type);
-          }
-          else
-          {
-            write_buffer = thread_context->get_spsc_queue<frontend_options_t::queue_type>().prepare_write(
-              static_cast<uint32_t>(total_size));
-          }
-        } while (write_buffer == nullptr);
-      }
-    }
-
-    // we have enough space in this buffer, and we will write to the buffer
-
-#ifndef NDEBUG
-    std::byte const* const write_begin = write_buffer;
-    assert(write_begin);
-#endif
-
-    std::memcpy(write_buffer, &current_timestamp, sizeof(current_timestamp));
-    write_buffer += sizeof(current_timestamp);
-
-    std::memcpy(write_buffer, &macro_metadata, sizeof(uintptr_t));
-    write_buffer += sizeof(uintptr_t);
-
-    detail::LoggerBase* logger_context = this;
-    std::memcpy(write_buffer, &logger_context, sizeof(uintptr_t));
-    write_buffer += sizeof(uintptr_t);
-
-    detail::FormatArgsDecoder ftf = detail::decode_and_populate_format_args<detail::remove_cvref_t<Args>...>;
-    std::memcpy(write_buffer, &ftf, sizeof(uintptr_t));
-    write_buffer += sizeof(uintptr_t);
-
-    // encode remaining arguments
-    detail::encode(write_buffer, thread_context->get_conditional_arg_size_cache(), fmt_args...);
-
-    if (dynamic_log_level != LogLevel::None)
-    {
-      // write the dynamic log level
-      // The reason we write it last is that is less likely to break the alignment in the buffer
-      std::memcpy(write_buffer, &dynamic_log_level, sizeof(dynamic_log_level));
-      write_buffer += sizeof(dynamic_log_level);
-    }
-
-#ifndef NDEBUG
-    assert((write_buffer > write_begin) && "write_buffer must be greater than write_begin");
-    assert(total_size == (static_cast<uint32_t>(write_buffer - write_begin)) &&
-           "The committed write bytes must be equal to the total_size requested bytes");
-#endif
-
-    thread_context->get_spsc_queue<frontend_options_t::queue_type>().finish_write(static_cast<uint32_t>(total_size));
-    thread_context->get_spsc_queue<frontend_options_t::queue_type>().commit_write();
-    thread_context->get_conditional_arg_size_cache().clear();
-
-    return true;
-  }
-
-  /**
-   * Init a backtrace for this logger.
-   * Stores messages logged with LOG_BACKTRACE in a ring buffer messages and displays them later on demand.
-   * @param max_capacity The max number of messages to store in the backtrace
-   * @param flush_level If this loggers logs any message higher or equal to this severity level the backtrace will also get flushed.
-   * Default level is None meaning the user has to call flush_backtrace explicitly
-   */
-  void init_backtrace(uint32_t max_capacity, LogLevel flush_level = LogLevel::None)
-  {
-    // we do not care about the other fields, except quill::MacroMetadata::Event::InitBacktrace
-    static constexpr MacroMetadata macro_metadata{
-      "", "", "{}", nullptr, LogLevel::Critical, MacroMetadata::Event::InitBacktrace};
-
-    // we pass this message to the queue and also pass capacity as arg
-    // We do not want to drop the message if a dropping queue is used
-    while (!this->log_message(LogLevel::None, &macro_metadata, max_capacity))
-    {
-      std::this_thread::sleep_for(std::chrono::nanoseconds{100});
-    }
-
-    // Also store the desired flush log level
-    backtrace_flush_level.store(flush_level, std::memory_order_relaxed);
-  }
-
-  /**
-   * Dump any stored backtrace messages
-   */
-  void flush_backtrace()
-  {
-    // we do not care about the other fields, except quill::MacroMetadata::Event::Flush
-    static constexpr MacroMetadata macro_metadata{
-      "", "", "", nullptr, LogLevel::Critical, MacroMetadata::Event::FlushBacktrace};
-
-    // We do not want to drop the message if a dropping queue is used
-    while (!this->log_message(LogLevel::None, &macro_metadata))
-    {
-      std::this_thread::sleep_for(std::chrono::nanoseconds{100});
-    }
-  }
-
-  /**
-   * Blocks the calling thread until all log messages up to the current timestamp are flushed.
-   *
-   * The backend thread will invoke the write operation on all sinks for all loggers up to the point
-   * (timestamp) when this function is invoked.
-   *
-   * @param sleep_duration_ns The duration in nanoseconds to sleep between retries when the
-   * blocking queue is full, and between checks for the flush completion. Default is 100 nanoseconds.
-   *
-   * @note This function should only be called when the backend worker is running after Backend::start(...)
-   * @note This function will block the calling thread until the flush message is processed by the backend thread.
-   *       The calling thread can block for up to backend_options.sleep_duration. If you configure a custom
-   *       long sleep duration on the backend thread, e.g., backend_options.sleep_duration = std::chrono::minutes{1},
-   *       then you should ideally avoid calling this function as you can block for long period of times unless
-   *       you use another thread that calls Backend::notify()
-   */
-  void flush_log(uint32_t sleep_duration_ns = 100)
-  {
-    static constexpr MacroMetadata macro_metadata{
-      "", "", "", nullptr, LogLevel::Critical, MacroMetadata::Event::Flush};
-
-    std::atomic<bool> backend_thread_flushed{false};
-    std::atomic<bool>* backend_thread_flushed_ptr = &backend_thread_flushed;
-
-    // We do not want to drop the message if a dropping queue is used
-    while (!this->log_message(LogLevel::None, &macro_metadata, reinterpret_cast<uintptr_t>(backend_thread_flushed_ptr)))
-    {
-      if (sleep_duration_ns > 0)
-      {
-        std::this_thread::sleep_for(std::chrono::nanoseconds{sleep_duration_ns});
-      }
-      else
-      {
-        std::this_thread::yield();
-      }
-    }
-
-    // The caller thread keeps checking the flag until the backend thread flushes
-    while (!backend_thread_flushed.load())
-    {
-      if (sleep_duration_ns > 0)
-      {
-        std::this_thread::sleep_for(std::chrono::nanoseconds{sleep_duration_ns});
-      }
-      else
-      {
-        std::this_thread::yield();
-      }
-    }
-  }
-
-private:
-  friend class detail::LoggerManager;
-  friend class detail::BackendWorker;
-
-  /***/
-  LoggerImpl(std::string logger_name, std::vector<std::shared_ptr<Sink>> sinks,
-             std::string format_pattern, std::string time_pattern, Timezone timestamp_timezone,
-             ClockSourceType clock_source, UserClockSource* user_clock)
-    : detail::LoggerBase(static_cast<std::string&&>(logger_name),
-                         static_cast<std::vector<std::shared_ptr<Sink>>&&>(sinks),
-                         static_cast<std::string&&>(format_pattern),
-                         static_cast<std::string&&>(time_pattern), timestamp_timezone, clock_source, user_clock)
-
-  {
-    if (this->user_clock)
-    {
-      // if a user clock is provided then set the ClockSourceType to User
-      this->clock_source = ClockSourceType::User;
-    }
-  }
-};
-
-using Logger = LoggerImpl<FrontendOptions>;
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/UserClockSource.h b/subprojects/quill-4.2.0/quill/include/quill/UserClockSource.h
deleted file mode 100644
index b3b28be..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/UserClockSource.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include <cstdint>
-
-namespace quill
-{
-/**
- * @brief Base class that provides a timestamp for log statements based on a user-provided clock source.
- *
- * This base class can be derived from to pass a user-generated timestamp to a Logger.
- *
- * It is particularly useful for simulations or scenarios where time manipulation is necessary,
- * such as simulating time in the past and displaying past timestamps in logs.
- *
- * @note The derived class must be thread-safe if the Logger object is used across multiple threads.
- * If a Logger is used within a single thread only, thread safety is not a concern.
- */
-class UserClockSource
-{
-public:
-  UserClockSource() = default;
-  virtual ~UserClockSource() = default;
-
-  UserClockSource(UserClockSource const&) = delete;
-  UserClockSource& operator=(UserClockSource const&) = delete;
-
-  /**
-   * Returns time since epoch in nanoseconds
-   */
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT virtual uint64_t now() const = 0;
-};
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/Utility.h b/subprojects/quill-4.2.0/quill/include/quill/Utility.h
deleted file mode 100644
index 11af61a..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/Utility.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include <cstddef>
-#include <string>
-#include <string_view>
-#include <tuple>
-
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-
-/**
- * Contains useful utilities to assist with logging
- */
-namespace quill::utility
-{
-/**
- * @brief Formats the given buffer to hexadecimal representation.
- *
- * This function converts the contents of the input buffer to a hexadecimal string.
- *
- * @param buffer Pointer to the input buffer.
- * @param size Size of the input buffer.
- * @return A string containing the hexadecimal representation of the given buffer.
- */
-template <typename T>
-QUILL_NODISCARD std::string to_hex(T* buffer, size_t size) noexcept
-{
-  static constexpr char hex_chars[] = "0123456789ABCDEF";
-
-  std::string hex_string;
-  hex_string.reserve(3 * size);
-
-  for (size_t i = 0; i < size; ++i)
-  {
-    // 00001111 mask
-    static constexpr uint8_t mask = 0x0Fu;
-
-    // add the first four bits
-    hex_string += hex_chars[(buffer[i] >> 4u) & mask];
-
-    // add the remaining bits
-    hex_string += hex_chars[buffer[i] & mask];
-
-    if (i != (size - 1))
-    {
-      // add a space delimiter
-      hex_string += ' ';
-    }
-  }
-
-  return hex_string;
-}
-
-/**
- * @brief Helper class for combining quill::Tag objects.
- * This class combines multiple quill::Tag objects into a single Tag object.
- */
-template <typename... TTags>
-class CombinedTags : public Tags
-{
-public:
-  constexpr CombinedTags(TTags... tags, std::string_view delim = ", ")
-    : _tags(std::move(tags)...), _delim(delim)
-  {
-  }
-
-  void format(std::string& out) const override
-  {
-    std::apply([&out, this](const auto&... tags)
-               { (((tags.format(out)), out.append(_delim.data())), ...); }, _tags);
-
-    if (!out.empty())
-    {
-      // erase last delim
-      out.erase(out.length() - _delim.length(), _delim.length());
-    }
-  }
-
-private:
-  std::tuple<TTags...> _tags;
-  std::string_view _delim;
-};
-} // namespace quill::utility
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/backend/BackendManager.h b/subprojects/quill-4.2.0/quill/include/quill/backend/BackendManager.h
deleted file mode 100644
index 4ba926f..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/backend/BackendManager.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/backend/BackendOptions.h"
-#include "quill/backend/BackendWorker.h"
-#include "quill/core/Attributes.h"
-
-#include <cstdint>
-#include <mutex>
-
-namespace quill::detail
-{
-/**
- * Provides access to common collection class that are used by both the frontend and the backend
- * components of the logging system
- * There should only be only active active instance of this class which is achieved by the
- * LogSystemManagerSingleton
- */
-class BackendManager
-{
-public:
-  /***/
-  static BackendManager& instance() noexcept
-  {
-    static BackendManager instance;
-    return instance;
-  }
-
-  /***/
-  BackendManager(BackendManager const&) = delete;
-  BackendManager& operator=(BackendManager const&) = delete;
-
-  /***/
-  QUILL_ATTRIBUTE_COLD void start_backend_thread(BackendOptions const& options)
-  {
-    // Start the backend worker
-    _backend_worker.run(options);
-  }
-
-  /***/
-  QUILL_ATTRIBUTE_COLD std::once_flag& get_start_once_flag() noexcept { return _start_once_flag; }
-
-  /***/
-  QUILL_ATTRIBUTE_COLD void stop_backend_thread() noexcept { _backend_worker.stop(); }
-
-  /***/
-  QUILL_NODISCARD uint32_t get_backend_thread_id() const noexcept
-  {
-    return _backend_worker.get_backend_thread_id();
-  }
-
-  /***/
-  void notify_backend_thread() noexcept { _backend_worker.notify(); }
-
-  /***/
-  QUILL_NODISCARD bool is_backend_thread_running() const noexcept
-  {
-    return _backend_worker.is_running();
-  }
-
-  /***/
-  QUILL_NODISCARD uint64_t convert_rdtsc_to_epoch_time(uint64_t rdtsc_value) const noexcept
-  {
-    return _backend_worker.time_since_epoch(rdtsc_value);
-  }
-
-private:
-  /***/
-  BackendManager() = default;
-  ~BackendManager() = default;
-
-private:
-  BackendWorker _backend_worker;
-  std::once_flag _start_once_flag;
-};
-} // namespace quill::detail
diff --git a/subprojects/quill-4.2.0/quill/include/quill/backend/BackendOptions.h b/subprojects/quill-4.2.0/quill/include/quill/backend/BackendOptions.h
deleted file mode 100644
index fb489bd..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/backend/BackendOptions.h
+++ /dev/null
@@ -1,169 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include <chrono>
-#include <cstdint>
-#include <cstdio>
-#include <functional>
-#include <limits>
-#include <string>
-
-#if defined(__MINGW32__)
-  #include <iostream>
-#endif
-
-namespace quill
-{
-struct BackendOptions
-{
-  /**
-   * The name assigned to the backend, visible during thread naming queries (e.g.,
-   * pthread_getname_np) or in the debugger.
-   */
-  std::string thread_name = "QuillBackend";
-
-  /**
-   * The backend employs "busy-waiting" by spinning around each frontend thread's queue.
-   * If enabled, the backend will yield when there is no remaining work, potentially
-   * reducing the OS scheduler priority for the backend.
-   * This option is effective only when sleep_duration is set to 0.
-   */
-  bool enable_yield_when_idle = false;
-
-  /**
-   * Specifies the duration the backend sleeps if there is no remaining work to process in the queues.
-   */
-  std::chrono::nanoseconds sleep_duration = std::chrono::nanoseconds{500};
-
-  /**
-   * The backend pops all log messages from the frontend queues and buffers them in a
-   * local ring buffer queue as transit events. The transit_event_buffer is unbounded, starting with
-   * a customizable initial capacity (in items, not bytes) and will reallocate up to
-   * transit_events_hard_limit The backend will use a separate transit_event_buffer for each
-   * frontend thread. The capacity must be a power of two.
-   */
-  uint32_t transit_event_buffer_initial_capacity = 64;
-
-  /**
-   * The backend gives priority to reading messages from the frontend queues of all
-   * the hot threads and temporarily buffers them.
-   *
-   * If a frontend threads continuously push messages to the queue (e.g., logging in a loop),
-   * no logs can ever be processed.
-   *
-   * When the soft limit is reached (default: 800), the backend worker thread will try to process
-   * a batch of cached transit events all at once
-   *
-   * The frontend queues are emptied on each iteration, so the actual popped messages
-   * can be much greater than the transit_events_soft_limit.
-   *
-   * @note This number represents a limit across the messages received from ALL frontend threads.
-   */
-  size_t transit_events_soft_limit = 800;
-
-  /**
-   * The backend gives priority to reading messages from the frontend queues and temporarily
-   * buffers them.
-   *
-   * If a frontend thread continuously push messages to the queue (e.g., logging in a loop),
-   * no logs can ever be processed.
-   *
-   * As the backend buffers messages, it can keep buffering indefinitely if the frontend
-   * threads keep pushing.
-   *
-   * This limit is the maximum size of the backend event buffer. When reached, the backend
-   * will stop reading the frontend queues until there is space available in the buffer.
-   *
-   * @note This number represents a limit PER frontend threads.
-   */
-  size_t transit_events_hard_limit = 100'000;
-
-  /**
-   * The backend iterates through all frontend queues and pops all messages from each queue.
-   * It then buffers and logs the message with the lowest timestamp among them.
-   *
-   * Each frontend queue corresponds to a thread, and when multiple frontend threads are pushing logs
-   * simultaneously, it is possible to read a timestamp from the last queue in the iteration but
-   * miss that timestamp when the first queue was read because it was not available at that time.
-   *
-   * When this option is enabled, the backend takes a timestamp (`now()`) before reading
-   * the queues. It uses that timestamp to ensure that each log message's timestamp from the frontend
-   * queues is less than or equal to the stored `now()` timestamp, guaranteeing ordering by timestamp.
-   *
-   * Messages that fail the above check are not logged and remain in the queue.
-   * They are checked again in the next iteration.
-   *
-   * The timestamp check is performed with microsecond precision.
-   *
-   * Enabling this option may cause a delay in processing but ensures correct timestamp order.
-   *
-   * @note Applicable only when use_transit_buffer = true.
-   */
-  bool enable_strict_log_timestamp_order = true;
-
-  /**
-   * When this option is enabled and the application is terminating, the backend worker thread
-   * will not exit until all the frontend queues are empty.
-   *
-   * However, if there is a thread during application destruction that keeps trying to log
-   * indefinitely, the backend will be unable to exit because it keeps popping log messages.
-   *
-   * When this option is disabled, the backend will try to read the queues once
-   * and then exit. Reading the queues only once means that some log messages can be dropped,
-   * especially when strict_log_timestamp_order is set to true.
-   */
-  bool wait_for_queues_to_empty_before_exit = true;
-
-  /**
-   * Pins the backend to the specified CPU.
-   *
-   * By default, the backend is not pinned to any CPU unless a value is specified.
-   * It is recommended to pin the backend to a shared non-critical CPU.
-   * Use `std::numeric_limits<uint16_t>::max()` as an undefined value to avoid setting CPU affinity.
-   */
-  uint16_t backend_cpu_affinity = (std::numeric_limits<uint16_t>::max)();
-
-  /**
-   * The backend may encounter exceptions that cannot be caught within user threads.
-   * In such cases, the backend invokes this callback to notify the user.
-   *
-   * This function sets up a user error notifier to handle backend errors and notifications,
-   * such as when the unbounded queue reallocates or when the bounded queue becomes full.
-   *
-   * To disable notifications, simply leave the function undefined:
-   *   std::function<void(std::string const&)> backend_error_notifier = {};
-   *
-   * It's safe to perform logging operations within this function (e.g., LOG_INFO(...)),
-   * but avoid calling logger->flush_log(). The function is invoked on the backend thread,
-   * which should not remain in a waiting state as it waits for itself.
-   */
-  std::function<void(std::string const&)> error_notifier = [](std::string const& error_message)
-  {
-#if !defined(__MINGW32__)
-    std::fprintf(stderr, "%s\n", error_message.data());
-#else
-    // fprintf crashes on mingw gcc 13 for unknown reason
-    std::cerr << error_message.data() << "\n";
-#endif
-  };
-
-  /**
-   * This option is only applicable if at least one frontend is using a Logger with
-   * ClockSourceType::Tsc
-   *
-   * When the system clock is used, this option can be ignored.
-   *
-   * Controls the frequency at which the backend recalculates and syncs the internal RdtscClock
-   * with the system time from the system wall clock.
-   * The TSC clock can drift slightly over time and is not synchronized with NTP server updates.
-   *
-   * Smaller values provide more accurate log timestamps at the cost of additional system clock
-   * calls. Changing this value only affects the performance of the backend worker.
-   */
-  std::chrono::milliseconds rdtsc_resync_interval = std::chrono::milliseconds{500};
-};
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/backend/BackendUtilities.h b/subprojects/quill-4.2.0/quill/include/quill/backend/BackendUtilities.h
deleted file mode 100644
index 32f9b55..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/backend/BackendUtilities.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/QuillError.h"
-
-#include <cstdint>
-#include <cstring>
-#include <string>
-#include <system_error>
-
-#if defined(_WIN32)
-  #if !defined(WIN32_LEAN_AND_MEAN)
-    #define WIN32_LEAN_AND_MEAN
-  #endif
-
-  #if !defined(NOMINMAX)
-    // Mingw already defines this, so no need to redefine
-    #define NOMINMAX
-  #endif
-
-  #include <windows.h>
-
-  #include "quill/core/ThreadUtilities.h" // for s2ws
-#elif defined(__APPLE__)
-  #include <mach/thread_act.h>
-  #include <mach/thread_policy.h>
-  #include <pthread.h>
-  #include <unistd.h>
-#elif defined(__CYGWIN__)
-  #include <sched.h>
-  #include <unistd.h>
-#elif defined(__linux__)
-  #include <pthread.h>
-  #include <sched.h>
-  #include <unistd.h>
-#elif defined(__NetBSD__)
-  #include <sched.h>
-  #include <unistd.h>
-#elif defined(__FreeBSD__)
-  #include <sched.h>
-  #include <unistd.h>
-#elif defined(__DragonFly__)
-  #include <sched.h>
-  #include <unistd.h>
-#else
-  #include <sched.h>
-  #include <unistd.h>
-#endif
-
-namespace quill::detail
-{
-/***/
-QUILL_ATTRIBUTE_COLD inline void set_cpu_affinity(uint16_t cpu_id)
-{
-#if defined(__CYGWIN__)
-  // setting cpu affinity on cygwin is not supported
-#elif defined(_WIN32)
-  // core number starts from 0
-  auto const mask = (static_cast<DWORD_PTR>(1) << cpu_id);
-  auto ret = SetThreadAffinityMask(GetCurrentThread(), mask);
-  if (ret == 0)
-  {
-    auto const last_error = std::error_code(GetLastError(), std::system_category());
-
-    QUILL_THROW(
-      QuillError{std::string{"Failed to set cpu affinity - errno: " + std::to_string(last_error.value()) +
-                             " error: " + last_error.message()}});
-  }
-#elif defined(__APPLE__)
-  // I don't think that's possible to link a thread with a specific core with Mac OS X
-  // This may be used to express affinity relationships  between threads in the task.
-  // Threads with the same affinity tag will be scheduled to share an L2 cache if possible.
-  thread_affinity_policy_data_t policy = {cpu_id};
-
-  // Get the mach thread bound to this thread
-  thread_port_t mach_thread = pthread_mach_thread_np(pthread_self());
-
-  thread_policy_set(mach_thread, THREAD_AFFINITY_POLICY, (thread_policy_t)&policy, 1);
-#else
-  cpu_set_t cpuset;
-  CPU_ZERO(&cpuset);
-  CPU_SET(cpu_id, &cpuset);
-
-  auto const err = sched_setaffinity(0, sizeof(cpuset), &cpuset);
-
-  if (QUILL_UNLIKELY(err == -1))
-  {
-    QUILL_THROW(QuillError{std::string{"Failed to set cpu affinity - errno: " + std::to_string(errno) +
-                                       " error: " + strerror(errno)}});
-  }
-#endif
-}
-
-/***/
-QUILL_ATTRIBUTE_COLD inline void set_thread_name(char const* name)
-{
-#if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__MINGW64__) || defined(QUILL_NO_THREAD_NAME_SUPPORT)
-  // Disabled on MINGW / Cygwin.
-  (void)name;
-#elif defined(_WIN32)
-  std::wstring name_ws = s2ws(name);
-  // Set the thread name
-
-  typedef HRESULT(WINAPI * SetThreadDescriptionSignature)(HANDLE, PCWSTR);
-  HRESULT hr = callRunTimeDynamicLinkedFunction<HRESULT, SetThreadDescriptionSignature>(
-    "KernelBase.dll", "SetThreadDescription", GetCurrentThread(), name_ws.data());
-
-  if (FAILED(hr))
-  {
-    QUILL_THROW(QuillError{"Failed to set thread name"});
-  }
-#elif defined(__APPLE__)
-  // Apple
-  auto const res = pthread_setname_np(name);
-  if (res != 0)
-  {
-    QUILL_THROW(QuillError{std::string{"Failed to set thread name - errno: " + std::to_string(errno) +
-                                       " error: " + strerror(errno)}});
-  }
-#else
-  // linux
-  char truncated_name[16];
-  std::strncpy(truncated_name, name, 15);
-  truncated_name[15] = '\0';
-
-  auto const res = pthread_setname_np(pthread_self(), name);
-  if (res != 0)
-  {
-    QUILL_THROW(QuillError{std::string{"Failed to set thread name - errno: " + std::to_string(errno) +
-                                       " error: " + strerror(errno)}});
-  }
-#endif
-}
-
-/***/
-QUILL_NODISCARD QUILL_ATTRIBUTE_COLD inline uint32_t get_process_id() noexcept
-{
-#if defined(__CYGWIN__)
-  // get pid on cygwin not supported
-  return 0;
-#elif defined(_WIN32)
-  return static_cast<uint32_t>(GetCurrentProcessId());
-#else
-  return static_cast<uint32_t>(getpid());
-#endif
-}
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/backend/BackendWorker.h b/subprojects/quill-4.2.0/quill/include/quill/backend/BackendWorker.h
deleted file mode 100644
index 2357755..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/backend/BackendWorker.h
+++ /dev/null
@@ -1,1295 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/backend/BackendOptions.h"
-#include "quill/backend/BackendUtilities.h"
-#include "quill/backend/BacktraceStorage.h"
-#include "quill/backend/PatternFormatter.h"
-#include "quill/backend/RdtscClock.h"
-#include "quill/backend/TimestampFormatter.h"
-#include "quill/backend/TransitEvent.h"
-#include "quill/backend/TransitEventBuffer.h"
-
-#include "quill/core/Attributes.h"
-#include "quill/core/BoundedSPSCQueue.h"
-#include "quill/core/Codec.h"
-#include "quill/core/Common.h"
-#include "quill/core/DynamicFormatArgStore.h"
-#include "quill/core/FormatBuffer.h"
-#include "quill/core/LogLevel.h"
-#include "quill/core/LoggerBase.h"
-#include "quill/core/LoggerManager.h"
-#include "quill/core/MacroMetadata.h"
-#include "quill/core/QuillError.h"
-#include "quill/core/SinkManager.h"
-#include "quill/core/ThreadContextManager.h"
-#include "quill/core/ThreadUtilities.h"
-#include "quill/core/TimeUtilities.h"
-#include "quill/core/UnboundedSPSCQueue.h"
-#include "quill/sinks/Sink.h"
-
-#include "quill/bundled/fmt/core.h"
-
-#include <algorithm>
-#include <atomic>
-#include <cassert>
-#include <chrono>
-#include <condition_variable>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <ctime>
-#include <exception>
-#include <functional>
-#include <iterator>
-#include <limits>
-#include <memory>
-#include <mutex>
-#include <optional>
-#include <ratio>
-#include <string>
-#include <string_view>
-#include <thread>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-namespace quill::detail
-{
-class BackendWorker
-{
-public:
-  /**
-   * Constructor
-   */
-  BackendWorker() { _process_id = std::to_string(get_process_id()); }
-
-  /**
-   * Deleted
-   */
-  BackendWorker(BackendWorker const&) = delete;
-  BackendWorker& operator=(BackendWorker const&) = delete;
-
-  /**
-   * Destructor
-   */
-  ~BackendWorker()
-  {
-    // This destructor will run during static destruction as the thread is part of the singleton
-    stop();
-
-    RdtscClock const* rdtsc_clock{_rdtsc_clock.load()};
-    _rdtsc_clock.store(nullptr);
-    delete rdtsc_clock;
-  }
-
-  /***/
-  QUILL_NODISCARD bool is_running() const noexcept
-  {
-    return _is_worker_running.load(std::memory_order_relaxed);
-  }
-
-  /**
-   * Access the rdtsc class to convert an rdtsc value to wall time
-   */
-  QUILL_NODISCARD uint64_t time_since_epoch(uint64_t rdtsc_value) const
-  {
-    if (QUILL_UNLIKELY(_options.sleep_duration > _options.rdtsc_resync_interval))
-    {
-      QUILL_THROW(
-        QuillError{"Invalid config, When TSC clock is used backend_thread_sleep_duration should "
-                   "not be higher than rdtsc_resync_interval"});
-    }
-
-    RdtscClock const* rdtsc_clock = _rdtsc_clock.load(std::memory_order_acquire);
-    return rdtsc_clock ? rdtsc_clock->time_since_epoch_safe(rdtsc_value) : 0;
-  }
-
-  /**
-   * Get the backend worker's thread id
-   * @return the backend worker's thread id
-   */
-  QUILL_NODISCARD uint32_t get_backend_thread_id() const noexcept
-  {
-    return _worker_thread_id.load();
-  }
-
-  /**
-   * Starts the backend worker thread
-   * @throws std::runtime_error, std::system_error on failures
-   */
-  QUILL_ATTRIBUTE_COLD void run(BackendOptions const& options)
-  {
-    _options = options;
-
-    std::thread worker(
-      [this]()
-      {
-        QUILL_TRY
-        {
-          if (_options.backend_cpu_affinity != (std::numeric_limits<uint16_t>::max)())
-          {
-            // Set cpu affinity if requested to cpu _backend_thread_cpu_affinity
-            set_cpu_affinity(_options.backend_cpu_affinity);
-          }
-        }
-#if !defined(QUILL_NO_EXCEPTIONS)
-        QUILL_CATCH(std::exception const& e) { _options.error_notifier(e.what()); }
-        QUILL_CATCH_ALL() { _options.error_notifier(std::string{"Caught unhandled exception."}); }
-#endif
-
-        QUILL_TRY
-        {
-          // Set the thread name to the desired name
-          set_thread_name(_options.thread_name.data());
-        }
-#if !defined(QUILL_NO_EXCEPTIONS)
-        QUILL_CATCH(std::exception const& e) { _options.error_notifier(e.what()); }
-        QUILL_CATCH_ALL() { _options.error_notifier(std::string{"Caught unhandled exception."}); }
-#endif
-
-        // Cache this thread's id
-        _worker_thread_id.store(get_thread_id());
-
-        // Double check or modify some backend options before we start
-        if (_options.transit_events_hard_limit == 0)
-        {
-          // transit_events_hard_limit of 0 makes no sense as we can't process anything
-          _options.transit_events_hard_limit = 1;
-        }
-
-        if (_options.transit_events_soft_limit == 0)
-        {
-          _options.transit_events_soft_limit = 1;
-        }
-
-        // All okay, set the backend worker thread running flag
-        _is_worker_running.store(true);
-
-        // Running
-        while (QUILL_LIKELY(_is_worker_running.load(std::memory_order_relaxed)))
-        {
-          // main loop
-          QUILL_TRY { _main_loop(); }
-#if !defined(QUILL_NO_EXCEPTIONS)
-          QUILL_CATCH(std::exception const& e) { _options.error_notifier(e.what()); }
-          QUILL_CATCH_ALL()
-          {
-            _options.error_notifier(std::string{"Caught unhandled exception."});
-          } // clang-format on
-#endif
-        }
-
-        // exit
-        QUILL_TRY { _exit(); }
-#if !defined(QUILL_NO_EXCEPTIONS)
-        QUILL_CATCH(std::exception const& e) { _options.error_notifier(e.what()); }
-        QUILL_CATCH_ALL()
-        {
-          _options.error_notifier(std::string{"Caught unhandled exception."});
-        } // clang-format on
-#endif
-      });
-
-    // Move the worker ownership to our class
-    _worker_thread.swap(worker);
-
-    while (!_is_worker_running.load(std::memory_order_seq_cst))
-    {
-      // wait for the thread to start
-      std::this_thread::sleep_for(std::chrono::microseconds{100});
-    }
-  }
-
-  /**
-   * Stops the backend worker thread
-   */
-  QUILL_ATTRIBUTE_COLD void stop() noexcept
-  {
-    // Stop the backend worker
-    if (!_is_worker_running.exchange(false))
-    {
-      // already stopped
-      return;
-    }
-
-    // signal wake up the backend worker thread
-    notify();
-
-    // Wait the backend thread to join, if backend thread was never started it won't be joinable
-    if (_worker_thread.joinable())
-    {
-      _worker_thread.join();
-    }
-  }
-
-  /**
-   * Wakes up the backend worker thread.
-   * Thread safe to be called from any thread
-   */
-  void notify()
-  {
-    // Set the flag to indicate that the data is ready
-    {
-      std::lock_guard<std::mutex> lock{_wake_up_mutex};
-      _wake_up_flag = true;
-    }
-
-    // Signal the condition variable to wake up the worker thread
-    _wake_up_cv.notify_one();
-  }
-
-private:
-  /**
-   * Backend worker thread main function
-   */
-  QUILL_ATTRIBUTE_HOT void _main_loop()
-  {
-    // load all contexts locally
-    _update_active_thread_contexts_cache();
-
-    // Phase 1:
-    // Read all frontend queues and cache the log statements and the metadata as TransitEvents
-    size_t const cached_transit_events_count = _populate_transit_events_from_frontend_queues();
-
-    if (cached_transit_events_count > 0)
-    {
-      // there are cached events to process
-      if (cached_transit_events_count < _options.transit_events_soft_limit)
-      {
-        // process a single transit event, then give priority to reading the frontend queues again
-        _process_next_cached_transit_event();
-      }
-      else
-      {
-        // we want to process a batch of events.
-        while (!has_pending_events_for_caching_when_transit_event_buffer_empty() &&
-               _process_next_cached_transit_event())
-        {
-          // We need to be cautious because there are log messages in the lock-free queues
-          // that have not yet been cached in the transit event buffer. Logging only the cached
-          // messages can result in out-of-order log entries, as messages with larger timestamps
-          // in the queue might be missed.
-        }
-      }
-    }
-    else
-    {
-      // No cached transit events to process, minimal thread workload.
-
-      // force flush all remaining messages
-      _flush_and_run_active_sinks_loop(true);
-
-      // check for any dropped messages / blocked threads
-      _check_failure_counter(_options.error_notifier);
-
-      // This is useful when BackendTscClock is used to keep it up to date
-      _resync_rdtsc_clock();
-
-      // Also check if all queues are empty
-      bool const queues_and_events_empty = _check_frontend_queues_and_cached_transit_events_empty();
-      if (queues_and_events_empty)
-      {
-        _cleanup_invalidated_thread_contexts();
-        _cleanup_invalidated_loggers();
-
-        // There is nothing left to do, and we can let this thread sleep for a while
-        // buffer events are 0 here and also all the producer queues are empty
-        if (_options.sleep_duration.count() != 0)
-        {
-          std::unique_lock<std::mutex> lock{_wake_up_mutex};
-
-          // Wait for a timeout or a notification to wake up
-          _wake_up_cv.wait_for(lock, _options.sleep_duration, [this] { return _wake_up_flag; });
-
-          // set the flag back to false since we woke up here
-          _wake_up_flag = false;
-
-          // After waking up resync rdtsc clock again and resume
-          _resync_rdtsc_clock();
-        }
-        else if (_options.enable_yield_when_idle)
-        {
-          std::this_thread::yield();
-        }
-      }
-    }
-  }
-
-  /**
-   * Logging thread exit function that flushes everything after stop() is called
-   */
-  QUILL_ATTRIBUTE_COLD void _exit()
-  {
-    while (true)
-    {
-      bool const queues_and_events_empty = (!_options.wait_for_queues_to_empty_before_exit) ||
-        _check_frontend_queues_and_cached_transit_events_empty();
-
-      if (queues_and_events_empty)
-      {
-        // we are done, all queues are now empty
-        _check_failure_counter(_options.error_notifier);
-        _flush_and_run_active_sinks_loop(false);
-        break;
-      }
-
-      size_t const cached_transit_events_count = _populate_transit_events_from_frontend_queues();
-      if (cached_transit_events_count > 0)
-      {
-        while (!has_pending_events_for_caching_when_transit_event_buffer_empty() &&
-               _process_next_cached_transit_event())
-        {
-          // We need to be cautious because there are log messages in the lock-free queues
-          // that have not yet been cached in the transit event buffer. Logging only the cached
-          // messages can result in out-of-order log entries, as messages with larger timestamps
-          // in the queue might be missed.
-        }
-      }
-    }
-  }
-
-  /**
-   * Populates the local transit event buffer
-   */
-  QUILL_ATTRIBUTE_HOT size_t _populate_transit_events_from_frontend_queues()
-  {
-    uint64_t const ts_now = _options.enable_strict_log_timestamp_order
-      ? static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::microseconds>(
-                                std::chrono::system_clock::now().time_since_epoch())
-                                .count())
-      : 0;
-
-    size_t cached_transit_events_count{0};
-
-    for (ThreadContext* thread_context : _active_thread_contexts_cache)
-    {
-      assert(thread_context->has_unbounded_queue_type() || thread_context->has_bounded_queue_type());
-
-      if (thread_context->has_unbounded_queue_type())
-      {
-        cached_transit_events_count += _read_and_decode_frontend_queue(
-          thread_context->get_spsc_queue_union().unbounded_spsc_queue, thread_context, ts_now);
-      }
-      else if (thread_context->has_bounded_queue_type())
-      {
-        cached_transit_events_count += _read_and_decode_frontend_queue(
-          thread_context->get_spsc_queue_union().bounded_spsc_queue, thread_context, ts_now);
-      }
-    }
-
-    return cached_transit_events_count;
-  }
-
-  /**
-   * Deserialize messages from the raw SPSC queue
-   * @param frontend_queue queue
-   * @param thread_context thread context
-   * @param ts_now timestamp now
-   * @return size of the transit_event_buffer
-   */
-  template <typename TFrontendQueue>
-  QUILL_ATTRIBUTE_HOT uint32_t _read_and_decode_frontend_queue(TFrontendQueue& frontend_queue,
-                                                               ThreadContext* thread_context, uint64_t ts_now)
-  {
-    // Note: The producer commits only complete messages to the queue.
-    // Therefore, if even a single byte is present in the queue, it signifies a full message.
-    size_t const queue_capacity = frontend_queue.capacity();
-    size_t total_bytes_read{0};
-
-    do
-    {
-      std::byte* read_pos;
-
-      if constexpr (std::is_same_v<TFrontendQueue, UnboundedSPSCQueue>)
-      {
-        read_pos = _read_unbounded_frontend_queue(frontend_queue, thread_context);
-      }
-      else
-      {
-        read_pos = frontend_queue.prepare_read();
-      }
-
-      if (!read_pos)
-      {
-        // Exit loop nothing to read
-        break;
-      }
-
-      std::byte const* const read_begin = read_pos;
-
-      if (!_populate_transit_event_from_frontend_queue(read_pos, thread_context, ts_now))
-      {
-        // If _get_transit_event_from_queue returns false, stop reading
-        break;
-      }
-
-      // Finish reading
-      assert((read_pos >= read_begin) && "read_buffer should be greater or equal to read_begin");
-      auto const bytes_read = static_cast<uint32_t>(read_pos - read_begin);
-      frontend_queue.finish_read(bytes_read);
-      total_bytes_read += bytes_read;
-      // Reads a maximum of one full frontend queue or the transit events' hard limit to prevent
-      // getting stuck on the same producer.
-    } while ((total_bytes_read < queue_capacity) &&
-             (thread_context->_transit_event_buffer->size() < _options.transit_events_hard_limit));
-
-    if (total_bytes_read != 0)
-    {
-      // If we read something from the queue, we commit all the reads together at the end.
-      // This strategy enhances cache coherence performance by updating the shared atomic flag
-      // only once.
-      frontend_queue.commit_read();
-    }
-
-    return thread_context->_transit_event_buffer->size();
-  }
-
-  /***/
-  QUILL_ATTRIBUTE_HOT bool _populate_transit_event_from_frontend_queue(std::byte*& read_pos,
-                                                                       ThreadContext* thread_context,
-                                                                       uint64_t ts_now)
-  {
-    assert(thread_context->_transit_event_buffer);
-
-    // Allocate a new TransitEvent or use an existing one to store the message from the queue
-    TransitEvent* transit_event = thread_context->_transit_event_buffer->back();
-    transit_event->thread_id = thread_context->thread_id();
-    transit_event->thread_name = thread_context->thread_name();
-
-    std::memcpy(&transit_event->timestamp, read_pos, sizeof(transit_event->timestamp));
-    read_pos += sizeof(transit_event->timestamp);
-
-    std::memcpy(&transit_event->macro_metadata, read_pos, sizeof(transit_event->macro_metadata));
-    read_pos += sizeof(transit_event->macro_metadata);
-
-    std::memcpy(&transit_event->logger_base, read_pos, sizeof(transit_event->logger_base));
-    read_pos += sizeof(transit_event->logger_base);
-
-    std::memcpy(&transit_event->format_args_decoder, read_pos, sizeof(transit_event->format_args_decoder));
-    read_pos += sizeof(transit_event->format_args_decoder);
-
-    // Look up to see if we have the formatter and if not create it
-    if (!transit_event->logger_base->pattern_formatter)
-    {
-      // Search for an existing pattern_formatter
-      auto search_it = std::find_if(
-        _pattern_formatters.begin(), _pattern_formatters.end(),
-        [transit_event](std::weak_ptr<PatternFormatter> const& elem)
-        {
-          std::shared_ptr<PatternFormatter> pattern_formatter = elem.lock();
-
-          return pattern_formatter &&
-            (pattern_formatter->format_pattern() == transit_event->logger_base->format_pattern) &&
-            (pattern_formatter->timestamp_formatter().time_format() == transit_event->logger_base->time_pattern) &&
-            (pattern_formatter->timestamp_formatter().timestamp_timezone() ==
-             transit_event->logger_base->timezone);
-        });
-
-      if (search_it != std::cend(_pattern_formatters))
-      {
-        // we found a pattern formatter we can use. We are the only thread removing loggers and
-        // we know it is safe to re-lock the weak pointer will still be valid
-        assert(!search_it->expired());
-        transit_event->logger_base->pattern_formatter = search_it->lock();
-      }
-      else
-      {
-        // need to create a new pattern formatter
-        transit_event->logger_base->pattern_formatter = std::make_shared<PatternFormatter>(
-          transit_event->logger_base->format_pattern, transit_event->logger_base->time_pattern,
-          transit_event->logger_base->timezone);
-
-        _pattern_formatters.push_back(transit_event->logger_base->pattern_formatter);
-      }
-    }
-
-    if (transit_event->logger_base->clock_source == ClockSourceType::Tsc)
-    {
-      // If using the rdtsc clock, convert the value to nanoseconds since epoch.
-      // This conversion ensures that every transit inserted in the buffer below has a timestamp in
-      // nanoseconds since epoch, allowing compatibility with Logger objects using different clocks.
-      if (!_rdtsc_clock.load(std::memory_order_relaxed))
-      {
-        // Lazy initialization of rdtsc clock on the backend thread only if the user decides to use
-        // it. The clock requires a few seconds to init as it is taking samples first.
-        _rdtsc_clock.store(new RdtscClock{_options.rdtsc_resync_interval}, std::memory_order_release);
-        _last_rdtsc_resync_time = std::chrono::system_clock::now();
-      }
-
-      // Convert the rdtsc value to nanoseconds since epoch.
-      transit_event->timestamp =
-        _rdtsc_clock.load(std::memory_order_relaxed)->time_since_epoch(transit_event->timestamp);
-    }
-
-    // Check if strict log timestamp order is enabled and the clock source is not User.
-    if (_options.enable_strict_log_timestamp_order &
-        (transit_event->logger_base->clock_source != ClockSourceType::User))
-    {
-      // Ensure the message timestamp is not greater than ts_now.
-      // We skip checking against `ts_now` for custom timestamps by the user
-      if (QUILL_UNLIKELY((transit_event->timestamp / 1'000) >= ts_now))
-      {
-        // If the message timestamp is ahead of the current time, temporarily halt processing.
-        // This guarantees the integrity of message order and avoids missed messages.
-        // We halt processing here to avoid introducing out-of-sequence messages.
-        // This scenario prevents potential race conditions where timestamps from
-        // the last queue could overwrite those from the first queue before they are included.
-        // We return at this point without adding the current event to the buffer.
-        return false;
-      }
-    }
-
-    // we need to check and do not try to format the flush events as that wouldn't be valid
-    if (transit_event->macro_metadata->event() != MacroMetadata::Event::Flush)
-    {
-      transit_event->format_args_decoder(read_pos, _format_args_store);
-
-      if (!transit_event->macro_metadata->has_named_args())
-      {
-        _populate_formatted_log_message(transit_event, transit_event->macro_metadata->message_format());
-      }
-      else
-      {
-        // using the message_format as key for lookups
-        _named_args_format_template.assign(transit_event->macro_metadata->message_format());
-
-        if (auto const search = _named_args_templates.find(_named_args_format_template);
-            search != std::cend(_named_args_templates))
-        {
-          // process named args message when we already have parsed the format message once,
-          // and we have the names of each arg cached
-          auto const& [message_format, arg_names] = search->second;
-
-          _populate_formatted_log_message(transit_event, message_format.data());
-          _populate_formatted_named_args(transit_event, arg_names);
-        }
-        else
-        {
-          // process named args log when the message format is processed for the first time
-          // parse name of each arg and stored them to our lookup map
-          auto const [res_it, inserted] = _named_args_templates.try_emplace(
-            _named_args_format_template,
-            _process_named_args_format_message(transit_event->macro_metadata->message_format()));
-
-          auto const& [message_format, arg_names] = res_it->second;
-
-          // suppress unused warnings
-          (void)inserted;
-
-          _populate_formatted_log_message(transit_event, message_format.data());
-          _populate_formatted_named_args(transit_event, arg_names);
-        }
-      }
-    }
-    else
-    {
-      // if this is a flush event then we do not need to format anything for the
-      // transit_event, but we need to set the transit event's flush_flag pointer instead
-      uintptr_t flush_flag_tmp;
-      std::memcpy(&flush_flag_tmp, read_pos, sizeof(uintptr_t));
-      transit_event->flush_flag = reinterpret_cast<std::atomic<bool>*>(flush_flag_tmp);
-      read_pos += sizeof(uintptr_t);
-    }
-
-    if (transit_event->macro_metadata->log_level() == LogLevel::Dynamic)
-    {
-      // if this is a dynamic log level we need to read the log level from the buffer
-      std::memcpy(&transit_event->dynamic_log_level, read_pos, sizeof(transit_event->dynamic_log_level));
-      read_pos += sizeof(transit_event->dynamic_log_level);
-    }
-    else
-    {
-      // Important: if a dynamic log level is not being used, then this must
-      // not have a value, otherwise the wrong log level may be used later.
-      // We can't assume that this member (or any member of TransitEvent) has
-      // its default value because TransitEvents may be reused.
-      transit_event->dynamic_log_level = LogLevel::None;
-    }
-
-    // commit this transit event
-    thread_context->_transit_event_buffer->push_back();
-
-    return true;
-  }
-
-  /**
-   * Checks if there are pending events for caching based on the state of transit event buffers and queues.
-   * @return True if there are pending events for caching when the _transit_event_buffer is empty, false otherwise.
-   */
-  QUILL_ATTRIBUTE_HOT bool has_pending_events_for_caching_when_transit_event_buffer_empty() noexcept
-  {
-    _update_active_thread_contexts_cache();
-
-    for (ThreadContext* thread_context : _active_thread_contexts_cache)
-    {
-      if (!thread_context->_transit_event_buffer || thread_context->_transit_event_buffer->empty())
-      {
-        // if there is no _transit_event_buffer yet then check only the queue
-        if (thread_context->has_unbounded_queue_type() &&
-            !thread_context->get_spsc_queue_union().unbounded_spsc_queue.empty())
-        {
-          return true;
-        }
-        else if (thread_context->has_bounded_queue_type() &&
-                 !thread_context->get_spsc_queue_union().bounded_spsc_queue.empty())
-        {
-          return true;
-        }
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Processes the cached transit event with the minimum timestamp
-   */
-  QUILL_ATTRIBUTE_HOT bool _process_next_cached_transit_event()
-  {
-    // Get the lowest timestamp
-    uint64_t min_ts{std::numeric_limits<uint64_t>::max()};
-    UnboundedTransitEventBuffer* transit_buffer{nullptr};
-
-    for (ThreadContext* thread_context : _active_thread_contexts_cache)
-    {
-      if (thread_context->_transit_event_buffer)
-      {
-        if (TransitEvent const* te = thread_context->_transit_event_buffer->front(); te && (min_ts > te->timestamp))
-        {
-          min_ts = te->timestamp;
-          transit_buffer = thread_context->_transit_event_buffer.get();
-        }
-      }
-    }
-
-    if (!transit_buffer)
-    {
-      // all buffers are empty
-      // return false, meaning we processed a message
-      return false;
-    }
-
-    TransitEvent* transit_event = transit_buffer->front();
-    assert(transit_event && "transit_buffer is set only when transit_event is valid");
-
-    QUILL_TRY { _process_cached_transit_event(*transit_event); }
-#if !defined(QUILL_NO_EXCEPTIONS)
-    QUILL_CATCH(std::exception const& e) { _options.error_notifier(e.what()); }
-    QUILL_CATCH_ALL()
-    {
-      _options.error_notifier(std::string{"Caught unhandled exception."});
-    } // clang-format on
-#endif
-
-    // Remove this event and move to the next.
-    transit_buffer->pop_front();
-
-    return true;
-  }
-
-  /**
-   * Process a single transit event
-   */
-  QUILL_ATTRIBUTE_HOT void _process_cached_transit_event(TransitEvent& transit_event)
-  {
-    // If backend_process(...) throws we want to skip this event and move to the next, so we catch
-    // the error here instead of catching it in the parent try/catch block of main_loop
-    if (transit_event.macro_metadata->event() == MacroMetadata::Event::Log)
-    {
-      if (transit_event.log_level() != LogLevel::Backtrace)
-      {
-        _write_transit_event_to_sinks(transit_event);
-
-        // We also need to check the severity of the log message here against the backtrace
-        // Check if we should also flush the backtrace messages:
-        // After we forwarded the message we will check the severity of this message for this logger
-        // If the severity of the message is higher than the backtrace flush severity we will also
-        // flush the backtrace of the logger
-        if (QUILL_UNLIKELY(transit_event.log_level() >=
-                           transit_event.logger_base->backtrace_flush_level.load(std::memory_order_relaxed)))
-        {
-          _backtrace_storage.process(transit_event.logger_base->logger_name, [this](TransitEvent const& te)
-                                     { _write_transit_event_to_sinks(te); });
-        }
-      }
-      else
-      {
-        // this is a backtrace log and we will store it
-        _backtrace_storage.store(std::move(transit_event));
-      }
-    }
-    else if (transit_event.macro_metadata->event() == MacroMetadata::Event::InitBacktrace)
-    {
-      // we can just convert the capacity back to int here and use it
-      _backtrace_storage.set_capacity(
-        transit_event.logger_base->logger_name,
-        static_cast<uint32_t>(std::stoul(
-          std::string{transit_event.formatted_msg.begin(), transit_event.formatted_msg.end()})));
-    }
-    else if (transit_event.macro_metadata->event() == MacroMetadata::Event::FlushBacktrace)
-    {
-      // process all records in backtrace for this logger_name and log them by calling backend_process_backtrace_log_message
-      _backtrace_storage.process(transit_event.logger_base->logger_name, [this](TransitEvent const& te)
-                                 { _write_transit_event_to_sinks(te); });
-    }
-    else if (transit_event.macro_metadata->event() == MacroMetadata::Event::Flush)
-    {
-      _flush_and_run_active_sinks_loop(false);
-
-      // this is a flush event, so we need to notify the caller to continue now
-      transit_event.flush_flag->store(true);
-
-      // we also need to reset the flush_flag as the TransitEvents are re-used
-      transit_event.flush_flag = nullptr;
-    }
-  }
-
-  /**
-   * Write a transit event
-   */
-  QUILL_ATTRIBUTE_HOT void _write_transit_event_to_sinks(TransitEvent const& transit_event) const
-  {
-    std::string_view const formatted_log_message = transit_event.logger_base->pattern_formatter->format(
-      transit_event.timestamp, transit_event.thread_id, transit_event.thread_name, _process_id,
-      transit_event.logger_base->logger_name, loglevel_to_string(transit_event.log_level()),
-      *transit_event.macro_metadata, transit_event.named_args.get(),
-      std::string_view{transit_event.formatted_msg.data(), transit_event.formatted_msg.size()});
-
-    for (auto& sink : transit_event.logger_base->sinks)
-    {
-      // If all filters are okay we write this message to the file
-      if (sink->apply_all_filters(transit_event.macro_metadata, transit_event.timestamp,
-                                  transit_event.thread_id, transit_event.thread_name,
-                                  transit_event.logger_base->logger_name, transit_event.log_level(),
-                                  formatted_log_message))
-      {
-        sink->write_log_message(transit_event.macro_metadata, transit_event.timestamp,
-                                transit_event.thread_id, transit_event.thread_name,
-                                transit_event.logger_base->logger_name, transit_event.log_level(),
-                                transit_event.named_args.get(), formatted_log_message);
-      }
-    }
-  }
-
-  /**
-   * Check for dropped messages - only when bounded queue is used
-   * @param error_notifier error notifier
-   */
-  QUILL_ATTRIBUTE_HOT void _check_failure_counter(std::function<void(std::string const&)> const& error_notifier) noexcept
-  {
-    // UnboundedNoMaxLimit does not block or drop messages
-    for (ThreadContext* thread_context : _active_thread_contexts_cache)
-    {
-      if (thread_context->has_bounded_queue_type())
-      {
-        size_t const failed_messages_cnt = thread_context->get_and_reset_failure_counter();
-
-        if (QUILL_UNLIKELY(failed_messages_cnt > 0))
-        {
-          char timestamp[24];
-          time_t now = time(nullptr);
-          tm local_time;
-          localtime_rs(&now, &local_time);
-          strftime(timestamp, sizeof(timestamp), "%X", &local_time);
-
-          if (thread_context->has_dropping_queue())
-          {
-            error_notifier(fmtquill::format("{} Quill INFO: Dropped {} log messages from thread {}",
-                                            timestamp, failed_messages_cnt, thread_context->thread_id()));
-          }
-          else if (thread_context->has_blocking_queue())
-          {
-            error_notifier(
-              fmtquill::format("{} Quill INFO: Experienced {} blocking occurrences on thread {}",
-                               timestamp, failed_messages_cnt, thread_context->thread_id()));
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * Process the format of a log message that contains named args
-   * @param fmt_template a log message containing named arguments
-   * @return first: fmt string without the named arguments, second: a vector extracted keys
-   */
-  QUILL_ATTRIBUTE_HOT static std::pair<std::string, std::vector<std::string>> _process_named_args_format_message(
-    std::string_view fmt_template) noexcept
-  {
-    // It would be nice to do this at compile time and store it in macro metadata, but without
-    // constexpr vector and string in c++17 it is not possible
-    std::string fmt_str;
-    std::vector<std::string> keys;
-
-    size_t cur_pos = 0;
-
-    size_t open_bracket_pos = fmt_template.find_first_of('{');
-    while (open_bracket_pos != std::string::npos)
-    {
-      // found an open bracket
-      if (size_t const open_bracket_2_pos = fmt_template.find_first_of('{', open_bracket_pos + 1);
-          open_bracket_2_pos != std::string::npos)
-      {
-        // found another open bracket
-        if ((open_bracket_2_pos - 1) == open_bracket_pos)
-        {
-          open_bracket_pos = fmt_template.find_first_of('{', open_bracket_2_pos + 1);
-          continue;
-        }
-      }
-
-      // look for the next close bracket
-      size_t close_bracket_pos = fmt_template.find_first_of('}', open_bracket_pos + 1);
-      while (close_bracket_pos != std::string::npos)
-      {
-        // found closed bracket
-        if (size_t const close_bracket_2_pos = fmt_template.find_first_of('}', close_bracket_pos + 1);
-            close_bracket_2_pos != std::string::npos)
-        {
-          // found another open bracket
-          if ((close_bracket_2_pos - 1) == close_bracket_pos)
-          {
-            close_bracket_pos = fmt_template.find_first_of('}', close_bracket_2_pos + 1);
-            continue;
-          }
-        }
-
-        // construct a fmt string excluding the characters inside the brackets { }
-        fmt_str += std::string{fmt_template.substr(cur_pos, open_bracket_pos - cur_pos)} + "{}";
-        cur_pos = close_bracket_pos + 1;
-
-        // also add the keys to the vector
-        keys.emplace_back(fmt_template.substr(open_bracket_pos + 1, (close_bracket_pos - open_bracket_pos - 1)));
-
-        break;
-      }
-
-      open_bracket_pos = fmt_template.find_first_of('{', close_bracket_pos);
-    }
-
-    // add anything remaining after the last bracket
-    fmt_str += std::string{fmt_template.substr(cur_pos, fmt_template.length() - cur_pos)};
-    return std::make_pair(fmt_str, keys);
-  }
-
-  /**
-   * Helper function to read the unbounded queue and also report the allocation
-   * @param frontend_queue queue
-   * @param thread_context thread context
-   * @return start position of read
-   */
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT std::byte* _read_unbounded_frontend_queue(UnboundedSPSCQueue& frontend_queue,
-                                                                                ThreadContext* thread_context) const
-  {
-    auto const read_result = frontend_queue.prepare_read();
-
-    if (read_result.allocation)
-    {
-      // When allocation_info has a value it means that the queue has re-allocated
-      if (_options.error_notifier)
-      {
-        char ts[24];
-        time_t t = time(nullptr);
-        tm p;
-        localtime_rs(std::addressof(t), std::addressof(p));
-        strftime(ts, 24, "%X", std::addressof(p));
-
-        // we switched to a new here, and we also notify the user of the allocation via the
-        // error_notifier
-        _options.error_notifier(fmtquill::format(
-          "{} Quill INFO: A new SPSC queue has been allocated with a new capacity of {} bytes and "
-          "a previous capacity of {} bytes from thread {}",
-          ts, read_result.new_capacity, read_result.previous_capacity, thread_context->thread_id()));
-      }
-    }
-
-    return read_result.read_pos;
-  }
-
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT bool _check_frontend_queues_and_cached_transit_events_empty()
-  {
-    _update_active_thread_contexts_cache();
-
-    bool all_empty{true};
-
-    for (ThreadContext* thread_context : _active_thread_contexts_cache)
-    {
-      assert(thread_context->has_unbounded_queue_type() || thread_context->has_bounded_queue_type());
-
-      if (thread_context->has_unbounded_queue_type())
-      {
-        all_empty &= thread_context->get_spsc_queue_union().unbounded_spsc_queue.empty();
-      }
-      else if (thread_context->has_bounded_queue_type())
-      {
-        all_empty &= thread_context->get_spsc_queue_union().bounded_spsc_queue.empty();
-      }
-
-      if (thread_context->_transit_event_buffer)
-      {
-        all_empty &= thread_context->_transit_event_buffer->empty();
-      }
-    }
-
-    return all_empty;
-  }
-
-  /**
-   * Resyncs the rdtsc clock
-   */
-  QUILL_ATTRIBUTE_HOT void _resync_rdtsc_clock()
-  {
-    if (_rdtsc_clock.load(std::memory_order_relaxed))
-    {
-      // resync in rdtsc if we are not logging so that time_since_epoch() still works
-
-      if (auto const now = std::chrono::system_clock::now();
-          (now - _last_rdtsc_resync_time) > _options.rdtsc_resync_interval)
-      {
-        if (_rdtsc_clock.load(std::memory_order_relaxed)->resync(2500))
-        {
-          _last_rdtsc_resync_time = now;
-        }
-      }
-    }
-  }
-
-  /**
-   * Updates the active sinks cache
-   */
-  QUILL_ATTRIBUTE_HOT void _flush_and_run_active_sinks_loop(bool run_loop)
-  {
-    // Update the active sinks cache, consider only the valid loggers
-    _logger_manager.for_each_logger(
-      [this](LoggerBase* logger)
-      {
-        _active_sinks_cache.clear();
-
-        if (logger->is_valid_logger())
-        {
-          for (std::shared_ptr<Sink> const& sink : logger->sinks)
-          {
-            auto search_it = std::find_if(_active_sinks_cache.begin(), _active_sinks_cache.end(),
-                                          [sink_ptr = sink.get()](std::weak_ptr<Sink> const& elem)
-                                          {
-                                            // no one else can remove the shared pointer as this is only
-                                            // running on backend thread, lock() will always succeed
-                                            return elem.lock().get() == sink_ptr;
-                                          });
-
-            if (search_it == std::end(_active_sinks_cache))
-            {
-              _active_sinks_cache.push_back(sink);
-            }
-          }
-        }
-      });
-
-    for (auto const& sink : _active_sinks_cache)
-    {
-      std::shared_ptr<Sink> h = sink.lock();
-      if (h)
-      {
-        QUILL_TRY
-        {
-          // If an exception is thrown, catch it here to prevent it from propagating
-          // to the outer function. This prevents potential infinite loops caused by failing flush operations.
-          h->flush_sink();
-        }
-#if !defined(QUILL_NO_EXCEPTIONS)
-        QUILL_CATCH(std::exception const& e) { _options.error_notifier(e.what()); }
-        QUILL_CATCH_ALL() { _options.error_notifier(std::string{"Caught unhandled exception."}); }
-#endif
-
-        if (run_loop)
-        {
-          h->run_periodic_tasks();
-        }
-      }
-    }
-  }
-
-  /**
-   * Reloads the thread contexts in our local cache.
-   */
-  QUILL_ATTRIBUTE_HOT void _update_active_thread_contexts_cache()
-  {
-    // Check if _thread_contexts has changed. This can happen only when a new thread context is added by any Logger
-    if (QUILL_UNLIKELY(_thread_context_manager.new_thread_context_flag()))
-    {
-      _active_thread_contexts_cache.clear();
-      _thread_context_manager.for_each_thread_context(
-        [this](ThreadContext* thread_context)
-        {
-          if (!thread_context->_transit_event_buffer)
-          {
-            // Lazy initialise the _transit_event_buffer for this thread_context
-            thread_context->_transit_event_buffer =
-              std::make_shared<UnboundedTransitEventBuffer>(_options.transit_event_buffer_initial_capacity);
-          }
-
-          // We do not skip invalidated && empty queue thread contexts as this is very rare,
-          // so instead we just add them and expect them to be cleaned in the next iteration
-          _active_thread_contexts_cache.push_back(thread_context);
-        });
-    }
-  }
-
-  /**
-   * Looks into the _thread_context_cache and removes all thread contexts that are 1) invalidated
-   * and 2) have an empty frontend queue and no cached transit events to process
-   *
-   * @note Only called by the backend thread
-   */
-  QUILL_ATTRIBUTE_HOT void _cleanup_invalidated_thread_contexts()
-  {
-    if (!_thread_context_manager.has_invalid_thread_context())
-    {
-      return;
-    }
-
-    auto find_invalid_and_empty_thread_context_callback = [](ThreadContext* thread_context)
-    {
-      // If the thread context is invalid it means the thread that created it has now died.
-      // We also want to empty the queue from all LogRecords before removing the thread context
-      if (!thread_context->is_valid_context())
-      {
-        bool empty_frontend_queue{false};
-
-        assert(thread_context->has_unbounded_queue_type() || thread_context->has_bounded_queue_type());
-
-        // detect empty queue
-        if (thread_context->has_unbounded_queue_type())
-        {
-          empty_frontend_queue = thread_context->get_spsc_queue_union().unbounded_spsc_queue.empty();
-        }
-        else if (thread_context->has_bounded_queue_type())
-        {
-          empty_frontend_queue = thread_context->get_spsc_queue_union().bounded_spsc_queue.empty();
-        }
-
-        if (empty_frontend_queue)
-        {
-          if (thread_context->_transit_event_buffer)
-          {
-            if (thread_context->_transit_event_buffer->empty())
-            {
-              return true;
-            }
-          }
-          else
-          {
-            // if _transit_event_buffer is not used, checking for the empty queue is enough
-            return true;
-          }
-        }
-      }
-
-      return false;
-    };
-
-    // First we iterate our existing cache and we look for any invalidated contexts
-    auto found_invalid_and_empty_thread_context =
-      std::find_if(_active_thread_contexts_cache.begin(), _active_thread_contexts_cache.end(),
-                   find_invalid_and_empty_thread_context_callback);
-
-    while (QUILL_UNLIKELY(found_invalid_and_empty_thread_context != std::end(_active_thread_contexts_cache)))
-    {
-      // if we found anything then remove it - Here if we have more than one to remove we will
-      // try to acquire the lock multiple times, but it should be fine as it is unlikely to have
-      // that many to remove
-      _thread_context_manager.remove_shared_invalidated_thread_context(*found_invalid_and_empty_thread_context);
-
-      // We also need to remove it from _thread_context_cache, that is used only by the backend
-      _active_thread_contexts_cache.erase(found_invalid_and_empty_thread_context);
-
-      // And then look again
-      found_invalid_and_empty_thread_context =
-        std::find_if(_active_thread_contexts_cache.begin(), _active_thread_contexts_cache.end(),
-                     find_invalid_and_empty_thread_context_callback);
-    }
-  }
-
-  /**
-   * Cleans up any invalidated loggers
-   */
-  QUILL_ATTRIBUTE_HOT void _cleanup_invalidated_loggers()
-  {
-    // since there are no messages we can check for invalidated loggers and clean them up
-    std::vector<std::string> const removed_loggers = _logger_manager.cleanup_invalidated_loggers(
-      [this]()
-      {
-        // check the queues are empty each time before removing a logger to avoid
-        // potential race condition of the logger* still being in the queue
-        return _check_frontend_queues_and_cached_transit_events_empty();
-      });
-
-    if (!removed_loggers.empty())
-    {
-      // if loggers were removed also check for sinks to remove
-      // cleanup_unused_sinks is expensive and should be only called when it is needed
-      _sink_manager.cleanup_unused_sinks();
-
-      // Clean up any expired pattern_formatters
-      for (auto it = _pattern_formatters.begin(); it != _pattern_formatters.end();)
-      {
-        if (it->expired())
-        {
-          it = _pattern_formatters.erase(it);
-        }
-        else
-        {
-          ++it;
-        }
-      }
-
-      // Clean up any backtrace storage
-      for (auto const& logger_name : removed_loggers)
-      {
-        _backtrace_storage.erase(logger_name);
-      }
-    }
-  }
-
-  /**
-   * This function takes an `arg_store` containing multiple arguments and formats them into
-   * a single string using a generated format string. Due to limitations in the ability to
-   * iterate and format each argument individually in libfmt, this approach is used.
-   * After formatting, the string is split to isolate each formatted value.
-   */
-  static void _format_and_split_arguments(std::vector<std::pair<std::string, std::string>>& named_args,
-                                          DynamicFormatArgStore const& arg_store)
-  {
-    // Generate a format string
-    std::string format_string;
-    static constexpr std::string_view delimiter{"\x01\x02\x03"};
-
-    for (size_t i = 0; i < named_args.size(); ++i)
-    {
-      format_string += "{}";
-      if (i < named_args.size() - 1)
-      {
-        format_string += delimiter;
-      }
-    }
-
-    // Format all values to a single string
-    std::string formatted_values_str;
-    fmtquill::vformat_to(
-      std::back_inserter(formatted_values_str), format_string,
-      fmtquill::basic_format_args<fmtquill::format_context>{arg_store.get_types(), arg_store.data()});
-
-    // Split the formatted_values to isolate each value
-    size_t start = 0;
-    size_t end = 0;
-    size_t idx = 0;
-
-    while ((end = formatted_values_str.find(delimiter, start)) != std::string::npos)
-    {
-      if (idx < named_args.size())
-      {
-        named_args[idx++].second = formatted_values_str.substr(start, end - start);
-      }
-      start = end + delimiter.length();
-    }
-
-    if (idx < named_args.size())
-    {
-      named_args[idx].second = formatted_values_str.substr(start);
-    }
-  }
-
-  void _populate_formatted_named_args(TransitEvent* transit_event, std::vector<std::string> const& arg_names)
-  {
-    if (!transit_event->named_args)
-    {
-      // named arg logs, we lazy initialise the named args buffer
-      transit_event->named_args = std::make_unique<std::vector<std::pair<std::string, std::string>>>();
-    }
-    else
-    {
-      transit_event->named_args->clear();
-    }
-
-    transit_event->named_args->resize(arg_names.size());
-
-    // We first populate the arg names in the transit buffer
-    for (size_t i = 0; i < arg_names.size(); ++i)
-    {
-      (*transit_event->named_args)[i].first = arg_names[i];
-    }
-
-    // Then populate all the values of each arg
-    QUILL_TRY { _format_and_split_arguments(*transit_event->named_args, _format_args_store); }
-#if !defined(QUILL_NO_EXCEPTIONS)
-    QUILL_CATCH(std::exception const&)
-    {
-      // This catch block simply catches the exception.
-      // Since the error has already been handled in _populate_formatted_log_message,
-      // there is no additional action required here.
-    }
-#endif
-  }
-
-  QUILL_ATTRIBUTE_HOT void _populate_formatted_log_message(TransitEvent* transit_event, char const* message_format)
-  {
-    transit_event->formatted_msg.clear();
-
-    QUILL_TRY
-    {
-      fmtquill::vformat_to(std::back_inserter(transit_event->formatted_msg), message_format,
-                           fmtquill::basic_format_args<fmtquill::format_context>{
-                             _format_args_store.get_types(), _format_args_store.data()});
-    }
-#if !defined(QUILL_NO_EXCEPTIONS)
-    QUILL_CATCH(std::exception const& e)
-    {
-      transit_event->formatted_msg.clear();
-      std::string const error = fmtquill::format(
-        "[Could not format log statement. message: \"{}\", location: \"{}\", error: \"{}\"]",
-        transit_event->macro_metadata->message_format(),
-        transit_event->macro_metadata->short_source_location(), e.what());
-
-      transit_event->formatted_msg.append(error);
-      _options.error_notifier(error);
-    }
-#endif
-  }
-
-private:
-  ThreadContextManager& _thread_context_manager = ThreadContextManager::instance();
-  SinkManager& _sink_manager = SinkManager::instance();
-  LoggerManager& _logger_manager = LoggerManager::instance();
-  BackendOptions _options;
-
-  std::thread _worker_thread;
-
-  std::atomic<RdtscClock*> _rdtsc_clock{nullptr}; /** rdtsc clock if enabled **/
-
-  DynamicFormatArgStore _format_args_store; /** Format args tmp storage as member to avoid reallocation */
-  std::vector<std::weak_ptr<Sink>> _active_sinks_cache;
-  std::vector<ThreadContext*> _active_thread_contexts_cache;
-
-  std::vector<std::weak_ptr<PatternFormatter>> _pattern_formatters;
-
-  BacktraceStorage _backtrace_storage; /** Stores a vector of backtrace messages per logger name */
-  std::unordered_map<std::string, std::pair<std::string, std::vector<std::string>>> _named_args_templates; /** Avoid re-formating the same named args log template each time */
-
-  /** Id of the current running process **/
-  std::string _process_id;
-  std::string _named_args_format_template; /** to avoid allocation each time **/
-  std::chrono::system_clock::time_point _last_rdtsc_resync_time;
-  std::atomic<uint32_t> _worker_thread_id{0}; /** cached backend worker thread id */
-
-  std::atomic<bool> _is_worker_running{false}; /** The spawned backend thread status */
-
-  alignas(CACHE_LINE_ALIGNED) std::mutex _wake_up_mutex;
-  std::condition_variable _wake_up_cv;
-  bool _wake_up_flag{false};
-};
-} // namespace quill::detail
diff --git a/subprojects/quill-4.2.0/quill/include/quill/backend/BacktraceStorage.h b/subprojects/quill-4.2.0/quill/include/quill/backend/BacktraceStorage.h
deleted file mode 100644
index 40cebd1..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/backend/BacktraceStorage.h
+++ /dev/null
@@ -1,198 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/backend/TransitEvent.h"
-#include "quill/core/Attributes.h"
-#include "quill/core/LoggerBase.h"
-#include "quill/core/QuillError.h"
-
-#include <cstdint>
-#include <functional>
-#include <string>
-#include <string_view>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-namespace quill::detail
-{
-/**
- * Stores N max messages per logger name in a vector.
- * For simplicity this class is used ONLY by the backend worker thread.
- * We push to the queue a BacktraceCommand event to communicate this from the frontend caller threads
- */
-class BacktraceStorage
-{
-public:
-  BacktraceStorage() = default;
-  ~BacktraceStorage()
-  {
-    // we want to clear all messages first, calling deallocate on the free list allocator before destructing
-    _stored_records_map.clear();
-  }
-
-  /**
-   * Stores an object to a vector that maps to logger_name
-   * @param transit_event transit_event
-   */
-  void store(TransitEvent transit_event)
-  {
-    auto const stored_records_it = _stored_records_map.find(transit_event.logger_base->get_logger_name());
-
-    if (QUILL_UNLIKELY(stored_records_it == _stored_records_map.end()))
-    {
-      // We have never used backtrace this logger name before, need to call set capacity first
-      QUILL_THROW(QuillError{
-        "logger->init_backtrace(...) needs to be called first before using LOG_BACKTRACE(...)."});
-    }
-
-    // we found a stored vector for this logger name and we have to update it
-    StoredRecordInfo& stored_object_info = stored_records_it->second;
-
-    if (stored_object_info.stored_records_collection.size() < stored_object_info.capacity)
-    {
-      // We are still growing the vector to max capacity
-      auto& emplaced = stored_object_info.stored_records_collection.emplace_back(
-        std::string{transit_event.thread_name}, std::string{transit_event.thread_id}, std::move(transit_event));
-
-      // we want to point the transit event objects to ours because they can point to invalid memory
-      // if the thread is destructed
-      emplaced.transit_event.thread_name = emplaced.thread_name;
-      emplaced.transit_event.thread_id = emplaced.thread_id;
-    }
-    else
-    {
-      // Store the object in the vector
-      StoredTransitEvent& ste = stored_object_info.stored_records_collection[stored_object_info.index];
-      ste = StoredTransitEvent{std::string{transit_event.thread_name},
-                               std::string{transit_event.thread_id}, std::move(transit_event)};
-
-      // we want to point the transit event objects to ours because they can point to invalid memory
-      // if the thread is destructed
-      ste.transit_event.thread_name = ste.thread_name;
-      ste.transit_event.thread_id = ste.thread_id;
-
-      // Update the index wrapping around the vector capacity
-      if (stored_object_info.index < stored_object_info.capacity - 1)
-      {
-        stored_object_info.index += 1;
-      }
-      else
-      {
-        stored_object_info.index = 0;
-      }
-    }
-  }
-
-  /**
-   * Calls the provided callback on all stored objects. The stored objects are provided
-   * in order from the first one (oldest record) to the last one (latest record)
-   */
-  void process(std::string const& logger_name, std::function<void(TransitEvent const&)> const& callback)
-  {
-    auto const stored_records_it = _stored_records_map.find(logger_name);
-
-    if (QUILL_UNLIKELY(stored_records_it == _stored_records_map.end()))
-    {
-      // Not found, Nothing to iterate
-      return;
-    }
-
-    // we found stored messages for this logger
-    uint32_t index = stored_records_it->second.index;
-    StoredRecordsCollection& stored_record_collection = stored_records_it->second.stored_records_collection;
-    // Iterate retrieved records in order from first message using index
-    for (uint32_t i = 0; i < stored_record_collection.size(); ++i)
-    {
-      // Give to the user callback the thread id and the RecordBase pointer
-      callback(stored_record_collection[index].transit_event);
-
-      // We wrap around to iterate all messages
-      if (index < stored_record_collection.size() - 1)
-      {
-        index += 1;
-      }
-      else
-      {
-        index = 0;
-      }
-    }
-
-    // finally clean all messages
-    stored_record_collection.clear();
-  }
-
-  /**
-   * Insert a new StoredObject with the given capacity
-   * @note This has to be called to set a capacity, before a call to store
-   * @param logger_name The logger name to set this capacity
-   * @param capacity capacity value
-   */
-  void set_capacity(std::string const& logger_name, uint32_t capacity)
-  {
-    auto inserted_it = _stored_records_map.emplace(std::string{logger_name}, StoredRecordInfo{capacity});
-
-    if (!inserted_it.second)
-    {
-      StoredRecordInfo& stored_object_info = inserted_it.first->second;
-
-      // We could not insert, the user called set_backtrace_capacity for a
-      // second time while one was active. In this case we will clear the existing one and
-      // store the new capacity if the new capacity is different
-      if (stored_object_info.capacity != capacity)
-      {
-        stored_object_info.stored_records_collection.clear();
-        stored_object_info.capacity = capacity;
-      }
-    }
-  }
-
-  /***/
-  void erase(std::string const& logger_name) { _stored_records_map.erase(logger_name); }
-
-private:
-  /**
-   * We use this to take o copy of some objects that are out of space when a thread finishes but
-   * the transit events are still in the buffer
-   */
-  struct StoredTransitEvent
-  {
-    StoredTransitEvent(std::string thread_name, std::string thread_id, TransitEvent transit_event)
-      : thread_name(std::move(thread_name)),
-        thread_id(std::move(thread_id)),
-        transit_event(std::move(transit_event))
-    {
-    }
-
-    std::string thread_name;
-    std::string thread_id;
-    TransitEvent transit_event;
-  };
-
-  using StoredRecordsCollection = std::vector<StoredTransitEvent>;
-
-  /**
-   * We map each logger name to this type
-   */
-  struct StoredRecordInfo
-  {
-    explicit StoredRecordInfo(uint32_t capacity) : capacity(capacity)
-    {
-      // also reserve the vector
-      stored_records_collection.reserve(capacity);
-    }
-
-    uint32_t capacity;                                   /** The maximum capacity for this */
-    uint32_t index{0};                                   /** Our current index */
-    StoredRecordsCollection stored_records_collection{}; /** A vector holding stored objects */
-  };
-
-private:
-  /** A map where we store a vector of stored records for each logger name. We use the vectors like a ring buffer and loop around */
-  std::unordered_map<std::string, StoredRecordInfo> _stored_records_map;
-};
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/backend/PatternFormatter.h b/subprojects/quill-4.2.0/quill/include/quill/backend/PatternFormatter.h
deleted file mode 100644
index 0d0a1ea..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/backend/PatternFormatter.h
+++ /dev/null
@@ -1,508 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/backend/TimestampFormatter.h"
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/format.h"
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/FormatBuffer.h"
-#include "quill/core/MacroMetadata.h"
-#include "quill/core/QuillError.h"
-
-#include <array>
-#include <bitset>
-#include <chrono>
-#include <cstddef>
-#include <cstdint>
-#include <iterator>
-#include <string>
-#include <string_view>
-#include <tuple>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-namespace quill
-{
-class PatternFormatter
-{
-  /** Public classes **/
-public:
-  /**
-   * Stores the precision of the timestamp
-   */
-  enum class TimestampPrecision : uint8_t
-  {
-    None,
-    MilliSeconds,
-    MicroSeconds,
-    NanoSeconds
-  };
-
-  enum Attribute : uint8_t
-  {
-    Time = 0,
-    FileName,
-    CallerFunction,
-    LogLevel,
-    LogLevelId,
-    LineNumber,
-    Logger,
-    FullPath,
-    ThreadId,
-    ThreadName,
-    ProcessId,
-    SourceLocation,
-    ShortSourceLocation,
-    Message,
-    Tags,
-    NamedArgs,
-    ATTR_NR_ITEMS
-  };
-
-  /** Main PatternFormatter class **/
-public:
-  /**
-   * Constructor for a PatterFormatter with a custom format
-   * @param format_pattern format_pattern a format string.
-   *
-   * The following attribute names can be used with the corresponding placeholder in a %-style format string.
-   * @note: The same attribute can not be used twice in the same format pattern
-   *
-   * %(time)                    - Human-readable timestamp representing when the log statement was created.
-   * %(file_name)               - Name of the source file where the logging call was issued.
-   * %(full_path)               - Full path of the source file where the logging call was issued.
-   * %(caller_function)         - Name of the function containing the logging call.
-   * %(log_level)               - Textual representation of the logging level for the message.
-   * %(log_level_id)            - Single-letter identifier representing the logging level.
-   * %(line_number)             - Line number in the source file where the logging call was issued.
-   * %(logger)                  - Name of the logger used to log the call.
-   * %(message)                 - The logged message itself.
-   * %(thread_id)               - ID of the thread in which the logging call was made.
-   * %(thread_name)             - Name of the thread. Must be set before the first log statement on that thread.
-   * %(process_id)              - ID of the process in which the logging call was made.
-   * %(source_location)         - Full source file path and line number as a single string.
-   * %(short_source_location)   - Shortened source file name and line number as a single string.
-   * %(tags)                    - Additional custom tags appended to the message when _WITH_TAGS macros are used.
-   * %(named_args)              - Key-value pairs appended to the message. Only applicable when the message has named args; remains empty otherwise.
-   *
-   * @param time_format The format of the date. Same as strftime() format with extra specifiers `%Qms` `%Qus` `Qns`
-   * @param timestamp_timezone The timezone of the timestamp, local_time or gmt_time
-   *
-   * @throws on invalid format string
-   */
-  explicit PatternFormatter(
-    std::string format_pattern =
-      "%(time) [%(thread_id)] %(short_source_location:<28) LOG_%(log_level:<9) "
-      "%(logger:<12) %(message)",
-    std::string const& time_format = "%H:%M:%S.%Qns", Timezone timestamp_timezone = Timezone::LocalTime)
-    : _format_pattern(std::move(format_pattern)), _timestamp_formatter(time_format, timestamp_timezone)
-  {
-    _set_pattern();
-  }
-
-  PatternFormatter(PatternFormatter const& other) = delete;
-  PatternFormatter(PatternFormatter&& other) noexcept = delete;
-  PatternFormatter& operator=(PatternFormatter const& other) = delete;
-  PatternFormatter& operator=(PatternFormatter&& other) noexcept = delete;
-
-  /**
-   * Destructor
-   */
-  ~PatternFormatter() = default;
-
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT std::string_view format(
-    uint64_t timestamp, std::string_view thread_id, std::string_view thread_name, std::string_view process_id,
-    std::string_view logger, std::string_view log_level, MacroMetadata const& log_statement_metadata,
-    std::vector<std::pair<std::string, std::string>> const* named_args, std::string_view log_msg)
-  {
-    if (_fmt_format.empty())
-    {
-      // nothing to format when the given format is empty. This is useful e.g. in the
-      // JsonFileSink if we want to skip formatting the main message
-      return std::string_view{};
-    }
-
-    // clear out existing buffer
-    _formatted_log_message_buffer.clear();
-
-    if (_is_set_in_pattern[Attribute::Time])
-    {
-      _set_arg_val<Attribute::Time>(_timestamp_formatter.format_timestamp(std::chrono::nanoseconds{timestamp}));
-    }
-
-    if (_is_set_in_pattern[Attribute::FileName])
-    {
-      _set_arg_val<Attribute::FileName>(log_statement_metadata.file_name());
-    }
-
-    if (_is_set_in_pattern[Attribute::CallerFunction])
-    {
-      _set_arg_val<Attribute::CallerFunction>(log_statement_metadata.caller_function());
-    }
-
-    if (_is_set_in_pattern[Attribute::LogLevel])
-    {
-      _set_arg_val<Attribute::LogLevel>(log_level);
-    }
-
-    if (_is_set_in_pattern[Attribute::LogLevelId])
-    {
-      _set_arg_val<Attribute::LogLevelId>(log_statement_metadata.log_level_id());
-    }
-
-    if (_is_set_in_pattern[Attribute::LineNumber])
-    {
-      _set_arg_val<Attribute::LineNumber>(log_statement_metadata.line());
-    }
-
-    if (_is_set_in_pattern[Attribute::Logger])
-    {
-      _set_arg_val<Attribute::Logger>(logger);
-    }
-
-    if (_is_set_in_pattern[Attribute::FullPath])
-    {
-      _set_arg_val<Attribute::FullPath>(log_statement_metadata.full_path());
-    }
-
-    if (_is_set_in_pattern[Attribute::ThreadId])
-    {
-      _set_arg_val<Attribute::ThreadId>(thread_id);
-    }
-
-    if (_is_set_in_pattern[Attribute::ThreadName])
-    {
-      _set_arg_val<Attribute::ThreadName>(thread_name);
-    }
-
-    if (_is_set_in_pattern[Attribute::ProcessId])
-    {
-      _set_arg_val<Attribute::ProcessId>(process_id);
-    }
-
-    if (_is_set_in_pattern[Attribute::SourceLocation])
-    {
-      _set_arg_val<Attribute::SourceLocation>(log_statement_metadata.source_location());
-    }
-
-    if (_is_set_in_pattern[Attribute::ShortSourceLocation])
-    {
-      _set_arg_val<Attribute::ShortSourceLocation>(log_statement_metadata.short_source_location());
-    }
-
-    if (_is_set_in_pattern[Attribute::NamedArgs])
-    {
-      _formatted_named_args_buffer.clear();
-
-      if (named_args)
-      {
-        for (size_t i = 0; i < named_args->size(); ++i)
-        {
-          _formatted_named_args_buffer.append((*named_args)[i].first);
-          _formatted_named_args_buffer.append(std::string_view{": "});
-          _formatted_named_args_buffer.append((*named_args)[i].second);
-
-          if (i != named_args->size() - 1)
-          {
-            _formatted_named_args_buffer.append(std::string_view{", "});
-          }
-        }
-      }
-
-      _set_arg_val<Attribute::NamedArgs>(
-        std::string_view{_formatted_named_args_buffer.data(), _formatted_named_args_buffer.size()});
-    }
-
-    if (_is_set_in_pattern[Attribute::Tags])
-    {
-      if (log_statement_metadata.tags())
-      {
-        _tags.clear();
-        log_statement_metadata.tags()->format(_tags);
-        _set_arg_val<Attribute::Tags>(_tags);
-      }
-      else
-      {
-        _set_arg_val<Attribute::Tags>(std::string{});
-      }
-    }
-
-    _set_arg_val<Attribute::Message>(log_msg);
-
-    fmtquill::vformat_to(std::back_inserter(_formatted_log_message_buffer), _fmt_format,
-                         fmtquill::basic_format_args(_args.data(), static_cast<int>(_args.size())));
-
-    return std::string_view{_formatted_log_message_buffer.data(), _formatted_log_message_buffer.size()};
-  }
-
-  QUILL_ATTRIBUTE_HOT std::string_view format_timestamp(std::chrono::nanoseconds timestamp)
-  {
-    return _timestamp_formatter.format_timestamp(timestamp);
-  }
-
-  /***/
-  QUILL_NODISCARD detail::TimestampFormatter const& timestamp_formatter() const noexcept
-  {
-    return _timestamp_formatter;
-  }
-
-  /***/
-  QUILL_NODISCARD std::string const& format_pattern() const noexcept { return _format_pattern; }
-
-private:
-  void _set_pattern()
-  {
-    // the order we pass the arguments here must match with the order of Attribute enum
-    using namespace fmtquill::literals;
-    std::tie(_fmt_format, _order_index) = _generate_fmt_format_string(
-      _is_set_in_pattern, _format_pattern, "time"_a = "", "file_name"_a = "",
-      "caller_function"_a = "", "log_level"_a = "", "log_level_id"_a = "", "line_number"_a = "",
-      "logger"_a = "", "full_path"_a = "", "thread_id"_a = "", "thread_name"_a = "",
-      "process_id"_a = "", "source_location"_a = "", "short_source_location"_a = "",
-      "message"_a = "", "tags"_a = "", "named_args"_a = "");
-
-    _set_arg<Attribute::Time>(std::string_view("time"));
-    _set_arg<Attribute::FileName>(std::string_view("file_name"));
-    _set_arg<Attribute::CallerFunction>("caller_function");
-    _set_arg<Attribute::LogLevel>(std::string_view("log_level"));
-    _set_arg<Attribute::LogLevelId>(std::string_view("log_level_id"));
-    _set_arg<Attribute::LineNumber>("line_number");
-    _set_arg<Attribute::Logger>(std::string_view("logger"));
-    _set_arg<Attribute::FullPath>(std::string_view("full_path"));
-    _set_arg<Attribute::ThreadId>(std::string_view("thread_id"));
-    _set_arg<Attribute::ThreadName>(std::string_view("thread_name"));
-    _set_arg<Attribute::ProcessId>(std::string_view("process_id"));
-    _set_arg<Attribute::SourceLocation>("source_location");
-    _set_arg<Attribute::ShortSourceLocation>("short_source_location");
-    _set_arg<Attribute::Message>(std::string_view("message"));
-    _set_arg<Attribute::Tags>(std::string_view("tags"));
-    _set_arg<Attribute::NamedArgs>(std::string_view("named_args"));
-  }
-
-  /***/
-  template <size_t I, typename T>
-  void _set_arg(T const& arg)
-  {
-    _args[_order_index[I]] = fmtquill::detail::make_arg<fmtquill::format_context>(arg);
-  }
-
-  template <size_t I, typename T>
-  void _set_arg_val(T const& arg)
-  {
-    fmtquill::detail::value<fmtquill::format_context>& value_ =
-      *(reinterpret_cast<fmtquill::detail::value<fmtquill::format_context>*>(
-        std::addressof(_args[_order_index[I]])));
-
-    value_ = fmtquill::detail::arg_mapper<fmtquill::format_context>().map(arg);
-  }
-
-  /***/
-  PatternFormatter::Attribute static _attribute_from_string(std::string const& attribute_name)
-  {
-    // don't make this static as it breaks on windows with atexit when backend worker stops
-    std::unordered_map<std::string, PatternFormatter::Attribute> const attr_map = {
-      {"time", PatternFormatter::Attribute::Time},
-      {"file_name", PatternFormatter::Attribute::FileName},
-      {"caller_function", PatternFormatter::Attribute::CallerFunction},
-      {"log_level", PatternFormatter::Attribute::LogLevel},
-      {"log_level_id", PatternFormatter::Attribute::LogLevelId},
-      {"line_number", PatternFormatter::Attribute::LineNumber},
-      {"logger", PatternFormatter::Attribute::Logger},
-      {"full_path", PatternFormatter::Attribute::FullPath},
-      {"thread_id", PatternFormatter::Attribute::ThreadId},
-      {"thread_name", PatternFormatter::Attribute::ThreadName},
-      {"process_id", PatternFormatter::Attribute::ProcessId},
-      {"source_location", PatternFormatter::Attribute::SourceLocation},
-      {"short_source_location", PatternFormatter::Attribute::ShortSourceLocation},
-      {"message", PatternFormatter::Attribute::Message},
-      {"tags", PatternFormatter::Attribute::Tags},
-      {"named_args", PatternFormatter::Attribute::NamedArgs}};
-
-    auto const search = attr_map.find(attribute_name);
-
-    if (QUILL_UNLIKELY(search == attr_map.cend()))
-    {
-      QUILL_THROW(QuillError{
-        std::string{"Attribute enum value does not exist for attribute with name " + attribute_name}});
-    }
-
-    return search->second;
-  }
-
-  /***/
-  template <size_t, size_t>
-  constexpr void _store_named_args(std::array<fmtquill::detail::named_arg_info<char>, PatternFormatter::Attribute::ATTR_NR_ITEMS>&)
-  {
-  }
-
-  /***/
-  template <size_t Idx, size_t NamedIdx, typename Arg, typename... Args>
-  constexpr void _store_named_args(
-    std::array<fmtquill::detail::named_arg_info<char>, PatternFormatter::Attribute::ATTR_NR_ITEMS>& named_args_store,
-    const Arg& arg, const Args&... args)
-  {
-    named_args_store[NamedIdx] = {arg.name, Idx};
-    _store_named_args<Idx + 1, NamedIdx + 1>(named_args_store, args...);
-  }
-
-  /**
-   * Convert the pattern to fmt format string and also populate the order index array
-   * e.g. given :
-   *   "%(time) [%(thread_id)] %(file_name):%(line_number) %(log_level:<12) %(logger) - "
-   *
-   * is changed to :
-   *  {} [{}] {}:{} {:<12} {} -
-   *
-   *  with a order index of :
-   *  i: 0 order idx[i] is: 0 - %(time)
-   *  i: 1 order idx[i] is: 2 - %(file_name)
-   *  i: 2 order idx[i] is: 10 - empty
-   *  i: 3 order idx[i] is: 4 - %(log_level)
-   *  i: 4 order idx[i] is: 10 - empty
-   *  i: 5 order idx[i] is: 3 - %(line_number)
-   *  i: 6 order idx[i] is: 5 - %(logger)
-   *  i: 7 order idx[i] is: 10 - empty
-   *  i: 8 order idx[i] is: 1 - %(thread_id)
-   *  i: 9 order idx[i] is: 10 - empty
-   *  i: 10 order idx[i] is: 10 - empty
-   * @tparam Args Args
-   * @param is_set_in_pattern is set in pattern
-   * @param pattern pattern
-   * @param args args
-   * @return process_id pattern
-   */
-  template <typename... Args>
-  QUILL_NODISCARD std::pair<std::string, std::array<size_t, PatternFormatter::Attribute::ATTR_NR_ITEMS>> _generate_fmt_format_string(
-    std::bitset<PatternFormatter::Attribute::ATTR_NR_ITEMS>& is_set_in_pattern, std::string pattern,
-    Args const&... args)
-  {
-    // Attribute enum and the args we are passing here must be in sync
-    static_assert(PatternFormatter::Attribute::ATTR_NR_ITEMS == sizeof...(Args));
-
-    pattern += "\n";
-
-    std::array<size_t, PatternFormatter::Attribute::ATTR_NR_ITEMS> order_index{};
-    order_index.fill(PatternFormatter::Attribute::ATTR_NR_ITEMS - 1);
-
-    std::array<fmtquill::detail::named_arg_info<char>, PatternFormatter::Attribute::ATTR_NR_ITEMS> named_args{};
-    _store_named_args<0, 0>(named_args, args...);
-    uint8_t arg_idx = 0;
-
-    // we will replace all %(....) with {} to construct a string to pass to fmt library
-    size_t arg_identifier_pos = pattern.find_first_of('%');
-    while (arg_identifier_pos != std::string::npos)
-    {
-      if (size_t const open_paren_pos = pattern.find_first_of('(', arg_identifier_pos);
-          open_paren_pos != std::string::npos && (open_paren_pos - arg_identifier_pos) == 1)
-      {
-        // if we found '%(' we have a matching pattern and we now need to get the closed paren
-        size_t const closed_paren_pos = pattern.find_first_of(')', open_paren_pos);
-
-        if (closed_paren_pos == std::string::npos)
-        {
-          QUILL_THROW(QuillError{"Invalid format pattern"});
-        }
-
-        // We have everything, get the substring, this time including '%( )'
-        std::string attr = pattern.substr(arg_identifier_pos, (closed_paren_pos + 1) - arg_identifier_pos);
-
-        // find any user format specifiers
-        size_t const pos = attr.find(':');
-        std::string attr_name;
-
-        if (pos != std::string::npos)
-        {
-          // we found user format specifiers that we want to keep.
-          // e.g. %(short_source_location:<32)
-
-          // Get only the format specifier
-          // e.g. :<32
-          std::string custom_format_specifier = attr.substr(pos);
-          custom_format_specifier.pop_back(); // remove the ")"
-
-          // replace with the pattern with the correct value
-          std::string value;
-          value += "{";
-          value += custom_format_specifier;
-          value += "}";
-
-          // e.g. {:<32}
-          pattern.replace(arg_identifier_pos, attr.length(), value);
-
-          // Get the part that is the named argument
-          // e.g. short_source_location
-          attr_name = attr.substr(2, pos - 2);
-        }
-        else
-        {
-          // Make the replacement.
-          pattern.replace(arg_identifier_pos, attr.length(), "{}");
-
-          // Get the part that is the named argument
-          // e.g. short_source_location
-          attr.pop_back(); // remove the ")"
-
-          attr_name = attr.substr(2, attr.size());
-        }
-
-        // reorder
-        int id = -1;
-
-        for (size_t i = 0; i < PatternFormatter::Attribute::ATTR_NR_ITEMS; ++i)
-        {
-          if (named_args[i].name == attr_name)
-          {
-            id = named_args[i].id;
-            break;
-          }
-        }
-
-        if (id < 0)
-        {
-          QUILL_THROW(QuillError{"Invalid format pattern, attribute with name \"" + attr_name + "\" is invalid"});
-        }
-
-        order_index[static_cast<size_t>(id)] = arg_idx++;
-
-        // Also set the value as used in the pattern in our bitset for lazy evaluation
-        PatternFormatter::Attribute const attr_enum_value = _attribute_from_string(attr_name);
-        is_set_in_pattern.set(attr_enum_value);
-
-        // Look for the next pattern to replace
-        arg_identifier_pos = pattern.find_first_of('%');
-      }
-      else
-      {
-        // search for the next '%'
-        arg_identifier_pos = pattern.find_first_of('%', arg_identifier_pos + 1);
-      }
-    }
-
-    return std::make_pair(pattern, order_index);
-  }
-
-private:
-  std::string _format_pattern;
-  std::string _fmt_format;
-  std::string _tags;
-
-  /** Each named argument in the format_pattern is mapped in order to this array **/
-  std::array<size_t, Attribute::ATTR_NR_ITEMS> _order_index{};
-  std::array<fmtquill::basic_format_arg<fmtquill::format_context>, Attribute::ATTR_NR_ITEMS> _args{};
-  std::bitset<Attribute::ATTR_NR_ITEMS> _is_set_in_pattern;
-
-  /** class responsible for formatting the timestamp */
-  detail::TimestampFormatter _timestamp_formatter;
-
-  /** The buffer where we store each formatted string, also stored as class member to avoid
-   * re-allocations **/
-  fmtquill::basic_memory_buffer<char, 512> _formatted_log_message_buffer;
-  fmtquill::basic_memory_buffer<char, 512> _formatted_named_args_buffer;
-};
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/backend/RdtscClock.h b/subprojects/quill-4.2.0/quill/include/quill/backend/RdtscClock.h
deleted file mode 100644
index f07b141..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/backend/RdtscClock.h
+++ /dev/null
@@ -1,212 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/Rdtsc.h"
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <chrono>
-#include <cstdint>
-#include <cstdio>
-#include <ratio>
-
-namespace quill::detail
-{
-/**
- * Converts tsc ticks to nanoseconds since epoch
- */
-class RdtscClock
-{
-  /**
-   * A static class that calculates the rdtsc ticks per second
-   */
-  class RdtscTicks
-  {
-  public:
-    QUILL_NODISCARD static RdtscTicks& instance()
-    {
-      static RdtscTicks inst;
-      return inst;
-    }
-
-    /***/
-    QUILL_NODISCARD double ns_per_tick() const noexcept { return _ns_per_tick; }
-
-  private:
-    /**
-     * Constructor
-     */
-    RdtscTicks()
-    {
-      // Convert rdtsc to wall time.
-      // 1. Get real time and rdtsc current count
-      // 2. Calculate how many rdtsc ticks can occur in one
-      // calculate _ticks_per_ns as the median over a number of observations.
-      constexpr std::chrono::milliseconds spin_duration = std::chrono::milliseconds{10};
-
-      constexpr int trials = 13;
-      std::array<double, trials> rates = {{0}};
-
-      for (size_t i = 0; i < trials; ++i)
-      {
-        auto const beg_ts =
-          std::chrono::nanoseconds{std::chrono::steady_clock::now().time_since_epoch().count()};
-        uint64_t const beg_tsc = rdtsc();
-
-        std::chrono::nanoseconds elapsed_ns;
-        uint64_t end_tsc;
-        do
-        {
-          auto const end_ts =
-            std::chrono::nanoseconds{std::chrono::steady_clock::now().time_since_epoch().count()};
-          end_tsc = rdtsc();
-
-          elapsed_ns = end_ts - beg_ts; // calculates ns between two timespecs
-        } while (elapsed_ns < spin_duration); // busy spin for 10ms
-
-        rates[i] = static_cast<double>(end_tsc - beg_tsc) / static_cast<double>(elapsed_ns.count());
-      }
-
-      std::nth_element(rates.begin(), rates.begin() + trials / 2, rates.end());
-
-      double const ticks_per_ns = rates[trials / 2];
-      _ns_per_tick = 1 / ticks_per_ns;
-    }
-
-    double _ns_per_tick{0};
-  };
-
-public:
-  /***/
-  explicit RdtscClock(std::chrono::nanoseconds resync_interval)
-    : _resync_interval_ticks(static_cast<std::int64_t>(static_cast<double>(resync_interval.count()) *
-                                                       RdtscTicks::instance().ns_per_tick())),
-      _resync_interval_original(_resync_interval_ticks),
-      _ns_per_tick(RdtscTicks::instance().ns_per_tick())
-
-  {
-    if (!resync(2500))
-    {
-      // try to resync again with higher lag
-      if (!resync(10000))
-      {
-        std::fprintf(stderr, "Failed to sync RdtscClock. Timestamps will be incorrect\n");
-      }
-    }
-  }
-
-  /***/
-  uint64_t time_since_epoch(uint64_t rdtsc_value) const noexcept
-  {
-    // should only get called by the backend thread
-
-    // get the current index, this is only sef called my the thread that is doing the resync
-    auto const index = _version.load(std::memory_order_relaxed) & (_base.size() - 1);
-
-    // get rdtsc current value and compare the diff then add it to base wall time
-    auto diff = static_cast<int64_t>(rdtsc_value - _base[index].base_tsc);
-
-    // we need to sync after we calculated otherwise base_tsc value will be ahead of passed tsc value
-    if (diff > _resync_interval_ticks)
-    {
-      resync(2500);
-      diff = static_cast<int64_t>(rdtsc_value - _base[index].base_tsc);
-    }
-
-    return static_cast<uint64_t>(_base[index].base_time +
-                                 static_cast<int64_t>(static_cast<double>(diff) * _ns_per_tick));
-  }
-
-  /***/
-  uint64_t time_since_epoch_safe(uint64_t rdtsc_value) const noexcept
-  {
-    // thread-safe, can be called by anyone
-    // this function won't resync as it can be called by anyone and only a single thread resyncs
-    uint32_t version;
-    uint64_t wall_ts;
-
-    do
-    {
-      version = _version.load(std::memory_order_acquire);
-      auto const index = version & (_base.size() - 1);
-
-      if (QUILL_UNLIKELY((_base[index].base_tsc) == 0 && (_base[index].base_time == 0)))
-      {
-        return 0;
-      }
-
-      // get rdtsc current value and compare the diff then add it to base wall time
-      auto const diff = static_cast<int64_t>(rdtsc_value - _base[index].base_tsc);
-      wall_ts = static_cast<uint64_t>(_base[index].base_time +
-                                      static_cast<int64_t>(static_cast<double>(diff) * _ns_per_tick));
-    } while (version != _version.load(std::memory_order_acquire));
-
-    return wall_ts;
-  }
-
-  /***/
-  bool resync(uint32_t lag) const noexcept
-  {
-    // Sometimes we might get an interrupt and might never resync, so we will try again up to max_attempts
-    constexpr uint8_t max_attempts{4};
-
-    for (uint8_t attempt = 0; attempt < max_attempts; ++attempt)
-    {
-      uint64_t const beg = rdtsc();
-      // we force convert to nanoseconds because the precision of system_clock::time-point is not portable across platforms.
-      int64_t const wall_time =
-        std::chrono::nanoseconds{std::chrono::system_clock::now().time_since_epoch()}.count();
-      uint64_t const end = rdtsc();
-
-      if (QUILL_LIKELY(end - beg <= lag))
-      {
-        // update the next index
-        auto const index = (_version.load(std::memory_order_relaxed) + 1) & (_base.size() - 1);
-        _base[index].base_time = wall_time;
-        _base[index].base_tsc = _fast_average(beg, end);
-        _version.fetch_add(1, std::memory_order_release);
-
-        _resync_interval_ticks = _resync_interval_original;
-        return true;
-      }
-    }
-
-    // we failed to return earlier and we never resynced, but we don't really want to keep retrying on each call
-    // to time_since_epoch() so we do non accurate resync we will increase the resync duration to resync later
-    _resync_interval_ticks = _resync_interval_ticks * 2;
-    return false;
-  }
-
-  /***/
-  double nanoseconds_per_tick() const noexcept { return _ns_per_tick; }
-
-private:
-  struct BaseTimeTsc
-  {
-    BaseTimeTsc() = default;
-    int64_t base_time{0}; /**< Get the initial base time in nanoseconds from epoch */
-    uint64_t base_tsc{0}; /**< Get the initial base tsc time */
-  };
-
-  /***/
-  QUILL_NODISCARD static uint64_t _fast_average(uint64_t x, uint64_t y) noexcept
-  {
-    return (x & y) + ((x ^ y) >> 1);
-  }
-
-private:
-  mutable int64_t _resync_interval_ticks{0};
-  int64_t _resync_interval_original{0}; /**< stores the initial interval value as as if we fail to resync we increase the timer */
-  double _ns_per_tick{0};
-
-  alignas(CACHE_LINE_ALIGNED) mutable std::atomic<uint32_t> _version{0};
-  mutable std::array<BaseTimeTsc, 2> _base{};
-};
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/backend/SignalHandler.h b/subprojects/quill-4.2.0/quill/include/quill/backend/SignalHandler.h
deleted file mode 100644
index d10b500..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/backend/SignalHandler.h
+++ /dev/null
@@ -1,374 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/Logger.h"
-#include "quill/core/Attributes.h"
-#include "quill/core/LogLevel.h"
-#include "quill/core/LoggerBase.h"
-#include "quill/core/LoggerManager.h"
-#include "quill/core/MacroMetadata.h"
-#include "quill/core/QuillError.h"
-#include "quill/core/ThreadUtilities.h"
-
-#include <atomic>
-#include <csignal>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
-#include <initializer_list>
-#include <string>
-
-#if defined(_WIN32)
-  #if !defined(WIN32_LEAN_AND_MEAN)
-    #define WIN32_LEAN_AND_MEAN
-  #endif
-
-  #if !defined(NOMINMAX)
-    // Mingw already defines this, so no need to redefine
-    #define NOMINMAX
-  #endif
-
-  #include <chrono>
-  #include <thread>
-  #include <windows.h>
-#else
-  #include <unistd.h>
-#endif
-
-namespace quill
-{
-namespace detail
-{
-/***/
-class SignalHandlerContext
-{
-public:
-  SignalHandlerContext(SignalHandlerContext const&) = delete;
-  SignalHandlerContext& operator=(SignalHandlerContext const&) = delete;
-
-  /***/
-  static SignalHandlerContext& instance() noexcept
-  {
-    static SignalHandlerContext instance;
-    return instance;
-  }
-
-  std::atomic<int32_t> signal_number{0};
-  std::atomic<uint32_t> lock{0};
-  std::atomic<uint32_t> backend_thread_id{0};
-  std::atomic<uint32_t> signal_handler_timeout_seconds{20};
-  std::atomic<bool> should_reraise_signal{true};
-
-private:
-  SignalHandlerContext() = default;
-  ~SignalHandlerContext() = default;
-};
-
-#define QUILL_SIGNAL_HANDLER_LOG(logger, log_level, fmt, ...)                                      \
-  do                                                                                               \
-  {                                                                                                \
-    if (logger->template should_log_message<log_level>())                                          \
-    {                                                                                              \
-      static constexpr quill::MacroMetadata macro_metadata{                                        \
-        "SignalHandler:~", "", fmt, nullptr, log_level, quill::MacroMetadata::Event::Log};         \
-                                                                                                   \
-      logger->log_message(quill::LogLevel::None, &macro_metadata, ##__VA_ARGS__);                  \
-    }                                                                                              \
-  } while (0)
-
-/***/
-template <typename TFrontendOptions>
-void on_signal(int32_t signal_number)
-{
-  // This handler can be entered by multiple threads.
-  uint32_t const lock = SignalHandlerContext::instance().lock.fetch_add(1);
-
-  if (lock != 0)
-  {
-    // We only allow the first thread to enter the signal handler
-
-    // sleep until a signal is delivered that either terminates the process or causes the
-    // invocation of a signal-catching function.
-
-#if defined(_WIN32)
-    std::this_thread::sleep_for(std::chrono::hours{24000});
-#else
-    pause();
-#endif
-  }
-
-#if defined(_WIN32)
-  // nothing to do, windows do not have alarm
-#else
-  // Store the original signal number for the alarm
-  SignalHandlerContext::instance().signal_number.store(signal_number);
-
-  // Set up an alarm to crash after 20 seconds by redelivering the original signal,
-  // in case anything else goes wrong
-  alarm(SignalHandlerContext::instance().signal_handler_timeout_seconds.load());
-#endif
-
-  // Get the id of this thread in the handler and make sure it is not the backend worker thread
-  uint32_t const backend_thread_id = SignalHandlerContext::instance().backend_thread_id.load();
-  uint32_t const current_thread_id = get_thread_id();
-  bool const should_reraise_signal = SignalHandlerContext::instance().should_reraise_signal.load();
-
-  if ((backend_thread_id == 0) || (current_thread_id == backend_thread_id))
-  {
-    // backend worker thread is not running or the signal handler is called in the backend worker thread
-    if (signal_number == SIGINT || signal_number == SIGTERM)
-    {
-      std::exit(EXIT_SUCCESS);
-    }
-    else if (should_reraise_signal)
-    {
-      // for other signals expect SIGINT and SIGTERM we re-raise
-      std::signal(signal_number, SIG_DFL);
-      std::raise(signal_number);
-    }
-  }
-  else
-  {
-    // This means signal handler is running on a frontend thread, we can log and flush
-    LoggerBase* logger_base = detail::LoggerManager::instance().get_valid_logger();
-
-    if (logger_base)
-    {
-#if defined(_WIN32)
-      int32_t const signal_desc = signal_number;
-#else
-      char const* const signal_desc = ::strsignal(signal_number);
-#endif
-
-      auto logger = reinterpret_cast<LoggerImpl<TFrontendOptions>*>(logger_base);
-      QUILL_SIGNAL_HANDLER_LOG(logger, quill::LogLevel::Info, "Received signal: {} (signum: {})",
-                               signal_desc, signal_number);
-
-      if (signal_number == SIGINT || signal_number == SIGTERM)
-      {
-        // For SIGINT and SIGTERM, we are shutting down gracefully
-        // Pass `0` to avoid calling std::this_thread::sleep_for()
-        logger->flush_log(0);
-        std::exit(EXIT_SUCCESS);
-      }
-      else if (should_reraise_signal)
-      {
-        QUILL_SIGNAL_HANDLER_LOG(logger, quill::LogLevel::Critical,
-                                 "Program terminated unexpectedly due to signal: {} (signum: {})",
-                                 signal_desc, signal_number);
-
-        // This is here in order to flush the above log statement
-        logger->flush_log(0);
-
-        // Reset to the default signal handler and re-raise the signal
-        std::signal(signal_number, SIG_DFL);
-        std::raise(signal_number);
-      }
-      else
-      {
-        logger->flush_log(0);
-      }
-    }
-  }
-}
-} // namespace detail
-
-/**
- * Setups a signal handler to handle fatal signals
- */
-#if defined(_WIN32)
-namespace detail
-{
-/***/
-char const* get_error_message(DWORD ex_code)
-{
-  switch (ex_code)
-  {
-  case EXCEPTION_ACCESS_VIOLATION:
-    return "EXCEPTION_ACCESS_VIOLATION";
-  case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-    return "EXCEPTION_ARRAY_BOUNDS_EXCEEDED";
-  case EXCEPTION_BREAKPOINT:
-    return "EXCEPTION_BREAKPOINT";
-  case EXCEPTION_DATATYPE_MISALIGNMENT:
-    return "EXCEPTION_DATATYPE_MISALIGNMENT";
-  case EXCEPTION_FLT_DENORMAL_OPERAND:
-    return "EXCEPTION_FLT_DENORMAL_OPERAND";
-  case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-    return "EXCEPTION_FLT_DIVIDE_BY_ZERO";
-  case EXCEPTION_FLT_INEXACT_RESULT:
-    return "EXCEPTION_FLT_INEXACT_RESULT";
-  case EXCEPTION_FLT_INVALID_OPERATION:
-    return "EXCEPTION_FLT_INVALID_OPERATION";
-  case EXCEPTION_FLT_OVERFLOW:
-    return "EXCEPTION_FLT_OVERFLOW";
-  case EXCEPTION_FLT_STACK_CHECK:
-    return "EXCEPTION_FLT_STACK_CHECK";
-  case EXCEPTION_FLT_UNDERFLOW:
-    return "EXCEPTION_FLT_UNDERFLOW";
-  case EXCEPTION_ILLEGAL_INSTRUCTION:
-    return "EXCEPTION_ILLEGAL_INSTRUCTION";
-  case EXCEPTION_IN_PAGE_ERROR:
-    return "EXCEPTION_IN_PAGE_ERROR";
-  case EXCEPTION_INT_DIVIDE_BY_ZERO:
-    return "EXCEPTION_INT_DIVIDE_BY_ZERO";
-  case EXCEPTION_INT_OVERFLOW:
-    return "EXCEPTION_INT_OVERFLOW";
-  case EXCEPTION_INVALID_DISPOSITION:
-    return "EXCEPTION_INVALID_DISPOSITION";
-  case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-    return "EXCEPTION_NONCONTINUABLE_EXCEPTION";
-  case EXCEPTION_PRIV_INSTRUCTION:
-    return "EXCEPTION_PRIV_INSTRUCTION";
-  case EXCEPTION_SINGLE_STEP:
-    return "EXCEPTION_SINGLE_STEP";
-  case EXCEPTION_STACK_OVERFLOW:
-    return "EXCEPTION_STACK_OVERFLOW";
-  default:
-    return "Unrecognized Exception";
-  }
-}
-
-/***/
-template <typename TFrontendOptions>
-BOOL WINAPI on_console_signal(DWORD signal)
-{
-  uint32_t const backend_thread_id = SignalHandlerContext::instance().backend_thread_id.load();
-  uint32_t const current_thread_id = get_thread_id();
-
-  // Check if the signal handler is running from a caller thread and if the signal is CTRL+C or CTRL+BREAK
-  if ((backend_thread_id != 0) && (current_thread_id != backend_thread_id) &&
-      (signal == CTRL_C_EVENT || signal == CTRL_BREAK_EVENT))
-  {
-    // Log the interruption and flush log messages
-    LoggerBase* logger_base = detail::LoggerManager::instance().get_valid_logger();
-    if (logger_base)
-    {
-      auto logger = reinterpret_cast<LoggerImpl<TFrontendOptions>*>(logger_base);
-      QUILL_SIGNAL_HANDLER_LOG(logger, quill::LogLevel::Info,
-                               "Program interrupted by Ctrl+C or Ctrl+Break signal");
-
-      // Pass `0` to avoid calling std::this_thread::sleep_for()
-      logger->flush_log(0);
-      std::exit(EXIT_SUCCESS);
-    }
-  }
-
-  return TRUE;
-}
-
-/***/
-template <typename TFrontendOptions>
-LONG WINAPI on_exception(EXCEPTION_POINTERS* exception_p)
-{
-  uint32_t const backend_thread_id = SignalHandlerContext::instance().backend_thread_id.load();
-  uint32_t const current_thread_id = get_thread_id();
-
-  // Check if the signal handler is running from a caller thread and if the signal is CTRL+C or CTRL+BREAK
-  if ((backend_thread_id != 0) && (current_thread_id != backend_thread_id))
-  {
-    // Log the interruption and flush log messages
-    LoggerBase* logger_base = detail::LoggerManager::instance().get_valid_logger();
-    if (logger_base)
-    {
-      auto logger = reinterpret_cast<LoggerImpl<TFrontendOptions>*>(logger_base);
-
-      QUILL_SIGNAL_HANDLER_LOG(logger, quill::LogLevel::Info, "Received exception: {} (Code: {})",
-                               get_error_message(exception_p->ExceptionRecord->ExceptionCode),
-                               exception_p->ExceptionRecord->ExceptionCode);
-
-      QUILL_SIGNAL_HANDLER_LOG(logger, quill::LogLevel::Critical,
-                               "Program terminated unexpectedly due to exception: {} (Code: {})",
-                               get_error_message(exception_p->ExceptionRecord->ExceptionCode),
-                               exception_p->ExceptionRecord->ExceptionCode);
-
-      // Pass `0` to avoid calling std::this_thread::sleep_for()
-      logger->flush_log(0);
-    }
-  }
-
-  // FATAL Exception: It doesn't necessarily stop here. we pass on continue search
-  // If nobody catches it, then it will exit anyhow.
-  // The risk here is if someone is catching this and returning "EXCEPTION_EXECUTE_HANDLER"
-  // but won't shut down then the app will be running with quill shutdown.
-  return EXCEPTION_CONTINUE_SEARCH;
-}
-
-/***/
-template <typename TFrontendOptions>
-void init_exception_handler()
-{
-  SetUnhandledExceptionFilter(on_exception<TFrontendOptions>);
-
-  if (!SetConsoleCtrlHandler(on_console_signal<TFrontendOptions>, TRUE))
-  {
-    QUILL_THROW(QuillError{"Failed to call SetConsoleCtrlHandler"});
-  }
-}
-} // namespace detail
-
-/**
- * On windows it has to be called on each thread
- * @param catchable_signals the signals we are catching
- */
-template <typename TFrontendOptions>
-void init_signal_handler(std::initializer_list<int32_t> const& catchable_signals = std::initializer_list<int>{
-                           SIGTERM, SIGINT, SIGABRT, SIGFPE, SIGILL, SIGSEGV})
-{
-  for (auto const& catchable_signal : catchable_signals)
-  {
-    // setup a signal handler per signal in the array
-    if (std::signal(catchable_signal, detail::on_signal<TFrontendOptions>) == SIG_ERR)
-    {
-      QUILL_THROW(QuillError{"Failed to setup signal handler for signal: " + std::to_string(catchable_signal)});
-    }
-  }
-}
-#else
-namespace detail
-{
-/***/
-void on_alarm(int32_t signal_number)
-{
-  if (SignalHandlerContext::instance().signal_number.load() == 0)
-  {
-    // Will only happen if SIGALRM is the first signal we receive
-    SignalHandlerContext::instance().signal_number = signal_number;
-  }
-
-  // We will raise the original signal back
-  std::signal(SignalHandlerContext::instance().signal_number, SIG_DFL);
-  std::raise(SignalHandlerContext::instance().signal_number);
-}
-
-template <typename TFrontendOptions>
-void init_signal_handler(std::initializer_list<int32_t> const& catchable_signals)
-{
-  for (auto const& catchable_signal : catchable_signals)
-  {
-    if (catchable_signal == SIGALRM)
-    {
-      QUILL_THROW(QuillError{"SIGALRM can not be part of catchable_signals."});
-    }
-
-    // set up a signal handler per signal in the array
-    if (std::signal(catchable_signal, on_signal<TFrontendOptions>) == SIG_ERR)
-    {
-      QUILL_THROW(QuillError{"Failed to setup signal handler for signal: " + std::to_string(catchable_signal)});
-    }
-  }
-
-  /* Register the alarm handler */
-  if (std::signal(SIGALRM, on_alarm) == SIG_ERR)
-  {
-    QUILL_THROW(QuillError{"Failed to setup signal handler for signal: SIGALRM"});
-  }
-}
-} // namespace detail
-#endif
-
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/backend/StringFromTime.h b/subprojects/quill-4.2.0/quill/include/quill/backend/StringFromTime.h
deleted file mode 100644
index 4fc2217..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/backend/StringFromTime.h
+++ /dev/null
@@ -1,533 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/QuillError.h"
-#include "quill/core/TimeUtilities.h"
-
-#include <array>
-#include <chrono>
-#include <cstdint>
-#include <cstdlib>
-#include <ctime>
-#include <map>
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace quill::detail
-{
-/**
- * A class that converts a timestamp to a string based on the given format.
- * It works exactly the same as strftime() but it caches the string on it's creation
- * and only modifies the parts of the string that need to change.
- * This is much more efficient than calling strftime as we just need to calculate the different
- * between the cached and the requested timestamp and modify our preformatted string.
- *
- * 1) We take a format string eg "%Y-%m-%dT%H:%M:%SZ".
- * 2) We split it into several parts (_initial_parts) where we separate the time modifiers.
- * e.g "%Y-%m-%dT", "%H", ":", "%M", ":", "%S", Z".
- * 3) We cache the current timestamp and current h/m/s in seconds and on each part above
- * we call strftime() and we create a preformatted string.
- * 4) While calling stftime in 3) we can manually check for any time modifiers and store
- * their index in the final pre-formatted string.
- * 5) Next time we want to calculate the timestamp we will just calculate the difference
- * in seconds between the current and the cache timestamp.
- * Then we add this value to the cached seconds and then convert the seconds
- * to hh::mm::ss and replace in our pre-formatted string using the stored indexes.
- * 6) We re-calculate the pre-formatted string every midnight and noon.
- */
-class StringFromTime
-{
-public:
-  /***/
-  QUILL_ATTRIBUTE_COLD void init(std::string timestamp_format, Timezone timezone)
-  {
-    _timestamp_format = std::move(timestamp_format);
-    _time_zone = timezone;
-
-    if (_timestamp_format.find("%X") != std::string::npos)
-    {
-      QUILL_THROW(QuillError("`%X` as format modifier is not currently supported in format: " + _timestamp_format));
-    }
-
-    // We first look for some special format modifiers and replace them
-    _replace_all(_timestamp_format, "%r", "%I:%M:%S %p");
-    _replace_all(_timestamp_format, "%R", "%H:%M");
-    _replace_all(_timestamp_format, "%T", "%H:%M:%S");
-
-    // Populate the initial parts that we will use to generate a pre-formatted string
-    _populate_initial_parts(_timestamp_format);
-
-    // Get the current timestamp now
-    time_t timestamp;
-    std::time(&timestamp);
-
-    if (_time_zone == Timezone::LocalTime)
-    {
-      // If localtime is used we will recalculate every 1 hour - this is because of the DST changes
-      // and an easy work-around
-
-      // Then round it down to the nearest hour
-      timestamp = _nearest_hour_timestamp(timestamp);
-
-      // Also calculate and store the next hour timestamp
-      _next_recalculation_timestamp = _next_hour_timestamp(timestamp);
-    }
-    else if (_time_zone == Timezone::GmtTime)
-    {
-      // otherwise we will only recalculate every noon and midnight. the reason for this is in case
-      // user is using PM, AM format etc
-      _next_recalculation_timestamp = _next_noon_or_midnight_timestamp(timestamp, _time_zone);
-
-      // we don't need to modify timestamp in the case of UTC
-    }
-
-    // Now populate a pre formatted string for this hour,
-    // also cache any indexes of the time modifier in the string
-    _populate_pre_formatted_string_and_cached_indexes(timestamp);
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT std::string const& format_timestamp(time_t timestamp)
-  {
-    // First we check for the edge case where the given timestamp is back in time. This is when
-    // the timestamp provided is less than our cached_timestamp. We only expect to format timestamps
-    // that are incrementing not those back in time. In this case we just fall back to calling strfime
-    if (timestamp < _cached_timestamp)
-    {
-      _fallback_formatted = _safe_strftime(_timestamp_format.data(), timestamp, _time_zone).data();
-      return _fallback_formatted;
-    }
-
-    // After this point we know that given timestamp is >= to the cache timestamp.
-
-    // We check if the given timestamp greater than the _next_recalculation_timestamp to recalculate
-    if (timestamp >= _next_recalculation_timestamp)
-    {
-      // in this case we have to populate our cached string again using strftime
-      _pre_formatted_ts.clear();
-      _cached_indexes.clear();
-
-      // Now populate a pre-formatted string for the next rec
-      _populate_pre_formatted_string_and_cached_indexes(timestamp);
-
-      if (_time_zone == Timezone::LocalTime)
-      {
-        _next_recalculation_timestamp = _next_hour_timestamp(timestamp);
-      }
-      else if (_time_zone == Timezone::GmtTime)
-      {
-        _next_recalculation_timestamp = _next_noon_or_midnight_timestamp(timestamp + 1, _time_zone);
-      }
-    }
-
-    if (_cached_indexes.empty())
-    {
-      // if we don't have to format any hours minutes or seconds we can just return here
-      return _pre_formatted_ts;
-    }
-
-    if (_cached_timestamp == timestamp)
-    {
-      // This has 2 usages:
-      // 1. Any timestamps in seconds precision that are the same, we don't need to do anything.
-      // 2. This checks happens after the _next_recalculation_timestamp calculation. The _next_recalculation_timestamp
-      // will mutate _cached_timestamp and if they are similar we will just return here anyway
-      return _pre_formatted_ts;
-    }
-
-    // Get the difference from our cached timestamp
-    time_t const timestamp_diff = timestamp - _cached_timestamp;
-
-    // cache this timestamp
-    _cached_timestamp = timestamp;
-
-    // Add the timestamp_diff to the cached seconds and calculate the new hours minutes seconds.
-    // Note: cached_seconds could be in gmtime or localtime but we don't care as we are just
-    // adding the difference.
-    _cached_seconds += static_cast<uint32_t>(timestamp_diff);
-
-    uint32_t cached_seconds = _cached_seconds;
-    uint32_t const hours = cached_seconds / 3600;
-    cached_seconds = cached_seconds % 3600;
-    uint32_t const minutes = cached_seconds / 60;
-    cached_seconds = cached_seconds % 60;
-    uint32_t const seconds = cached_seconds;
-
-    std::string to_replace;
-
-    for (auto const& index : _cached_indexes)
-    {
-      // for each cached index we have, replace it when the new value
-      switch (index.second)
-      {
-      case format_type::H:
-        to_replace = std::to_string(hours);
-
-        if (to_replace.size() == 1)
-        {
-          to_replace.insert(0, 1, '0');
-        }
-
-        _pre_formatted_ts.replace(index.first, 2, to_replace);
-        break;
-      case format_type::M:
-        to_replace = std::to_string(minutes);
-
-        if (to_replace.size() == 1)
-        {
-          to_replace.insert(0, 1, '0');
-        }
-        _pre_formatted_ts.replace(index.first, 2, to_replace);
-        break;
-      case format_type::S:
-        to_replace = std::to_string(seconds);
-
-        if (to_replace.size() == 1)
-        {
-          to_replace.insert(0, 1, '0');
-        }
-        _pre_formatted_ts.replace(index.first, 2, to_replace);
-        break;
-      case format_type::I:
-        if (hours != 0)
-        {
-          to_replace = std::to_string(hours > 12 ? hours - 12 : hours);
-        }
-        else
-        {
-          // if hours is `00` we need to replace than with '12' instead in this format
-          to_replace = std::to_string(12);
-        }
-
-        if (to_replace.size() == 1)
-        {
-          to_replace.insert(0, 1, '0');
-        }
-        _pre_formatted_ts.replace(index.first, 2, to_replace);
-        break;
-      case format_type::k:
-        to_replace = std::to_string(hours);
-
-        if (to_replace.size() == 1)
-        {
-          to_replace.insert(0, 1, ' ');
-        }
-        _pre_formatted_ts.replace(index.first, 2, to_replace);
-        break;
-      case format_type::l:
-        if (hours != 0)
-        {
-          to_replace = std::to_string(hours > 12 ? hours - 12 : hours);
-        }
-        else
-        {
-          // if hours is `00` we need to replace than with '12' instead in this format
-          to_replace = std::to_string(12);
-        }
-
-        if (to_replace.size() == 1)
-        {
-          to_replace.insert(0, 1, ' ');
-        }
-        _pre_formatted_ts.replace(index.first, 2, to_replace);
-        break;
-      case format_type::s:
-        to_replace = std::to_string(_cached_timestamp);
-        _pre_formatted_ts.replace(index.first, 10, to_replace);
-        break;
-      default:
-        abort();
-      }
-    }
-
-    return _pre_formatted_ts;
-  }
-
-protected:
-  enum class format_type : uint8_t
-  {
-    H,
-    M,
-    S,
-    I,
-    k,
-    l,
-    s
-  };
-
-  /***/
-  QUILL_ATTRIBUTE_COLD void _populate_initial_parts(std::string timestamp_format)
-  {
-    do
-    {
-      // we get part1 and part2 and keep looping on the new modified string without the part1 and
-      // part2 until we find not %H, %M or %S at all
-      auto const [part1, part2] = _split_timestamp_format_once(timestamp_format);
-
-      if (!part1.empty())
-      {
-        _initial_parts.push_back(part1);
-      }
-
-      if (!part2.empty())
-      {
-        _initial_parts.push_back(part2);
-      }
-
-      if (part1.empty() && part2.empty())
-      {
-        // if both part_1 and part_2 are empty it means we have no more
-        // format modifiers to add, we push back the remaining timestamp_format string
-        // and break
-        if (!timestamp_format.empty())
-        {
-          _initial_parts.push_back(timestamp_format);
-        }
-        break;
-      }
-    } while (true);
-  }
-
-  /***/
-  void _populate_pre_formatted_string_and_cached_indexes(time_t timestamp)
-  {
-    _cached_timestamp = timestamp;
-
-    tm time_info{};
-
-    if (_time_zone == Timezone::LocalTime)
-    {
-      localtime_rs(reinterpret_cast<time_t const*>(std::addressof(_cached_timestamp)), std::addressof(time_info));
-    }
-    else if (_time_zone == Timezone::GmtTime)
-    {
-      gmtime_rs(reinterpret_cast<time_t const*>(std::addressof(_cached_timestamp)), std::addressof(time_info));
-    }
-
-    // also cache the seconds
-    _cached_seconds =
-      static_cast<uint32_t>((time_info.tm_hour * 3600) + (time_info.tm_min * 60) + time_info.tm_sec);
-
-    // Now run through all parts and call strftime
-    for (auto const& format_part : _initial_parts)
-    {
-      // We call strftime on each part of the timestamp to format it.
-      _pre_formatted_ts += _safe_strftime(format_part.data(), _cached_timestamp, _time_zone).data();
-
-      // If we formatted and appended to the string a time modifier also store the
-      // current index in the string
-      if (format_part == "%H")
-      {
-        _cached_indexes.emplace_back(_pre_formatted_ts.size() - 2, format_type::H);
-      }
-      else if (format_part == "%M")
-      {
-        _cached_indexes.emplace_back(_pre_formatted_ts.size() - 2, format_type::M);
-      }
-      else if (format_part == "%S")
-      {
-        _cached_indexes.emplace_back(_pre_formatted_ts.size() - 2, format_type::S);
-      }
-      else if (format_part == "%I")
-      {
-        _cached_indexes.emplace_back(_pre_formatted_ts.size() - 2, format_type::I);
-      }
-      else if (format_part == "%k")
-      {
-        _cached_indexes.emplace_back(_pre_formatted_ts.size() - 2, format_type::k);
-      }
-      else if (format_part == "%l")
-      {
-        _cached_indexes.emplace_back(_pre_formatted_ts.size() - 2, format_type::l);
-      }
-      else if (format_part == "%s")
-      {
-        _cached_indexes.emplace_back(_pre_formatted_ts.size() - 10, format_type::s);
-      }
-    }
-  }
-
-  /***/
-  std::pair<std::string, std::string> static _split_timestamp_format_once(std::string& timestamp_format) noexcept
-  {
-    // don't make this static as it breaks on windows with atexit when backend worker stops
-    std::array<std::string, 7> const modifiers{"%H", "%M", "%S", "%I", "%k", "%l", "%s"};
-
-    // if we find any modifier in the timestamp format we store the index where we
-    // found it.
-    // We use a map to find the first modifier (with the lowest index) in the given string
-    // Maps found_index -> modifier value
-    std::map<size_t, std::string> found_format_modifiers;
-
-    for (auto const& modifier : modifiers)
-    {
-      if (auto const search = timestamp_format.find(modifier); search != std::string::npos)
-      {
-        // Add the index and the modifier string to our map
-        found_format_modifiers.emplace(search, modifier);
-      }
-    }
-
-    if (found_format_modifiers.empty())
-    {
-      // We didn't find any modifiers in the given string, therefore we return
-      // both parts as empty
-      return std::make_pair(std::string{}, std::string{});
-    }
-
-    // we will split the formatted timestamp on the first modifier we found
-
-    // Part 1 is the part before the modifier
-    // Here we check that there is actually a part of before and the format doesn't start with the
-    // modifier, otherwise we use an empty string
-    std::string const part_1 = found_format_modifiers.begin()->first > 0
-      ? std::string{timestamp_format.data(), found_format_modifiers.begin()->first}
-      : "";
-
-    // The actual value of the modifier string
-    std::string const part_2 = found_format_modifiers.begin()->second;
-
-    // We modify the given timestamp string to exclude part_1 and part_2.
-    // part_2 length as the modifier value will always be 2
-    timestamp_format = std::string{timestamp_format.data() + found_format_modifiers.begin()->first + 2};
-
-    return std::make_pair(part_1, part_2);
-  }
-
-  /***/
-  QUILL_NODISCARD static std::vector<char> _safe_strftime(char const* format_string, time_t timestamp, Timezone timezone)
-  {
-    if (format_string[0] == '\0')
-    {
-      std::vector<char> res;
-      res.push_back('\0');
-      return res;
-    }
-
-    // Convert timestamp to time_info
-    tm time_info;
-    if (timezone == Timezone::LocalTime)
-    {
-      localtime_rs(reinterpret_cast<time_t const*>(std::addressof(timestamp)), std::addressof(time_info));
-    }
-    else if (timezone == Timezone::GmtTime)
-    {
-      gmtime_rs(reinterpret_cast<time_t const*>(std::addressof(timestamp)), std::addressof(time_info));
-    }
-
-    // Create a buffer to call strftimex
-    std::vector<char> buffer;
-    buffer.resize(32);
-    size_t res = strftime(&buffer[0], buffer.size(), format_string, std::addressof(time_info));
-
-    while (res == 0)
-    {
-      // if strftime fails we will reserve more space
-      buffer.resize(buffer.size() * 2);
-      res = strftime(&buffer[0], buffer.size(), format_string, std::addressof(time_info));
-    }
-
-    return buffer;
-  }
-
-  /***/
-  static void _replace_all(std::string& str, std::string const& old_value, std::string const& new_value) noexcept
-  {
-    std::string::size_type pos = 0u;
-    while ((pos = str.find(old_value, pos)) != std::string::npos)
-    {
-      str.replace(pos, old_value.length(), new_value);
-      pos += new_value.length();
-    }
-  }
-
-  /***/
-  QUILL_NODISCARD static time_t _nearest_hour_timestamp(time_t timestamp) noexcept
-  {
-    time_t const nearest_hour_ts = timestamp - (timestamp % 3600);
-    return nearest_hour_ts;
-  }
-
-  /***/
-  QUILL_NODISCARD static time_t _next_hour_timestamp(time_t timestamp) noexcept
-  {
-    time_t const next_hour_ts = _nearest_hour_timestamp(timestamp) + 3600;
-    return next_hour_ts;
-  }
-
-  /***/
-  QUILL_NODISCARD static time_t _next_noon_or_midnight_timestamp(time_t timestamp, Timezone timezone) noexcept
-  {
-    // Get the current date and time now as time_info
-    tm time_info;
-
-    if (timezone == Timezone::GmtTime)
-    {
-      gmtime_rs(&timestamp, &time_info);
-    }
-    else
-    {
-      localtime_rs(&timestamp, &time_info);
-    }
-
-    if (time_info.tm_hour < 12)
-    {
-      // we are before noon, so calculate noon
-      time_info.tm_hour = 11;
-      time_info.tm_min = 59;
-      time_info.tm_sec = 59; // we add 1 second later
-    }
-    else
-    {
-      // we are after noon so we calculate midnight
-      time_info.tm_hour = 23;
-      time_info.tm_min = 59;
-      time_info.tm_sec = 59; // we add 1 second later
-    }
-
-    // convert back to time since epoch
-    std::chrono::system_clock::time_point const next_midnight = (timezone == Timezone::GmtTime)
-      ? std::chrono::system_clock::from_time_t(detail::timegm(&time_info))
-      : std::chrono::system_clock::from_time_t(std::mktime(&time_info));
-
-    // returns seconds since epoch of the next midnight.
-    return std::chrono::duration_cast<std::chrono::seconds>(next_midnight.time_since_epoch()).count() + 1;
-  }
-
-private:
-  /** Contains the timestamp_format broken down into parts. We call use those parts to
-   * create a pre-formatted string */
-  std::vector<std::string> _initial_parts;
-
-  /** Contains stored indexes of the _pre_formatted_ts for each format time modifier*/
-  std::vector<std::pair<size_t, format_type>> _cached_indexes;
-
-  /** The format request format of the timestamp. This can be slightly modified in constructor so we store it. */
-  std::string _timestamp_format;
-
-  /** The pre-formatted timestamp string */
-  std::string _pre_formatted_ts;
-
-  /** This is only used only when we fallback to strftime */
-  std::string _fallback_formatted;
-
-  /** The timestamp of the next noon, or midnight, we use this to resync */
-  time_t _next_recalculation_timestamp{0};
-
-  /** The timestamp of value of our pre-formated string */
-  time_t _cached_timestamp{0};
-
-  /** The seconds of hh:mm:ss of the pre-formatted string this is after using gmtime or localtime on cached_timestamp */
-  uint32_t _cached_seconds{0};
-
-  /** gmtime or localtime */
-  Timezone _time_zone;
-};
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/backend/TimestampFormatter.h b/subprojects/quill-4.2.0/quill/include/quill/backend/TimestampFormatter.h
deleted file mode 100644
index 265ac2b..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/backend/TimestampFormatter.h
+++ /dev/null
@@ -1,214 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/backend/StringFromTime.h"
-#include "quill/bundled/fmt/format.h"
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/QuillError.h"
-
-#include <array>
-#include <cassert>
-#include <chrono>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <string>
-#include <string_view>
-#include <utility>
-
-namespace quill::detail
-{
-
-/**
- * Formats a timestamp given a format string as a pattern. The format pattern uses the
- * same format specifiers as strftime() but with the following additional specifiers :
- * 1) %Qms - Milliseconds
- * 2) %Qus - Microseconds
- * 3) %Qns - Nanoseconds
- * @note %Qms, %Qus, %Qns specifiers are mutually exclusive
- * e.g given : "%I:%M.%Qms%p" the output would be "03:21.343PM"
- */
-class TimestampFormatter
-{
-private:
-  enum AdditionalSpecifier : uint8_t
-  {
-    None,
-    Qms,
-    Qus,
-    Qns
-  };
-
-public:
-  /***/
-  explicit TimestampFormatter(std::string time_format, Timezone timestamp_timezone = Timezone::LocalTime)
-    : _time_format(std::move(time_format)), _timestamp_timezone(timestamp_timezone)
-  {
-    assert((_timestamp_timezone == Timezone::LocalTime || _timestamp_timezone == Timezone::GmtTime) &&
-           "Invalid timezone type");
-
-    // store the beginning of the found specifier
-    size_t specifier_begin{std::string::npos};
-
-    // look for all three special specifiers
-
-    if (size_t const search_qms = _time_format.find(specifier_name[AdditionalSpecifier::Qms]);
-        search_qms != std::string::npos)
-    {
-      _additional_format_specifier = AdditionalSpecifier::Qms;
-      specifier_begin = search_qms;
-    }
-
-    if (size_t const search_qus = _time_format.find(specifier_name[AdditionalSpecifier::Qus]);
-        search_qus != std::string::npos)
-    {
-      if (specifier_begin != std::string::npos)
-      {
-        QUILL_THROW(QuillError{"format specifiers %Qms, %Qus and %Qns are mutually exclusive"});
-      }
-
-      _additional_format_specifier = AdditionalSpecifier::Qus;
-      specifier_begin = search_qus;
-    }
-
-    if (size_t const search_qns = _time_format.find(specifier_name[AdditionalSpecifier::Qns]);
-        search_qns != std::string::npos)
-    {
-      if (specifier_begin != std::string::npos)
-      {
-        QUILL_THROW(QuillError{"format specifiers %Qms, %Qus and %Qns are mutually exclusive"});
-      }
-
-      _additional_format_specifier = AdditionalSpecifier::Qns;
-      specifier_begin = search_qns;
-    }
-
-    if (specifier_begin == std::string::npos)
-    {
-      // If no additional specifier was found then we can simply store the whole format string
-      assert(_additional_format_specifier == AdditionalSpecifier::None);
-      _format_part_1 = _time_format;
-    }
-    else
-    {
-      // We now the index where the specifier begins so copy everything until there from beginning
-      _format_part_1 = _time_format.substr(0, specifier_begin);
-
-      // Now copy the remaining format string, ignoring the specifier
-      size_t const specifier_end = specifier_begin + specifier_length;
-
-      _format_part_2 = _time_format.substr(specifier_end, _time_format.length() - specifier_end);
-    }
-
-    // Now init two custom string from time classes with pre-formatted strings
-    _strftime_part_1.init(_format_part_1, _timestamp_timezone);
-    _strftime_part_2.init(_format_part_2, _timestamp_timezone);
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT std::string_view format_timestamp(std::chrono::nanoseconds time_since_epoch)
-  {
-    int64_t const timestamp_ns = time_since_epoch.count();
-
-    // convert timestamp to seconds
-    int64_t const timestamp_secs = timestamp_ns / 1'000'000'000;
-
-    // First always clear our cached string
-    _formatted_date.clear();
-
-    // 1. we always format part 1
-    _formatted_date += _strftime_part_1.format_timestamp(timestamp_secs);
-
-    // 2. We add any special ms/us/ns specifier if any
-    auto const extracted_ns = static_cast<uint32_t>(timestamp_ns - (timestamp_secs * 1'000'000'000));
-
-    if (_additional_format_specifier == AdditionalSpecifier::Qms)
-    {
-      uint32_t const extracted_ms = extracted_ns / 1'000'000;
-      constexpr char const* zeros = "000";
-
-      // Add as many zeros as the extracted_fractional_seconds_length
-      _formatted_date += zeros;
-
-      _append_fractional_seconds(extracted_ms);
-    }
-    else if (_additional_format_specifier == AdditionalSpecifier::Qus)
-    {
-      uint32_t const extracted_us = extracted_ns / 1'000;
-      constexpr char const* zeros = "000000";
-
-      // Add as many zeros as the extracted_fractional_seconds_length
-      _formatted_date += zeros;
-
-      _append_fractional_seconds(extracted_us);
-    }
-    else if (_additional_format_specifier == AdditionalSpecifier::Qns)
-    {
-      constexpr char const* zeros = "000000000";
-
-      // Add as many zeros as the extracted_fractional_seconds_length
-      _formatted_date += zeros;
-
-      _append_fractional_seconds(extracted_ns);
-    }
-
-    // 3. format part 2 after fractional seconds - if any
-    if (!_format_part_2.empty())
-    {
-      _formatted_date += _strftime_part_2.format_timestamp(timestamp_secs);
-    }
-
-    return _formatted_date;
-  }
-
-  /***/
-  QUILL_NODISCARD std::string const& time_format() const noexcept { return _time_format; }
-
-  /***/
-  QUILL_NODISCARD Timezone timestamp_timezone() const noexcept { return _timestamp_timezone; }
-
-private:
-  /***/
-  void _append_fractional_seconds(uint32_t extracted_fractional_seconds)
-  {
-    // Format the seconds and add them
-    fmtquill::format_int const extracted_ms_string{extracted_fractional_seconds};
-
-    // _formatted_date.size() - extracted_ms_string.size() is where we want to begin placing the fractional seconds
-    memcpy(&_formatted_date[_formatted_date.size() - extracted_ms_string.size()],
-           extracted_ms_string.data(), extracted_ms_string.size());
-  }
-
-private:
-  /** Contains the additional specifier name, at the same index as the enum **/
-  static constexpr std::array<char const*, 4> specifier_name{"", "%Qms", "%Qus", "%Qns"};
-
-  /** All special specifiers have same length at the moment **/
-  static constexpr size_t specifier_length = 4u;
-
-  std::string _time_format;
-
-  /** As class member to avoid re-allocating **/
-  std::string _formatted_date;
-
-  /** The format string is broken down to two parts. Before and after our additional specifiers */
-  std::string _format_part_1;
-  std::string _format_part_2;
-
-  /** Strftime cache for both parts of the string */
-  StringFromTime _strftime_part_1;
-  StringFromTime _strftime_part_2;
-
-  /** Timezone, Local time by default **/
-  Timezone _timestamp_timezone;
-
-  /** fractional seconds */
-  AdditionalSpecifier _additional_format_specifier{AdditionalSpecifier::None};
-};
-
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/backend/TransitEvent.h b/subprojects/quill-4.2.0/quill/include/quill/backend/TransitEvent.h
deleted file mode 100644
index 4c006e4..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/backend/TransitEvent.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/Codec.h"
-#include "quill/core/FormatBuffer.h"
-#include "quill/core/LogLevel.h"
-#include "quill/core/MacroMetadata.h"
-
-#include <atomic>
-#include <cstdint>
-#include <memory>
-#include <optional>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-namespace quill::detail
-{
-/** Forward declaration */
-class LoggerBase;
-
-/***/
-struct TransitEvent
-{
-  /***/
-  TransitEvent() { formatted_msg.reserve(32); }
-
-  /***/
-  ~TransitEvent() = default;
-
-  /***/
-  TransitEvent(TransitEvent const& other) = delete;
-  TransitEvent& operator=(TransitEvent const& other) = delete;
-
-  /***/
-  TransitEvent(TransitEvent&& other) noexcept
-    : timestamp(other.timestamp),
-      macro_metadata(other.macro_metadata),
-      logger_base(other.logger_base),
-      format_args_decoder(other.format_args_decoder),
-      thread_id(other.thread_id),
-      thread_name(other.thread_name),
-      formatted_msg(std::move(other.formatted_msg)),
-      named_args(std::move(other.named_args)),
-      dynamic_log_level(other.dynamic_log_level),
-      flush_flag(other.flush_flag)
-  {
-  }
-
-  /***/
-  TransitEvent& operator=(TransitEvent&& other) noexcept
-  {
-    if (this != &other)
-    {
-      timestamp = other.timestamp;
-      macro_metadata = other.macro_metadata;
-      logger_base = other.logger_base;
-      format_args_decoder = other.format_args_decoder;
-      thread_id = other.thread_id;
-      thread_name = other.thread_name;
-      formatted_msg = std::move(other.formatted_msg);
-      named_args = std::move(other.named_args);
-      dynamic_log_level = other.dynamic_log_level;
-      flush_flag = other.flush_flag;
-    }
-
-    return *this;
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT LogLevel log_level() const noexcept
-  {
-    return (macro_metadata->log_level() != LogLevel::Dynamic) ? macro_metadata->log_level() : dynamic_log_level;
-  }
-
-  uint64_t timestamp{0};
-  MacroMetadata const* macro_metadata{nullptr};
-  detail::LoggerBase* logger_base{nullptr};
-  detail::FormatArgsDecoder format_args_decoder{nullptr};
-  std::string_view thread_id;
-  std::string_view thread_name;
-  FormatBuffer formatted_msg; /** buffer for message **/
-  std::unique_ptr<std::vector<std::pair<std::string, std::string>>> named_args; /** A unique ptr to save space as named args feature is not always used */
-  LogLevel dynamic_log_level{LogLevel::None};
-  std::atomic<bool>* flush_flag{nullptr}; /** This is only used in the case of Event::Flush **/
-};
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/backend/TransitEventBuffer.h b/subprojects/quill-4.2.0/quill/include/quill/backend/TransitEventBuffer.h
deleted file mode 100644
index d5d52c1..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/backend/TransitEventBuffer.h
+++ /dev/null
@@ -1,211 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/backend/TransitEvent.h"
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/MathUtils.h"
-
-#include <cassert>
-#include <cstdint>
-#include <limits>
-#include <vector>
-
-namespace quill::detail
-{
-template <typename T>
-class BoundedTransitEventBufferImpl
-{
-public:
-  using integer_type = T;
-
-  /***/
-  explicit BoundedTransitEventBufferImpl(integer_type capacity)
-    : _capacity(next_power_of_two(capacity)), _mask(static_cast<integer_type>(_capacity - 1u))
-  {
-    _storage.resize(_capacity);
-  }
-
-  /***/
-  BoundedTransitEventBufferImpl(BoundedTransitEventBufferImpl const&) = delete;
-  BoundedTransitEventBufferImpl& operator=(BoundedTransitEventBufferImpl const&) = delete;
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT TransitEvent* front() noexcept
-  {
-    if (_writer_pos == _reader_pos)
-    {
-      // empty
-      return nullptr;
-    }
-
-    return &_storage[static_cast<uint32_t>(_reader_pos & _mask)];
-  }
-
-  /***/
-  QUILL_ATTRIBUTE_HOT void pop_front() noexcept { ++_reader_pos; }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT TransitEvent* back() noexcept
-  {
-    if (_capacity - size() == 0)
-    {
-      // is full
-      return nullptr;
-    }
-
-    return &_storage[static_cast<uint32_t>(_writer_pos & _mask)];
-  }
-
-  /***/
-  QUILL_ATTRIBUTE_HOT void push_back() noexcept { ++_writer_pos; }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT integer_type size() const noexcept
-  {
-    return static_cast<integer_type>(_writer_pos - _reader_pos);
-  }
-
-  /***/
-  QUILL_NODISCARD integer_type capacity() const noexcept
-  {
-    return static_cast<integer_type>(_capacity);
-  }
-
-private:
-  integer_type const _capacity;
-  integer_type const _mask;
-  integer_type _reader_pos{0};
-  integer_type _writer_pos{0};
-  std::vector<TransitEvent> _storage;
-};
-
-using BoundedTransitEventBuffer = BoundedTransitEventBufferImpl<uint32_t>;
-
-class UnboundedTransitEventBuffer
-{
-public:
-  /***/
-  struct Node
-  {
-    /**
-     * Constructor
-     * @param transit_buffer_capacity the capacity of the fixed buffer
-     */
-    explicit Node(uint32_t transit_buffer_capacity) : transit_buffer(transit_buffer_capacity) {}
-
-    /** members */
-    Node* next{nullptr};
-    BoundedTransitEventBuffer transit_buffer;
-  };
-
-  /***/
-  explicit UnboundedTransitEventBuffer(uint32_t initial_transit_buffer_capacity)
-    : _writer(new Node(initial_transit_buffer_capacity)), _reader(_writer)
-  {
-  }
-
-  /***/
-  UnboundedTransitEventBuffer(UnboundedTransitEventBuffer const&) = delete;
-  UnboundedTransitEventBuffer& operator=(UnboundedTransitEventBuffer const&) = delete;
-
-  /***/
-  ~UnboundedTransitEventBuffer()
-  {
-    Node const* reader_node = _reader;
-
-    // Look for extra nodes to delete
-    while (reader_node)
-    {
-      auto const to_delete = reader_node;
-      reader_node = reader_node->next;
-      delete to_delete;
-    }
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT TransitEvent* front() noexcept
-  {
-    TransitEvent* next_event = _reader->transit_buffer.front();
-
-    if (!next_event)
-    {
-      // the buffer is empty check if another buffer exists
-      if (QUILL_UNLIKELY(_reader->next != nullptr))
-      {
-        // a new buffer was added by the producer, this happens only when we have allocated a new queue
-
-        // switch to the new buffer, existing one is deleted
-        Node* next_node = _reader->next;
-        delete _reader;
-        _reader = next_node;
-        next_event = _reader->transit_buffer.front();
-      }
-    }
-
-    return next_event;
-  }
-
-  /***/
-  QUILL_ATTRIBUTE_HOT void pop_front() noexcept { _reader->transit_buffer.pop_front(); }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT TransitEvent* back() noexcept
-  {
-    // Try to reserve the bounded queue
-    TransitEvent* write_event = _writer->transit_buffer.back();
-
-    if (QUILL_UNLIKELY(write_event == nullptr))
-    {
-      // buffer doesn't have enough space
-      uint64_t capacity = static_cast<uint64_t>(_writer->transit_buffer.capacity()) * 2ull;
-      uint64_t constexpr max_bounded_queue_capacity =
-        (std::numeric_limits<BoundedTransitEventBuffer::integer_type>::max() >> 1) + 1;
-
-      if (QUILL_UNLIKELY(capacity > max_bounded_queue_capacity))
-      {
-        capacity = max_bounded_queue_capacity;
-      }
-
-      auto const new_node = new Node{static_cast<uint32_t>(capacity)};
-      _writer->next = new_node;
-      _writer = _writer->next;
-      write_event = _writer->transit_buffer.back();
-    }
-
-    assert(write_event && "Write event is always true");
-
-    return write_event;
-  }
-
-  /***/
-  QUILL_ATTRIBUTE_HOT void push_back() noexcept { _writer->transit_buffer.push_back(); }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT uint32_t size() const noexcept
-  {
-    Node const* reader = _reader;
-
-    uint32_t size = reader->transit_buffer.size();
-
-    while (reader->next)
-    {
-      reader = reader->next;
-      size += reader->transit_buffer.size();
-    }
-
-    return size;
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT bool empty() noexcept { return front() ? false : true; }
-
-private:
-  Node* _writer{nullptr};
-  Node* _reader{nullptr};
-};
-} // namespace quill::detail
diff --git a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/args.h b/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/args.h
deleted file mode 100644
index 3e2364c..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/args.h
+++ /dev/null
@@ -1,235 +0,0 @@
-// Formatting library for C++ - dynamic argument lists
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMTQUILL_ARGS_H_
-#define FMTQUILL_ARGS_H_
-
-#include <functional>  // std::reference_wrapper
-#include <memory>      // std::unique_ptr
-#include <vector>
-
-#include "core.h"
-
-FMTQUILL_BEGIN_NAMESPACE
-
-namespace detail {
-
-template <typename T> struct is_reference_wrapper : std::false_type {};
-template <typename T>
-struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
-
-template <typename T> auto unwrap(const T& v) -> const T& { return v; }
-template <typename T>
-auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
-  return static_cast<const T&>(v);
-}
-
-class dynamic_arg_list {
-  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
-  // templates it doesn't complain about inability to deduce single translation
-  // unit for placing vtable. So storage_node_base is made a fake template.
-  template <typename = void> struct node {
-    virtual ~node() = default;
-    std::unique_ptr<node<>> next;
-  };
-
-  template <typename T> struct typed_node : node<> {
-    T value;
-
-    template <typename Arg>
-    FMTQUILL_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
-
-    template <typename Char>
-    FMTQUILL_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
-        : value(arg.data(), arg.size()) {}
-  };
-
-  std::unique_ptr<node<>> head_;
-
- public:
-  template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
-    auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
-    auto& value = new_node->value;
-    new_node->next = std::move(head_);
-    head_ = std::move(new_node);
-    return value;
-  }
-};
-}  // namespace detail
-
-/**
-  \rst
-  A dynamic version of `fmtquill::format_arg_store`.
-  It's equipped with a storage to potentially temporary objects which lifetimes
-  could be shorter than the format arguments object.
-
-  It can be implicitly converted into `~fmtquill::basic_format_args` for passing
-  into type-erased formatting functions such as `~fmtquill::vformat`.
-  \endrst
- */
-template <typename Context>
-class dynamic_format_arg_store
-#if FMTQUILL_GCC_VERSION && FMTQUILL_GCC_VERSION < 409
-    // Workaround a GCC template argument substitution bug.
-    : public basic_format_args<Context>
-#endif
-{
- private:
-  using char_type = typename Context::char_type;
-
-  template <typename T> struct need_copy {
-    static constexpr detail::type mapped_type =
-        detail::mapped_type_constant<T, Context>::value;
-
-    enum {
-      value = !(detail::is_reference_wrapper<T>::value ||
-                std::is_same<T, basic_string_view<char_type>>::value ||
-                std::is_same<T, detail::std_string_view<char_type>>::value ||
-                (mapped_type != detail::type::cstring_type &&
-                 mapped_type != detail::type::string_type &&
-                 mapped_type != detail::type::custom_type))
-    };
-  };
-
-  template <typename T>
-  using stored_type = conditional_t<
-      std::is_convertible<T, std::basic_string<char_type>>::value &&
-          !detail::is_reference_wrapper<T>::value,
-      std::basic_string<char_type>, T>;
-
-  // Storage of basic_format_arg must be contiguous.
-  std::vector<basic_format_arg<Context>> data_;
-  std::vector<detail::named_arg_info<char_type>> named_info_;
-
-  // Storage of arguments not fitting into basic_format_arg must grow
-  // without relocation because items in data_ refer to it.
-  detail::dynamic_arg_list dynamic_args_;
-
-  friend class basic_format_args<Context>;
-
-  auto get_types() const -> unsigned long long {
-    return detail::is_unpacked_bit | data_.size() |
-           (named_info_.empty()
-                ? 0ULL
-                : static_cast<unsigned long long>(detail::has_named_args_bit));
-  }
-
-  auto data() const -> const basic_format_arg<Context>* {
-    return named_info_.empty() ? data_.data() : data_.data() + 1;
-  }
-
-  template <typename T> void emplace_arg(const T& arg) {
-    data_.emplace_back(detail::make_arg<Context>(arg));
-  }
-
-  template <typename T>
-  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
-    if (named_info_.empty()) {
-      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
-      data_.insert(data_.begin(), {zero_ptr, 0});
-    }
-    data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
-    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
-      data->pop_back();
-    };
-    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
-        guard{&data_, pop_one};
-    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
-    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
-    guard.release();
-  }
-
- public:
-  constexpr dynamic_format_arg_store() = default;
-
-  /**
-    \rst
-    Adds an argument into the dynamic store for later passing to a formatting
-    function.
-
-    Note that custom types and string types (but not string views) are copied
-    into the store dynamically allocating memory if necessary.
-
-    **Example**::
-
-      fmtquill::dynamic_format_arg_store<fmtquill::format_context> store;
-      store.push_back(42);
-      store.push_back("abc");
-      store.push_back(1.5f);
-      std::string result = fmtquill::vformat("{} and {} and {}", store);
-    \endrst
-  */
-  template <typename T> void push_back(const T& arg) {
-    if (detail::const_check(need_copy<T>::value))
-      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
-    else
-      emplace_arg(detail::unwrap(arg));
-  }
-
-  /**
-    \rst
-    Adds a reference to the argument into the dynamic store for later passing to
-    a formatting function.
-
-    **Example**::
-
-      fmtquill::dynamic_format_arg_store<fmtquill::format_context> store;
-      char band[] = "Rolling Stones";
-      store.push_back(std::cref(band));
-      band[9] = 'c'; // Changing str affects the output.
-      std::string result = fmtquill::vformat("{}", store);
-      // result == "Rolling Scones"
-    \endrst
-  */
-  template <typename T> void push_back(std::reference_wrapper<T> arg) {
-    static_assert(
-        need_copy<T>::value,
-        "objects of built-in types and string views are always copied");
-    emplace_arg(arg.get());
-  }
-
-  /**
-    Adds named argument into the dynamic store for later passing to a formatting
-    function. ``std::reference_wrapper`` is supported to avoid copying of the
-    argument. The name is always copied into the store.
-  */
-  template <typename T>
-  void push_back(const detail::named_arg<char_type, T>& arg) {
-    const char_type* arg_name =
-        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
-    if (detail::const_check(need_copy<T>::value)) {
-      emplace_arg(
-          fmtquill::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
-    } else {
-      emplace_arg(fmtquill::arg(arg_name, arg.value));
-    }
-  }
-
-  /** Erase all elements from the store */
-  void clear() {
-    data_.clear();
-    named_info_.clear();
-    dynamic_args_ = detail::dynamic_arg_list();
-  }
-
-  /**
-    \rst
-    Reserves space to store at least *new_cap* arguments including
-    *new_cap_named* named arguments.
-    \endrst
-  */
-  void reserve(size_t new_cap, size_t new_cap_named) {
-    FMTQUILL_ASSERT(new_cap >= new_cap_named,
-               "Set of arguments includes set of named arguments");
-    data_.reserve(new_cap);
-    named_info_.reserve(new_cap_named);
-  }
-};
-
-FMTQUILL_END_NAMESPACE
-
-#endif  // FMTQUILL_ARGS_H_
diff --git a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/chrono.h b/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/chrono.h
deleted file mode 100644
index f3bb7e4..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/chrono.h
+++ /dev/null
@@ -1,2240 +0,0 @@
-// Formatting library for C++ - chrono support
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMTQUILL_CHRONO_H_
-#define FMTQUILL_CHRONO_H_
-
-#include <algorithm>
-#include <chrono>
-#include <cmath>    // std::isfinite
-#include <cstring>  // std::memcpy
-#include <ctime>
-#include <iterator>
-#include <locale>
-#include <ostream>
-#include <type_traits>
-
-#include "ostream.h"  // formatbuf
-
-FMTQUILL_BEGIN_NAMESPACE
-
-// Check if std::chrono::local_t is available.
-#ifndef FMTQUILL_USE_LOCAL_TIME
-#  ifdef __cpp_lib_chrono
-#    define FMTQUILL_USE_LOCAL_TIME (__cpp_lib_chrono >= 201907L)
-#  else
-#    define FMTQUILL_USE_LOCAL_TIME 0
-#  endif
-#endif
-
-// Check if std::chrono::utc_timestamp is available.
-#ifndef FMTQUILL_USE_UTC_TIME
-#  ifdef __cpp_lib_chrono
-#    define FMTQUILL_USE_UTC_TIME (__cpp_lib_chrono >= 201907L)
-#  else
-#    define FMTQUILL_USE_UTC_TIME 0
-#  endif
-#endif
-
-// Enable tzset.
-#ifndef FMTQUILL_USE_TZSET
-// UWP doesn't provide _tzset.
-#  if FMTQUILL_HAS_INCLUDE("winapifamily.h")
-#    include <winapifamily.h>
-#  endif
-#  if defined(_WIN32) && (!defined(WINAPI_FAMILY) || \
-                          (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
-#    define FMTQUILL_USE_TZSET 1
-#  else
-#    define FMTQUILL_USE_TZSET 0
-#  endif
-#endif
-
-// Enable safe chrono durations, unless explicitly disabled.
-#ifndef FMTQUILL_SAFE_DURATION_CAST
-#  define FMTQUILL_SAFE_DURATION_CAST 1
-#endif
-#if FMTQUILL_SAFE_DURATION_CAST
-
-// For conversion between std::chrono::durations without undefined
-// behaviour or erroneous results.
-// This is a stripped down version of duration_cast, for inclusion in fmt.
-// See https://github.com/pauldreik/safe_duration_cast
-//
-// Copyright Paul Dreik 2019
-namespace safe_duration_cast {
-
-template <typename To, typename From,
-          FMTQUILL_ENABLE_IF(!std::is_same<From, To>::value &&
-                        std::numeric_limits<From>::is_signed ==
-                            std::numeric_limits<To>::is_signed)>
-FMTQUILL_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
-    -> To {
-  ec = 0;
-  using F = std::numeric_limits<From>;
-  using T = std::numeric_limits<To>;
-  static_assert(F::is_integer, "From must be integral");
-  static_assert(T::is_integer, "To must be integral");
-
-  // A and B are both signed, or both unsigned.
-  if (detail::const_check(F::digits <= T::digits)) {
-    // From fits in To without any problem.
-  } else {
-    // From does not always fit in To, resort to a dynamic check.
-    if (from < (T::min)() || from > (T::max)()) {
-      // outside range.
-      ec = 1;
-      return {};
-    }
-  }
-  return static_cast<To>(from);
-}
-
-/**
- * converts From to To, without loss. If the dynamic value of from
- * can't be converted to To without loss, ec is set.
- */
-template <typename To, typename From,
-          FMTQUILL_ENABLE_IF(!std::is_same<From, To>::value &&
-                        std::numeric_limits<From>::is_signed !=
-                            std::numeric_limits<To>::is_signed)>
-FMTQUILL_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
-    -> To {
-  ec = 0;
-  using F = std::numeric_limits<From>;
-  using T = std::numeric_limits<To>;
-  static_assert(F::is_integer, "From must be integral");
-  static_assert(T::is_integer, "To must be integral");
-
-  if (detail::const_check(F::is_signed && !T::is_signed)) {
-    // From may be negative, not allowed!
-    if (fmtquill::detail::is_negative(from)) {
-      ec = 1;
-      return {};
-    }
-    // From is positive. Can it always fit in To?
-    if (detail::const_check(F::digits > T::digits) &&
-        from > static_cast<From>(detail::max_value<To>())) {
-      ec = 1;
-      return {};
-    }
-  }
-
-  if (detail::const_check(!F::is_signed && T::is_signed &&
-                          F::digits >= T::digits) &&
-      from > static_cast<From>(detail::max_value<To>())) {
-    ec = 1;
-    return {};
-  }
-  return static_cast<To>(from);  // Lossless conversion.
-}
-
-template <typename To, typename From,
-          FMTQUILL_ENABLE_IF(std::is_same<From, To>::value)>
-FMTQUILL_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
-    -> To {
-  ec = 0;
-  return from;
-}  // function
-
-// clang-format off
-/**
- * converts From to To if possible, otherwise ec is set.
- *
- * input                            |    output
- * ---------------------------------|---------------
- * NaN                              | NaN
- * Inf                              | Inf
- * normal, fits in output           | converted (possibly lossy)
- * normal, does not fit in output   | ec is set
- * subnormal                        | best effort
- * -Inf                             | -Inf
- */
-// clang-format on
-template <typename To, typename From,
-          FMTQUILL_ENABLE_IF(!std::is_same<From, To>::value)>
-FMTQUILL_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {
-  ec = 0;
-  using T = std::numeric_limits<To>;
-  static_assert(std::is_floating_point<From>::value, "From must be floating");
-  static_assert(std::is_floating_point<To>::value, "To must be floating");
-
-  // catch the only happy case
-  if (std::isfinite(from)) {
-    if (from >= T::lowest() && from <= (T::max)()) {
-      return static_cast<To>(from);
-    }
-    // not within range.
-    ec = 1;
-    return {};
-  }
-
-  // nan and inf will be preserved
-  return static_cast<To>(from);
-}  // function
-
-template <typename To, typename From,
-          FMTQUILL_ENABLE_IF(std::is_same<From, To>::value)>
-FMTQUILL_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {
-  ec = 0;
-  static_assert(std::is_floating_point<From>::value, "From must be floating");
-  return from;
-}
-
-/**
- * safe duration cast between integral durations
- */
-template <typename To, typename FromRep, typename FromPeriod,
-          FMTQUILL_ENABLE_IF(std::is_integral<FromRep>::value),
-          FMTQUILL_ENABLE_IF(std::is_integral<typename To::rep>::value)>
-auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
-                        int& ec) -> To {
-  using From = std::chrono::duration<FromRep, FromPeriod>;
-  ec = 0;
-  // the basic idea is that we need to convert from count() in the from type
-  // to count() in the To type, by multiplying it with this:
-  struct Factor
-      : std::ratio_divide<typename From::period, typename To::period> {};
-
-  static_assert(Factor::num > 0, "num must be positive");
-  static_assert(Factor::den > 0, "den must be positive");
-
-  // the conversion is like this: multiply from.count() with Factor::num
-  // /Factor::den and convert it to To::rep, all this without
-  // overflow/underflow. let's start by finding a suitable type that can hold
-  // both To, From and Factor::num
-  using IntermediateRep =
-      typename std::common_type<typename From::rep, typename To::rep,
-                                decltype(Factor::num)>::type;
-
-  // safe conversion to IntermediateRep
-  IntermediateRep count =
-      lossless_integral_conversion<IntermediateRep>(from.count(), ec);
-  if (ec) return {};
-  // multiply with Factor::num without overflow or underflow
-  if (detail::const_check(Factor::num != 1)) {
-    const auto max1 = detail::max_value<IntermediateRep>() / Factor::num;
-    if (count > max1) {
-      ec = 1;
-      return {};
-    }
-    const auto min1 =
-        (std::numeric_limits<IntermediateRep>::min)() / Factor::num;
-    if (detail::const_check(!std::is_unsigned<IntermediateRep>::value) &&
-        count < min1) {
-      ec = 1;
-      return {};
-    }
-    count *= Factor::num;
-  }
-
-  if (detail::const_check(Factor::den != 1)) count /= Factor::den;
-  auto tocount = lossless_integral_conversion<typename To::rep>(count, ec);
-  return ec ? To() : To(tocount);
-}
-
-/**
- * safe duration_cast between floating point durations
- */
-template <typename To, typename FromRep, typename FromPeriod,
-          FMTQUILL_ENABLE_IF(std::is_floating_point<FromRep>::value),
-          FMTQUILL_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>
-auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
-                        int& ec) -> To {
-  using From = std::chrono::duration<FromRep, FromPeriod>;
-  ec = 0;
-  if (std::isnan(from.count())) {
-    // nan in, gives nan out. easy.
-    return To{std::numeric_limits<typename To::rep>::quiet_NaN()};
-  }
-  // maybe we should also check if from is denormal, and decide what to do about
-  // it.
-
-  // +-inf should be preserved.
-  if (std::isinf(from.count())) {
-    return To{from.count()};
-  }
-
-  // the basic idea is that we need to convert from count() in the from type
-  // to count() in the To type, by multiplying it with this:
-  struct Factor
-      : std::ratio_divide<typename From::period, typename To::period> {};
-
-  static_assert(Factor::num > 0, "num must be positive");
-  static_assert(Factor::den > 0, "den must be positive");
-
-  // the conversion is like this: multiply from.count() with Factor::num
-  // /Factor::den and convert it to To::rep, all this without
-  // overflow/underflow. let's start by finding a suitable type that can hold
-  // both To, From and Factor::num
-  using IntermediateRep =
-      typename std::common_type<typename From::rep, typename To::rep,
-                                decltype(Factor::num)>::type;
-
-  // force conversion of From::rep -> IntermediateRep to be safe,
-  // even if it will never happen be narrowing in this context.
-  IntermediateRep count =
-      safe_float_conversion<IntermediateRep>(from.count(), ec);
-  if (ec) {
-    return {};
-  }
-
-  // multiply with Factor::num without overflow or underflow
-  if (detail::const_check(Factor::num != 1)) {
-    constexpr auto max1 = detail::max_value<IntermediateRep>() /
-                          static_cast<IntermediateRep>(Factor::num);
-    if (count > max1) {
-      ec = 1;
-      return {};
-    }
-    constexpr auto min1 = std::numeric_limits<IntermediateRep>::lowest() /
-                          static_cast<IntermediateRep>(Factor::num);
-    if (count < min1) {
-      ec = 1;
-      return {};
-    }
-    count *= static_cast<IntermediateRep>(Factor::num);
-  }
-
-  // this can't go wrong, right? den>0 is checked earlier.
-  if (detail::const_check(Factor::den != 1)) {
-    using common_t = typename std::common_type<IntermediateRep, intmax_t>::type;
-    count /= static_cast<common_t>(Factor::den);
-  }
-
-  // convert to the to type, safely
-  using ToRep = typename To::rep;
-
-  const ToRep tocount = safe_float_conversion<ToRep>(count, ec);
-  if (ec) {
-    return {};
-  }
-  return To{tocount};
-}
-}  // namespace safe_duration_cast
-#endif
-
-// Prevents expansion of a preceding token as a function-style macro.
-// Usage: f FMTQUILL_NOMACRO()
-#define FMTQUILL_NOMACRO
-
-namespace detail {
-template <typename T = void> struct null {};
-inline auto localtime_r FMTQUILL_NOMACRO(...) -> null<> { return null<>(); }
-inline auto localtime_s(...) -> null<> { return null<>(); }
-inline auto gmtime_r(...) -> null<> { return null<>(); }
-inline auto gmtime_s(...) -> null<> { return null<>(); }
-
-inline auto get_classic_locale() -> const std::locale& {
-  static const auto& locale = std::locale::classic();
-  return locale;
-}
-
-template <typename CodeUnit> struct codecvt_result {
-  static constexpr const size_t max_size = 32;
-  CodeUnit buf[max_size];
-  CodeUnit* end;
-};
-
-template <typename CodeUnit>
-void write_codecvt(codecvt_result<CodeUnit>& out, string_view in_buf,
-                   const std::locale& loc) {
-#if FMTQUILL_CLANG_VERSION
-#  pragma clang diagnostic push
-#  pragma clang diagnostic ignored "-Wdeprecated"
-  auto& f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc);
-#  pragma clang diagnostic pop
-#else
-  auto& f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc);
-#endif
-  auto mb = std::mbstate_t();
-  const char* from_next = nullptr;
-  auto result = f.in(mb, in_buf.begin(), in_buf.end(), from_next,
-                     std::begin(out.buf), std::end(out.buf), out.end);
-  if (result != std::codecvt_base::ok)
-    FMTQUILL_THROW(format_error("failed to format time"));
-}
-
-template <typename OutputIt>
-auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc)
-    -> OutputIt {
-  if (detail::is_utf8() && loc != get_classic_locale()) {
-    // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and
-    // gcc-4.
-#if FMTQUILL_MSC_VERSION != 0 || \
-    (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI))
-    // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5
-    // and newer.
-    using code_unit = wchar_t;
-#else
-    using code_unit = char32_t;
-#endif
-
-    using unit_t = codecvt_result<code_unit>;
-    unit_t unit;
-    write_codecvt(unit, in, loc);
-    // In UTF-8 is used one to four one-byte code units.
-    auto u =
-        to_utf8<code_unit, basic_memory_buffer<char, unit_t::max_size * 4>>();
-    if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)}))
-      FMTQUILL_THROW(format_error("failed to format time"));
-    return copy_str<char>(u.c_str(), u.c_str() + u.size(), out);
-  }
-  return copy_str<char>(in.data(), in.data() + in.size(), out);
-}
-
-template <typename Char, typename OutputIt,
-          FMTQUILL_ENABLE_IF(!std::is_same<Char, char>::value)>
-auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc)
-    -> OutputIt {
-  codecvt_result<Char> unit;
-  write_codecvt(unit, sv, loc);
-  return copy_str<Char>(unit.buf, unit.end, out);
-}
-
-template <typename Char, typename OutputIt,
-          FMTQUILL_ENABLE_IF(std::is_same<Char, char>::value)>
-auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc)
-    -> OutputIt {
-  return write_encoded_tm_str(out, sv, loc);
-}
-
-template <typename Char>
-inline void do_write(buffer<Char>& buf, const std::tm& time,
-                     const std::locale& loc, char format, char modifier) {
-  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
-  auto&& os = std::basic_ostream<Char>(&format_buf);
-  os.imbue(loc);
-  const auto& facet = std::use_facet<std::time_put<Char>>(loc);
-  auto end = facet.put(os, os, Char(' '), &time, format, modifier);
-  if (end.failed()) FMTQUILL_THROW(format_error("failed to format time"));
-}
-
-template <typename Char, typename OutputIt,
-          FMTQUILL_ENABLE_IF(!std::is_same<Char, char>::value)>
-auto write(OutputIt out, const std::tm& time, const std::locale& loc,
-           char format, char modifier = 0) -> OutputIt {
-  auto&& buf = get_buffer<Char>(out);
-  do_write<Char>(buf, time, loc, format, modifier);
-  return get_iterator(buf, out);
-}
-
-template <typename Char, typename OutputIt,
-          FMTQUILL_ENABLE_IF(std::is_same<Char, char>::value)>
-auto write(OutputIt out, const std::tm& time, const std::locale& loc,
-           char format, char modifier = 0) -> OutputIt {
-  auto&& buf = basic_memory_buffer<Char>();
-  do_write<char>(buf, time, loc, format, modifier);
-  return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc);
-}
-
-template <typename Rep1, typename Rep2>
-struct is_same_arithmetic_type
-    : public std::integral_constant<bool,
-                                    (std::is_integral<Rep1>::value &&
-                                     std::is_integral<Rep2>::value) ||
-                                        (std::is_floating_point<Rep1>::value &&
-                                         std::is_floating_point<Rep2>::value)> {
-};
-
-template <
-    typename To, typename FromRep, typename FromPeriod,
-    FMTQUILL_ENABLE_IF(is_same_arithmetic_type<FromRep, typename To::rep>::value)>
-auto fmt_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To {
-#if FMTQUILL_SAFE_DURATION_CAST
-  // Throwing version of safe_duration_cast is only available for
-  // integer to integer or float to float casts.
-  int ec;
-  To to = safe_duration_cast::safe_duration_cast<To>(from, ec);
-  if (ec) FMTQUILL_THROW(format_error("cannot format duration"));
-  return to;
-#else
-  // Standard duration cast, may overflow.
-  return std::chrono::duration_cast<To>(from);
-#endif
-}
-
-template <
-    typename To, typename FromRep, typename FromPeriod,
-    FMTQUILL_ENABLE_IF(!is_same_arithmetic_type<FromRep, typename To::rep>::value)>
-auto fmt_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To {
-  // Mixed integer <-> float cast is not supported by safe_duration_cast.
-  return std::chrono::duration_cast<To>(from);
-}
-
-template <typename Duration>
-auto to_time_t(
-    std::chrono::time_point<std::chrono::system_clock, Duration> time_point)
-    -> std::time_t {
-  // Cannot use std::chrono::system_clock::to_time_t since this would first
-  // require a cast to std::chrono::system_clock::time_point, which could
-  // overflow.
-  return fmt_duration_cast<std::chrono::duration<std::time_t>>(
-             time_point.time_since_epoch())
-      .count();
-}
-}  // namespace detail
-
-FMTQUILL_BEGIN_EXPORT
-
-/**
-  Converts given time since epoch as ``std::time_t`` value into calendar time,
-  expressed in local time. Unlike ``std::localtime``, this function is
-  thread-safe on most platforms.
- */
-inline auto localtime(std::time_t time) -> std::tm {
-  struct dispatcher {
-    std::time_t time_;
-    std::tm tm_;
-
-    dispatcher(std::time_t t) : time_(t) {}
-
-    auto run() -> bool {
-      using namespace fmtquill::detail;
-      return handle(localtime_r(&time_, &tm_));
-    }
-
-    auto handle(std::tm* tm) -> bool { return tm != nullptr; }
-
-    auto handle(detail::null<>) -> bool {
-      using namespace fmtquill::detail;
-      return fallback(localtime_s(&tm_, &time_));
-    }
-
-    auto fallback(int res) -> bool { return res == 0; }
-
-#if !FMTQUILL_MSC_VERSION
-    auto fallback(detail::null<>) -> bool {
-      using namespace fmtquill::detail;
-      std::tm* tm = std::localtime(&time_);
-      if (tm) tm_ = *tm;
-      return tm != nullptr;
-    }
-#endif
-  };
-  dispatcher lt(time);
-  // Too big time values may be unsupported.
-  if (!lt.run()) FMTQUILL_THROW(format_error("time_t value out of range"));
-  return lt.tm_;
-}
-
-#if FMTQUILL_USE_LOCAL_TIME
-template <typename Duration>
-inline auto localtime(std::chrono::local_time<Duration> time) -> std::tm {
-  return localtime(
-      detail::to_time_t(std::chrono::current_zone()->to_sys(time)));
-}
-#endif
-
-/**
-  Converts given time since epoch as ``std::time_t`` value into calendar time,
-  expressed in Coordinated Universal Time (UTC). Unlike ``std::gmtime``, this
-  function is thread-safe on most platforms.
- */
-inline auto gmtime(std::time_t time) -> std::tm {
-  struct dispatcher {
-    std::time_t time_;
-    std::tm tm_;
-
-    dispatcher(std::time_t t) : time_(t) {}
-
-    auto run() -> bool {
-      using namespace fmtquill::detail;
-      return handle(gmtime_r(&time_, &tm_));
-    }
-
-    auto handle(std::tm* tm) -> bool { return tm != nullptr; }
-
-    auto handle(detail::null<>) -> bool {
-      using namespace fmtquill::detail;
-      return fallback(gmtime_s(&tm_, &time_));
-    }
-
-    auto fallback(int res) -> bool { return res == 0; }
-
-#if !FMTQUILL_MSC_VERSION
-    auto fallback(detail::null<>) -> bool {
-      std::tm* tm = std::gmtime(&time_);
-      if (tm) tm_ = *tm;
-      return tm != nullptr;
-    }
-#endif
-  };
-  auto gt = dispatcher(time);
-  // Too big time values may be unsupported.
-  if (!gt.run()) FMTQUILL_THROW(format_error("time_t value out of range"));
-  return gt.tm_;
-}
-
-template <typename Duration>
-inline auto gmtime(
-    std::chrono::time_point<std::chrono::system_clock, Duration> time_point)
-    -> std::tm {
-  return gmtime(detail::to_time_t(time_point));
-}
-
-namespace detail {
-
-// Writes two-digit numbers a, b and c separated by sep to buf.
-// The method by Pavel Novikov based on
-// https://johnnylee-sde.github.io/Fast-unsigned-integer-to-time-string/.
-inline void write_digit2_separated(char* buf, unsigned a, unsigned b,
-                                   unsigned c, char sep) {
-  unsigned long long digits =
-      a | (b << 24) | (static_cast<unsigned long long>(c) << 48);
-  // Convert each value to BCD.
-  // We have x = a * 10 + b and we want to convert it to BCD y = a * 16 + b.
-  // The difference is
-  //   y - x = a * 6
-  // a can be found from x:
-  //   a = floor(x / 10)
-  // then
-  //   y = x + a * 6 = x + floor(x / 10) * 6
-  // floor(x / 10) is (x * 205) >> 11 (needs 16 bits).
-  digits += (((digits * 205) >> 11) & 0x000f00000f00000f) * 6;
-  // Put low nibbles to high bytes and high nibbles to low bytes.
-  digits = ((digits & 0x00f00000f00000f0) >> 4) |
-           ((digits & 0x000f00000f00000f) << 8);
-  auto usep = static_cast<unsigned long long>(sep);
-  // Add ASCII '0' to each digit byte and insert separators.
-  digits |= 0x3030003030003030 | (usep << 16) | (usep << 40);
-
-  constexpr const size_t len = 8;
-  if (const_check(is_big_endian())) {
-    char tmp[len];
-    std::memcpy(tmp, &digits, len);
-    std::reverse_copy(tmp, tmp + len, buf);
-  } else {
-    std::memcpy(buf, &digits, len);
-  }
-}
-
-template <typename Period>
-FMTQUILL_CONSTEXPR inline auto get_units() -> const char* {
-  if (std::is_same<Period, std::atto>::value) return "as";
-  if (std::is_same<Period, std::femto>::value) return "fs";
-  if (std::is_same<Period, std::pico>::value) return "ps";
-  if (std::is_same<Period, std::nano>::value) return "ns";
-  if (std::is_same<Period, std::micro>::value) return "µs";
-  if (std::is_same<Period, std::milli>::value) return "ms";
-  if (std::is_same<Period, std::centi>::value) return "cs";
-  if (std::is_same<Period, std::deci>::value) return "ds";
-  if (std::is_same<Period, std::ratio<1>>::value) return "s";
-  if (std::is_same<Period, std::deca>::value) return "das";
-  if (std::is_same<Period, std::hecto>::value) return "hs";
-  if (std::is_same<Period, std::kilo>::value) return "ks";
-  if (std::is_same<Period, std::mega>::value) return "Ms";
-  if (std::is_same<Period, std::giga>::value) return "Gs";
-  if (std::is_same<Period, std::tera>::value) return "Ts";
-  if (std::is_same<Period, std::peta>::value) return "Ps";
-  if (std::is_same<Period, std::exa>::value) return "Es";
-  if (std::is_same<Period, std::ratio<60>>::value) return "min";
-  if (std::is_same<Period, std::ratio<3600>>::value) return "h";
-  if (std::is_same<Period, std::ratio<86400>>::value) return "d";
-  return nullptr;
-}
-
-enum class numeric_system {
-  standard,
-  // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.
-  alternative
-};
-
-// Glibc extensions for formatting numeric values.
-enum class pad_type {
-  unspecified,
-  // Do not pad a numeric result string.
-  none,
-  // Pad a numeric result string with zeros even if the conversion specifier
-  // character uses space-padding by default.
-  zero,
-  // Pad a numeric result string with spaces.
-  space,
-};
-
-template <typename OutputIt>
-auto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt {
-  if (pad == pad_type::none) return out;
-  return std::fill_n(out, width, pad == pad_type::space ? ' ' : '0');
-}
-
-template <typename OutputIt>
-auto write_padding(OutputIt out, pad_type pad) -> OutputIt {
-  if (pad != pad_type::none) *out++ = pad == pad_type::space ? ' ' : '0';
-  return out;
-}
-
-// Parses a put_time-like format string and invokes handler actions.
-template <typename Char, typename Handler>
-FMTQUILL_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end,
-                                       Handler&& handler) -> const Char* {
-  if (begin == end || *begin == '}') return begin;
-  if (*begin != '%') FMTQUILL_THROW(format_error("invalid format"));
-  auto ptr = begin;
-  pad_type pad = pad_type::unspecified;
-  while (ptr != end) {
-    auto c = *ptr;
-    if (c == '}') break;
-    if (c != '%') {
-      ++ptr;
-      continue;
-    }
-    if (begin != ptr) handler.on_text(begin, ptr);
-    ++ptr;  // consume '%'
-    if (ptr == end) FMTQUILL_THROW(format_error("invalid format"));
-    c = *ptr;
-    switch (c) {
-    case '_':
-      pad = pad_type::space;
-      ++ptr;
-      break;
-    case '-':
-      pad = pad_type::none;
-      ++ptr;
-      break;
-    case '0':
-      pad = pad_type::zero;
-      ++ptr;
-      break;
-    }
-    if (ptr == end) FMTQUILL_THROW(format_error("invalid format"));
-    c = *ptr++;
-    switch (c) {
-    case '%':
-      handler.on_text(ptr - 1, ptr);
-      break;
-    case 'n': {
-      const Char newline[] = {'\n'};
-      handler.on_text(newline, newline + 1);
-      break;
-    }
-    case 't': {
-      const Char tab[] = {'\t'};
-      handler.on_text(tab, tab + 1);
-      break;
-    }
-    // Year:
-    case 'Y':
-      handler.on_year(numeric_system::standard);
-      break;
-    case 'y':
-      handler.on_short_year(numeric_system::standard);
-      break;
-    case 'C':
-      handler.on_century(numeric_system::standard);
-      break;
-    case 'G':
-      handler.on_iso_week_based_year();
-      break;
-    case 'g':
-      handler.on_iso_week_based_short_year();
-      break;
-    // Day of the week:
-    case 'a':
-      handler.on_abbr_weekday();
-      break;
-    case 'A':
-      handler.on_full_weekday();
-      break;
-    case 'w':
-      handler.on_dec0_weekday(numeric_system::standard);
-      break;
-    case 'u':
-      handler.on_dec1_weekday(numeric_system::standard);
-      break;
-    // Month:
-    case 'b':
-    case 'h':
-      handler.on_abbr_month();
-      break;
-    case 'B':
-      handler.on_full_month();
-      break;
-    case 'm':
-      handler.on_dec_month(numeric_system::standard);
-      break;
-    // Day of the year/month:
-    case 'U':
-      handler.on_dec0_week_of_year(numeric_system::standard);
-      break;
-    case 'W':
-      handler.on_dec1_week_of_year(numeric_system::standard);
-      break;
-    case 'V':
-      handler.on_iso_week_of_year(numeric_system::standard);
-      break;
-    case 'j':
-      handler.on_day_of_year();
-      break;
-    case 'd':
-      handler.on_day_of_month(numeric_system::standard);
-      break;
-    case 'e':
-      handler.on_day_of_month_space(numeric_system::standard);
-      break;
-    // Hour, minute, second:
-    case 'H':
-      handler.on_24_hour(numeric_system::standard, pad);
-      break;
-    case 'I':
-      handler.on_12_hour(numeric_system::standard, pad);
-      break;
-    case 'M':
-      handler.on_minute(numeric_system::standard, pad);
-      break;
-    case 'S':
-      handler.on_second(numeric_system::standard, pad);
-      break;
-    // Other:
-    case 'c':
-      handler.on_datetime(numeric_system::standard);
-      break;
-    case 'x':
-      handler.on_loc_date(numeric_system::standard);
-      break;
-    case 'X':
-      handler.on_loc_time(numeric_system::standard);
-      break;
-    case 'D':
-      handler.on_us_date();
-      break;
-    case 'F':
-      handler.on_iso_date();
-      break;
-    case 'r':
-      handler.on_12_hour_time();
-      break;
-    case 'R':
-      handler.on_24_hour_time();
-      break;
-    case 'T':
-      handler.on_iso_time();
-      break;
-    case 'p':
-      handler.on_am_pm();
-      break;
-    case 'Q':
-      handler.on_duration_value();
-      break;
-    case 'q':
-      handler.on_duration_unit();
-      break;
-    case 'z':
-      handler.on_utc_offset(numeric_system::standard);
-      break;
-    case 'Z':
-      handler.on_tz_name();
-      break;
-    // Alternative representation:
-    case 'E': {
-      if (ptr == end) FMTQUILL_THROW(format_error("invalid format"));
-      c = *ptr++;
-      switch (c) {
-      case 'Y':
-        handler.on_year(numeric_system::alternative);
-        break;
-      case 'y':
-        handler.on_offset_year();
-        break;
-      case 'C':
-        handler.on_century(numeric_system::alternative);
-        break;
-      case 'c':
-        handler.on_datetime(numeric_system::alternative);
-        break;
-      case 'x':
-        handler.on_loc_date(numeric_system::alternative);
-        break;
-      case 'X':
-        handler.on_loc_time(numeric_system::alternative);
-        break;
-      case 'z':
-        handler.on_utc_offset(numeric_system::alternative);
-        break;
-      default:
-        FMTQUILL_THROW(format_error("invalid format"));
-      }
-      break;
-    }
-    case 'O':
-      if (ptr == end) FMTQUILL_THROW(format_error("invalid format"));
-      c = *ptr++;
-      switch (c) {
-      case 'y':
-        handler.on_short_year(numeric_system::alternative);
-        break;
-      case 'm':
-        handler.on_dec_month(numeric_system::alternative);
-        break;
-      case 'U':
-        handler.on_dec0_week_of_year(numeric_system::alternative);
-        break;
-      case 'W':
-        handler.on_dec1_week_of_year(numeric_system::alternative);
-        break;
-      case 'V':
-        handler.on_iso_week_of_year(numeric_system::alternative);
-        break;
-      case 'd':
-        handler.on_day_of_month(numeric_system::alternative);
-        break;
-      case 'e':
-        handler.on_day_of_month_space(numeric_system::alternative);
-        break;
-      case 'w':
-        handler.on_dec0_weekday(numeric_system::alternative);
-        break;
-      case 'u':
-        handler.on_dec1_weekday(numeric_system::alternative);
-        break;
-      case 'H':
-        handler.on_24_hour(numeric_system::alternative, pad);
-        break;
-      case 'I':
-        handler.on_12_hour(numeric_system::alternative, pad);
-        break;
-      case 'M':
-        handler.on_minute(numeric_system::alternative, pad);
-        break;
-      case 'S':
-        handler.on_second(numeric_system::alternative, pad);
-        break;
-      case 'z':
-        handler.on_utc_offset(numeric_system::alternative);
-        break;
-      default:
-        FMTQUILL_THROW(format_error("invalid format"));
-      }
-      break;
-    default:
-      FMTQUILL_THROW(format_error("invalid format"));
-    }
-    begin = ptr;
-  }
-  if (begin != ptr) handler.on_text(begin, ptr);
-  return ptr;
-}
-
-template <typename Derived> struct null_chrono_spec_handler {
-  FMTQUILL_CONSTEXPR void unsupported() {
-    static_cast<Derived*>(this)->unsupported();
-  }
-  FMTQUILL_CONSTEXPR void on_year(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_short_year(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_offset_year() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_century(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_iso_week_based_year() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_iso_week_based_short_year() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_abbr_weekday() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_full_weekday() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_dec0_weekday(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_dec1_weekday(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_abbr_month() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_full_month() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_dec_month(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_dec0_week_of_year(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_dec1_week_of_year(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_iso_week_of_year(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_day_of_year() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_day_of_month(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_day_of_month_space(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_minute(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_second(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_datetime(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_loc_date(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_loc_time(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_us_date() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_iso_date() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_12_hour_time() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_24_hour_time() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_iso_time() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_am_pm() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_duration_value() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_duration_unit() { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_utc_offset(numeric_system) { unsupported(); }
-  FMTQUILL_CONSTEXPR void on_tz_name() { unsupported(); }
-};
-
-struct tm_format_checker : null_chrono_spec_handler<tm_format_checker> {
-  FMTQUILL_NORETURN void unsupported() { FMTQUILL_THROW(format_error("no format")); }
-
-  template <typename Char>
-  FMTQUILL_CONSTEXPR void on_text(const Char*, const Char*) {}
-  FMTQUILL_CONSTEXPR void on_year(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_short_year(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_offset_year() {}
-  FMTQUILL_CONSTEXPR void on_century(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_iso_week_based_year() {}
-  FMTQUILL_CONSTEXPR void on_iso_week_based_short_year() {}
-  FMTQUILL_CONSTEXPR void on_abbr_weekday() {}
-  FMTQUILL_CONSTEXPR void on_full_weekday() {}
-  FMTQUILL_CONSTEXPR void on_dec0_weekday(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_dec1_weekday(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_abbr_month() {}
-  FMTQUILL_CONSTEXPR void on_full_month() {}
-  FMTQUILL_CONSTEXPR void on_dec_month(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_dec0_week_of_year(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_dec1_week_of_year(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_iso_week_of_year(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_day_of_year() {}
-  FMTQUILL_CONSTEXPR void on_day_of_month(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_day_of_month_space(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_24_hour(numeric_system, pad_type) {}
-  FMTQUILL_CONSTEXPR void on_12_hour(numeric_system, pad_type) {}
-  FMTQUILL_CONSTEXPR void on_minute(numeric_system, pad_type) {}
-  FMTQUILL_CONSTEXPR void on_second(numeric_system, pad_type) {}
-  FMTQUILL_CONSTEXPR void on_datetime(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_loc_date(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_loc_time(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_us_date() {}
-  FMTQUILL_CONSTEXPR void on_iso_date() {}
-  FMTQUILL_CONSTEXPR void on_12_hour_time() {}
-  FMTQUILL_CONSTEXPR void on_24_hour_time() {}
-  FMTQUILL_CONSTEXPR void on_iso_time() {}
-  FMTQUILL_CONSTEXPR void on_am_pm() {}
-  FMTQUILL_CONSTEXPR void on_utc_offset(numeric_system) {}
-  FMTQUILL_CONSTEXPR void on_tz_name() {}
-};
-
-inline auto tm_wday_full_name(int wday) -> const char* {
-  static constexpr const char* full_name_list[] = {
-      "Sunday",   "Monday", "Tuesday", "Wednesday",
-      "Thursday", "Friday", "Saturday"};
-  return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?";
-}
-inline auto tm_wday_short_name(int wday) -> const char* {
-  static constexpr const char* short_name_list[] = {"Sun", "Mon", "Tue", "Wed",
-                                                    "Thu", "Fri", "Sat"};
-  return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???";
-}
-
-inline auto tm_mon_full_name(int mon) -> const char* {
-  static constexpr const char* full_name_list[] = {
-      "January", "February", "March",     "April",   "May",      "June",
-      "July",    "August",   "September", "October", "November", "December"};
-  return mon >= 0 && mon <= 11 ? full_name_list[mon] : "?";
-}
-inline auto tm_mon_short_name(int mon) -> const char* {
-  static constexpr const char* short_name_list[] = {
-      "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-      "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
-  };
-  return mon >= 0 && mon <= 11 ? short_name_list[mon] : "???";
-}
-
-template <typename T, typename = void>
-struct has_member_data_tm_gmtoff : std::false_type {};
-template <typename T>
-struct has_member_data_tm_gmtoff<T, void_t<decltype(T::tm_gmtoff)>>
-    : std::true_type {};
-
-template <typename T, typename = void>
-struct has_member_data_tm_zone : std::false_type {};
-template <typename T>
-struct has_member_data_tm_zone<T, void_t<decltype(T::tm_zone)>>
-    : std::true_type {};
-
-#if FMTQUILL_USE_TZSET
-inline void tzset_once() {
-  static bool init = []() -> bool {
-    _tzset();
-    return true;
-  }();
-  ignore_unused(init);
-}
-#endif
-
-// Converts value to Int and checks that it's in the range [0, upper).
-template <typename T, typename Int, FMTQUILL_ENABLE_IF(std::is_integral<T>::value)>
-inline auto to_nonnegative_int(T value, Int upper) -> Int {
-  if (!std::is_unsigned<Int>::value &&
-      (value < 0 || to_unsigned(value) > to_unsigned(upper))) {
-    FMTQUILL_THROW(fmtquill::format_error("chrono value is out of range"));
-  }
-  return static_cast<Int>(value);
-}
-template <typename T, typename Int, FMTQUILL_ENABLE_IF(!std::is_integral<T>::value)>
-inline auto to_nonnegative_int(T value, Int upper) -> Int {
-  if (value < 0 || value > static_cast<T>(upper))
-    FMTQUILL_THROW(format_error("invalid value"));
-  return static_cast<Int>(value);
-}
-
-constexpr auto pow10(std::uint32_t n) -> long long {
-  return n == 0 ? 1 : 10 * pow10(n - 1);
-}
-
-// Counts the number of fractional digits in the range [0, 18] according to the
-// C++20 spec. If more than 18 fractional digits are required then returns 6 for
-// microseconds precision.
-template <long long Num, long long Den, int N = 0,
-          bool Enabled = (N < 19) && (Num <= max_value<long long>() / 10)>
-struct count_fractional_digits {
-  static constexpr int value =
-      Num % Den == 0 ? N : count_fractional_digits<Num * 10, Den, N + 1>::value;
-};
-
-// Base case that doesn't instantiate any more templates
-// in order to avoid overflow.
-template <long long Num, long long Den, int N>
-struct count_fractional_digits<Num, Den, N, false> {
-  static constexpr int value = (Num % Den == 0) ? N : 6;
-};
-
-// Format subseconds which are given as an integer type with an appropriate
-// number of digits.
-template <typename Char, typename OutputIt, typename Duration>
-void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) {
-  constexpr auto num_fractional_digits =
-      count_fractional_digits<Duration::period::num,
-                              Duration::period::den>::value;
-
-  using subsecond_precision = std::chrono::duration<
-      typename std::common_type<typename Duration::rep,
-                                std::chrono::seconds::rep>::type,
-      std::ratio<1, detail::pow10(num_fractional_digits)>>;
-
-  const auto fractional = d - fmt_duration_cast<std::chrono::seconds>(d);
-  const auto subseconds =
-      std::chrono::treat_as_floating_point<
-          typename subsecond_precision::rep>::value
-          ? fractional.count()
-          : fmt_duration_cast<subsecond_precision>(fractional).count();
-  auto n = static_cast<uint32_or_64_or_128_t<long long>>(subseconds);
-  const int num_digits = detail::count_digits(n);
-
-  int leading_zeroes = (std::max)(0, num_fractional_digits - num_digits);
-  if (precision < 0) {
-    FMTQUILL_ASSERT(!std::is_floating_point<typename Duration::rep>::value, "");
-    if (std::ratio_less<typename subsecond_precision::period,
-                        std::chrono::seconds::period>::value) {
-      *out++ = '.';
-      out = std::fill_n(out, leading_zeroes, '0');
-      out = format_decimal<Char>(out, n, num_digits).end;
-    }
-  } else {
-    *out++ = '.';
-    leading_zeroes = (std::min)(leading_zeroes, precision);
-    out = std::fill_n(out, leading_zeroes, '0');
-    int remaining = precision - leading_zeroes;
-    if (remaining != 0 && remaining < num_digits) {
-      n /= to_unsigned(detail::pow10(to_unsigned(num_digits - remaining)));
-      out = format_decimal<Char>(out, n, remaining).end;
-      return;
-    }
-    out = format_decimal<Char>(out, n, num_digits).end;
-    remaining -= num_digits;
-    out = std::fill_n(out, remaining, '0');
-  }
-}
-
-// Format subseconds which are given as a floating point type with an
-// appropriate number of digits. We cannot pass the Duration here, as we
-// explicitly need to pass the Rep value in the chrono_formatter.
-template <typename Duration>
-void write_floating_seconds(memory_buffer& buf, Duration duration,
-                            int num_fractional_digits = -1) {
-  using rep = typename Duration::rep;
-  FMTQUILL_ASSERT(std::is_floating_point<rep>::value, "");
-
-  auto val = duration.count();
-
-  if (num_fractional_digits < 0) {
-    // For `std::round` with fallback to `round`:
-    // On some toolchains `std::round` is not available (e.g. GCC 6).
-    using namespace std;
-    num_fractional_digits =
-        count_fractional_digits<Duration::period::num,
-                                Duration::period::den>::value;
-    if (num_fractional_digits < 6 && static_cast<rep>(round(val)) != val)
-      num_fractional_digits = 6;
-  }
-
-  fmtquill::format_to(std::back_inserter(buf), FMTQUILL_STRING("{:.{}f}"),
-                 std::fmod(val * static_cast<rep>(Duration::period::num) /
-                               static_cast<rep>(Duration::period::den),
-                           static_cast<rep>(60)),
-                 num_fractional_digits);
-}
-
-template <typename OutputIt, typename Char,
-          typename Duration = std::chrono::seconds>
-class tm_writer {
- private:
-  static constexpr int days_per_week = 7;
-
-  const std::locale& loc_;
-  const bool is_classic_;
-  OutputIt out_;
-  const Duration* subsecs_;
-  const std::tm& tm_;
-
-  auto tm_sec() const noexcept -> int {
-    FMTQUILL_ASSERT(tm_.tm_sec >= 0 && tm_.tm_sec <= 61, "");
-    return tm_.tm_sec;
-  }
-  auto tm_min() const noexcept -> int {
-    FMTQUILL_ASSERT(tm_.tm_min >= 0 && tm_.tm_min <= 59, "");
-    return tm_.tm_min;
-  }
-  auto tm_hour() const noexcept -> int {
-    FMTQUILL_ASSERT(tm_.tm_hour >= 0 && tm_.tm_hour <= 23, "");
-    return tm_.tm_hour;
-  }
-  auto tm_mday() const noexcept -> int {
-    FMTQUILL_ASSERT(tm_.tm_mday >= 1 && tm_.tm_mday <= 31, "");
-    return tm_.tm_mday;
-  }
-  auto tm_mon() const noexcept -> int {
-    FMTQUILL_ASSERT(tm_.tm_mon >= 0 && tm_.tm_mon <= 11, "");
-    return tm_.tm_mon;
-  }
-  auto tm_year() const noexcept -> long long { return 1900ll + tm_.tm_year; }
-  auto tm_wday() const noexcept -> int {
-    FMTQUILL_ASSERT(tm_.tm_wday >= 0 && tm_.tm_wday <= 6, "");
-    return tm_.tm_wday;
-  }
-  auto tm_yday() const noexcept -> int {
-    FMTQUILL_ASSERT(tm_.tm_yday >= 0 && tm_.tm_yday <= 365, "");
-    return tm_.tm_yday;
-  }
-
-  auto tm_hour12() const noexcept -> int {
-    const auto h = tm_hour();
-    const auto z = h < 12 ? h : h - 12;
-    return z == 0 ? 12 : z;
-  }
-
-  // POSIX and the C Standard are unclear or inconsistent about what %C and %y
-  // do if the year is negative or exceeds 9999. Use the convention that %C
-  // concatenated with %y yields the same output as %Y, and that %Y contains at
-  // least 4 characters, with more only if necessary.
-  auto split_year_lower(long long year) const noexcept -> int {
-    auto l = year % 100;
-    if (l < 0) l = -l;  // l in [0, 99]
-    return static_cast<int>(l);
-  }
-
-  // Algorithm: https://en.wikipedia.org/wiki/ISO_week_date.
-  auto iso_year_weeks(long long curr_year) const noexcept -> int {
-    const auto prev_year = curr_year - 1;
-    const auto curr_p =
-        (curr_year + curr_year / 4 - curr_year / 100 + curr_year / 400) %
-        days_per_week;
-    const auto prev_p =
-        (prev_year + prev_year / 4 - prev_year / 100 + prev_year / 400) %
-        days_per_week;
-    return 52 + ((curr_p == 4 || prev_p == 3) ? 1 : 0);
-  }
-  auto iso_week_num(int tm_yday, int tm_wday) const noexcept -> int {
-    return (tm_yday + 11 - (tm_wday == 0 ? days_per_week : tm_wday)) /
-           days_per_week;
-  }
-  auto tm_iso_week_year() const noexcept -> long long {
-    const auto year = tm_year();
-    const auto w = iso_week_num(tm_yday(), tm_wday());
-    if (w < 1) return year - 1;
-    if (w > iso_year_weeks(year)) return year + 1;
-    return year;
-  }
-  auto tm_iso_week_of_year() const noexcept -> int {
-    const auto year = tm_year();
-    const auto w = iso_week_num(tm_yday(), tm_wday());
-    if (w < 1) return iso_year_weeks(year - 1);
-    if (w > iso_year_weeks(year)) return 1;
-    return w;
-  }
-
-  void write1(int value) {
-    *out_++ = static_cast<char>('0' + to_unsigned(value) % 10);
-  }
-  void write2(int value) {
-    const char* d = digits2(to_unsigned(value) % 100);
-    *out_++ = *d++;
-    *out_++ = *d;
-  }
-  void write2(int value, pad_type pad) {
-    unsigned int v = to_unsigned(value) % 100;
-    if (v >= 10) {
-      const char* d = digits2(v);
-      *out_++ = *d++;
-      *out_++ = *d;
-    } else {
-      out_ = detail::write_padding(out_, pad);
-      *out_++ = static_cast<char>('0' + v);
-    }
-  }
-
-  void write_year_extended(long long year) {
-    // At least 4 characters.
-    int width = 4;
-    if (year < 0) {
-      *out_++ = '-';
-      year = 0 - year;
-      --width;
-    }
-    uint32_or_64_or_128_t<long long> n = to_unsigned(year);
-    const int num_digits = count_digits(n);
-    if (width > num_digits) out_ = std::fill_n(out_, width - num_digits, '0');
-    out_ = format_decimal<Char>(out_, n, num_digits).end;
-  }
-  void write_year(long long year) {
-    if (year >= 0 && year < 10000) {
-      write2(static_cast<int>(year / 100));
-      write2(static_cast<int>(year % 100));
-    } else {
-      write_year_extended(year);
-    }
-  }
-
-  void write_utc_offset(long offset, numeric_system ns) {
-    if (offset < 0) {
-      *out_++ = '-';
-      offset = -offset;
-    } else {
-      *out_++ = '+';
-    }
-    offset /= 60;
-    write2(static_cast<int>(offset / 60));
-    if (ns != numeric_system::standard) *out_++ = ':';
-    write2(static_cast<int>(offset % 60));
-  }
-  template <typename T, FMTQUILL_ENABLE_IF(has_member_data_tm_gmtoff<T>::value)>
-  void format_utc_offset_impl(const T& tm, numeric_system ns) {
-    write_utc_offset(tm.tm_gmtoff, ns);
-  }
-  template <typename T, FMTQUILL_ENABLE_IF(!has_member_data_tm_gmtoff<T>::value)>
-  void format_utc_offset_impl(const T& tm, numeric_system ns) {
-#if defined(_WIN32) && defined(_UCRT)
-#  if FMTQUILL_USE_TZSET
-    tzset_once();
-#  endif
-    long offset = 0;
-    _get_timezone(&offset);
-    if (tm.tm_isdst) {
-      long dstbias = 0;
-      _get_dstbias(&dstbias);
-      offset += dstbias;
-    }
-    write_utc_offset(-offset, ns);
-#else
-    if (ns == numeric_system::standard) return format_localized('z');
-
-    // Extract timezone offset from timezone conversion functions.
-    std::tm gtm = tm;
-    std::time_t gt = std::mktime(&gtm);
-    std::tm ltm = gmtime(gt);
-    std::time_t lt = std::mktime(&ltm);
-    long offset = gt - lt;
-    write_utc_offset(offset, ns);
-#endif
-  }
-
-  template <typename T, FMTQUILL_ENABLE_IF(has_member_data_tm_zone<T>::value)>
-  void format_tz_name_impl(const T& tm) {
-    if (is_classic_)
-      out_ = write_tm_str<Char>(out_, tm.tm_zone, loc_);
-    else
-      format_localized('Z');
-  }
-  template <typename T, FMTQUILL_ENABLE_IF(!has_member_data_tm_zone<T>::value)>
-  void format_tz_name_impl(const T&) {
-    format_localized('Z');
-  }
-
-  void format_localized(char format, char modifier = 0) {
-    out_ = write<Char>(out_, tm_, loc_, format, modifier);
-  }
-
- public:
-  tm_writer(const std::locale& loc, OutputIt out, const std::tm& tm,
-            const Duration* subsecs = nullptr)
-      : loc_(loc),
-        is_classic_(loc_ == get_classic_locale()),
-        out_(out),
-        subsecs_(subsecs),
-        tm_(tm) {}
-
-  auto out() const -> OutputIt { return out_; }
-
-  FMTQUILL_CONSTEXPR void on_text(const Char* begin, const Char* end) {
-    out_ = copy_str<Char>(begin, end, out_);
-  }
-
-  void on_abbr_weekday() {
-    if (is_classic_)
-      out_ = write(out_, tm_wday_short_name(tm_wday()));
-    else
-      format_localized('a');
-  }
-  void on_full_weekday() {
-    if (is_classic_)
-      out_ = write(out_, tm_wday_full_name(tm_wday()));
-    else
-      format_localized('A');
-  }
-  void on_dec0_weekday(numeric_system ns) {
-    if (is_classic_ || ns == numeric_system::standard) return write1(tm_wday());
-    format_localized('w', 'O');
-  }
-  void on_dec1_weekday(numeric_system ns) {
-    if (is_classic_ || ns == numeric_system::standard) {
-      auto wday = tm_wday();
-      write1(wday == 0 ? days_per_week : wday);
-    } else {
-      format_localized('u', 'O');
-    }
-  }
-
-  void on_abbr_month() {
-    if (is_classic_)
-      out_ = write(out_, tm_mon_short_name(tm_mon()));
-    else
-      format_localized('b');
-  }
-  void on_full_month() {
-    if (is_classic_)
-      out_ = write(out_, tm_mon_full_name(tm_mon()));
-    else
-      format_localized('B');
-  }
-
-  void on_datetime(numeric_system ns) {
-    if (is_classic_) {
-      on_abbr_weekday();
-      *out_++ = ' ';
-      on_abbr_month();
-      *out_++ = ' ';
-      on_day_of_month_space(numeric_system::standard);
-      *out_++ = ' ';
-      on_iso_time();
-      *out_++ = ' ';
-      on_year(numeric_system::standard);
-    } else {
-      format_localized('c', ns == numeric_system::standard ? '\0' : 'E');
-    }
-  }
-  void on_loc_date(numeric_system ns) {
-    if (is_classic_)
-      on_us_date();
-    else
-      format_localized('x', ns == numeric_system::standard ? '\0' : 'E');
-  }
-  void on_loc_time(numeric_system ns) {
-    if (is_classic_)
-      on_iso_time();
-    else
-      format_localized('X', ns == numeric_system::standard ? '\0' : 'E');
-  }
-  void on_us_date() {
-    char buf[8];
-    write_digit2_separated(buf, to_unsigned(tm_mon() + 1),
-                           to_unsigned(tm_mday()),
-                           to_unsigned(split_year_lower(tm_year())), '/');
-    out_ = copy_str<Char>(std::begin(buf), std::end(buf), out_);
-  }
-  void on_iso_date() {
-    auto year = tm_year();
-    char buf[10];
-    size_t offset = 0;
-    if (year >= 0 && year < 10000) {
-      copy2(buf, digits2(static_cast<size_t>(year / 100)));
-    } else {
-      offset = 4;
-      write_year_extended(year);
-      year = 0;
-    }
-    write_digit2_separated(buf + 2, static_cast<unsigned>(year % 100),
-                           to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()),
-                           '-');
-    out_ = copy_str<Char>(std::begin(buf) + offset, std::end(buf), out_);
-  }
-
-  void on_utc_offset(numeric_system ns) { format_utc_offset_impl(tm_, ns); }
-  void on_tz_name() { format_tz_name_impl(tm_); }
-
-  void on_year(numeric_system ns) {
-    if (is_classic_ || ns == numeric_system::standard)
-      return write_year(tm_year());
-    format_localized('Y', 'E');
-  }
-  void on_short_year(numeric_system ns) {
-    if (is_classic_ || ns == numeric_system::standard)
-      return write2(split_year_lower(tm_year()));
-    format_localized('y', 'O');
-  }
-  void on_offset_year() {
-    if (is_classic_) return write2(split_year_lower(tm_year()));
-    format_localized('y', 'E');
-  }
-
-  void on_century(numeric_system ns) {
-    if (is_classic_ || ns == numeric_system::standard) {
-      auto year = tm_year();
-      auto upper = year / 100;
-      if (year >= -99 && year < 0) {
-        // Zero upper on negative year.
-        *out_++ = '-';
-        *out_++ = '0';
-      } else if (upper >= 0 && upper < 100) {
-        write2(static_cast<int>(upper));
-      } else {
-        out_ = write<Char>(out_, upper);
-      }
-    } else {
-      format_localized('C', 'E');
-    }
-  }
-
-  void on_dec_month(numeric_system ns) {
-    if (is_classic_ || ns == numeric_system::standard)
-      return write2(tm_mon() + 1);
-    format_localized('m', 'O');
-  }
-
-  void on_dec0_week_of_year(numeric_system ns) {
-    if (is_classic_ || ns == numeric_system::standard)
-      return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week);
-    format_localized('U', 'O');
-  }
-  void on_dec1_week_of_year(numeric_system ns) {
-    if (is_classic_ || ns == numeric_system::standard) {
-      auto wday = tm_wday();
-      write2((tm_yday() + days_per_week -
-              (wday == 0 ? (days_per_week - 1) : (wday - 1))) /
-             days_per_week);
-    } else {
-      format_localized('W', 'O');
-    }
-  }
-  void on_iso_week_of_year(numeric_system ns) {
-    if (is_classic_ || ns == numeric_system::standard)
-      return write2(tm_iso_week_of_year());
-    format_localized('V', 'O');
-  }
-
-  void on_iso_week_based_year() { write_year(tm_iso_week_year()); }
-  void on_iso_week_based_short_year() {
-    write2(split_year_lower(tm_iso_week_year()));
-  }
-
-  void on_day_of_year() {
-    auto yday = tm_yday() + 1;
-    write1(yday / 100);
-    write2(yday % 100);
-  }
-  void on_day_of_month(numeric_system ns) {
-    if (is_classic_ || ns == numeric_system::standard) return write2(tm_mday());
-    format_localized('d', 'O');
-  }
-  void on_day_of_month_space(numeric_system ns) {
-    if (is_classic_ || ns == numeric_system::standard) {
-      auto mday = to_unsigned(tm_mday()) % 100;
-      const char* d2 = digits2(mday);
-      *out_++ = mday < 10 ? ' ' : d2[0];
-      *out_++ = d2[1];
-    } else {
-      format_localized('e', 'O');
-    }
-  }
-
-  void on_24_hour(numeric_system ns, pad_type pad) {
-    if (is_classic_ || ns == numeric_system::standard)
-      return write2(tm_hour(), pad);
-    format_localized('H', 'O');
-  }
-  void on_12_hour(numeric_system ns, pad_type pad) {
-    if (is_classic_ || ns == numeric_system::standard)
-      return write2(tm_hour12(), pad);
-    format_localized('I', 'O');
-  }
-  void on_minute(numeric_system ns, pad_type pad) {
-    if (is_classic_ || ns == numeric_system::standard)
-      return write2(tm_min(), pad);
-    format_localized('M', 'O');
-  }
-
-  void on_second(numeric_system ns, pad_type pad) {
-    if (is_classic_ || ns == numeric_system::standard) {
-      write2(tm_sec(), pad);
-      if (subsecs_) {
-        if (std::is_floating_point<typename Duration::rep>::value) {
-          auto buf = memory_buffer();
-          write_floating_seconds(buf, *subsecs_);
-          if (buf.size() > 1) {
-            // Remove the leading "0", write something like ".123".
-            out_ = std::copy(buf.begin() + 1, buf.end(), out_);
-          }
-        } else {
-          write_fractional_seconds<Char>(out_, *subsecs_);
-        }
-      }
-    } else {
-      // Currently no formatting of subseconds when a locale is set.
-      format_localized('S', 'O');
-    }
-  }
-
-  void on_12_hour_time() {
-    if (is_classic_) {
-      char buf[8];
-      write_digit2_separated(buf, to_unsigned(tm_hour12()),
-                             to_unsigned(tm_min()), to_unsigned(tm_sec()), ':');
-      out_ = copy_str<Char>(std::begin(buf), std::end(buf), out_);
-      *out_++ = ' ';
-      on_am_pm();
-    } else {
-      format_localized('r');
-    }
-  }
-  void on_24_hour_time() {
-    write2(tm_hour());
-    *out_++ = ':';
-    write2(tm_min());
-  }
-  void on_iso_time() {
-    on_24_hour_time();
-    *out_++ = ':';
-    on_second(numeric_system::standard, pad_type::unspecified);
-  }
-
-  void on_am_pm() {
-    if (is_classic_) {
-      *out_++ = tm_hour() < 12 ? 'A' : 'P';
-      *out_++ = 'M';
-    } else {
-      format_localized('p');
-    }
-  }
-
-  // These apply to chrono durations but not tm.
-  void on_duration_value() {}
-  void on_duration_unit() {}
-};
-
-struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> {
-  bool has_precision_integral = false;
-
-  FMTQUILL_NORETURN void unsupported() { FMTQUILL_THROW(format_error("no date")); }
-
-  template <typename Char>
-  FMTQUILL_CONSTEXPR void on_text(const Char*, const Char*) {}
-  FMTQUILL_CONSTEXPR void on_day_of_year() {}
-  FMTQUILL_CONSTEXPR void on_24_hour(numeric_system, pad_type) {}
-  FMTQUILL_CONSTEXPR void on_12_hour(numeric_system, pad_type) {}
-  FMTQUILL_CONSTEXPR void on_minute(numeric_system, pad_type) {}
-  FMTQUILL_CONSTEXPR void on_second(numeric_system, pad_type) {}
-  FMTQUILL_CONSTEXPR void on_12_hour_time() {}
-  FMTQUILL_CONSTEXPR void on_24_hour_time() {}
-  FMTQUILL_CONSTEXPR void on_iso_time() {}
-  FMTQUILL_CONSTEXPR void on_am_pm() {}
-  FMTQUILL_CONSTEXPR void on_duration_value() const {
-    if (has_precision_integral) {
-      FMTQUILL_THROW(format_error("precision not allowed for this argument type"));
-    }
-  }
-  FMTQUILL_CONSTEXPR void on_duration_unit() {}
-};
-
-template <typename T,
-          FMTQUILL_ENABLE_IF(std::is_integral<T>::value&& has_isfinite<T>::value)>
-inline auto isfinite(T) -> bool {
-  return true;
-}
-
-template <typename T, FMTQUILL_ENABLE_IF(std::is_integral<T>::value)>
-inline auto mod(T x, int y) -> T {
-  return x % static_cast<T>(y);
-}
-template <typename T, FMTQUILL_ENABLE_IF(std::is_floating_point<T>::value)>
-inline auto mod(T x, int y) -> T {
-  return std::fmod(x, static_cast<T>(y));
-}
-
-// If T is an integral type, maps T to its unsigned counterpart, otherwise
-// leaves it unchanged (unlike std::make_unsigned).
-template <typename T, bool INTEGRAL = std::is_integral<T>::value>
-struct make_unsigned_or_unchanged {
-  using type = T;
-};
-
-template <typename T> struct make_unsigned_or_unchanged<T, true> {
-  using type = typename std::make_unsigned<T>::type;
-};
-
-template <typename Rep, typename Period,
-          FMTQUILL_ENABLE_IF(std::is_integral<Rep>::value)>
-inline auto get_milliseconds(std::chrono::duration<Rep, Period> d)
-    -> std::chrono::duration<Rep, std::milli> {
-  // this may overflow and/or the result may not fit in the
-  // target type.
-#if FMTQUILL_SAFE_DURATION_CAST
-  using CommonSecondsType =
-      typename std::common_type<decltype(d), std::chrono::seconds>::type;
-  const auto d_as_common = fmt_duration_cast<CommonSecondsType>(d);
-  const auto d_as_whole_seconds =
-      fmt_duration_cast<std::chrono::seconds>(d_as_common);
-  // this conversion should be nonproblematic
-  const auto diff = d_as_common - d_as_whole_seconds;
-  const auto ms =
-      fmt_duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
-  return ms;
-#else
-  auto s = fmt_duration_cast<std::chrono::seconds>(d);
-  return fmt_duration_cast<std::chrono::milliseconds>(d - s);
-#endif
-}
-
-template <typename Char, typename Rep, typename OutputIt,
-          FMTQUILL_ENABLE_IF(std::is_integral<Rep>::value)>
-auto format_duration_value(OutputIt out, Rep val, int) -> OutputIt {
-  return write<Char>(out, val);
-}
-
-template <typename Char, typename Rep, typename OutputIt,
-          FMTQUILL_ENABLE_IF(std::is_floating_point<Rep>::value)>
-auto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt {
-  auto specs = format_specs<Char>();
-  specs.precision = precision;
-  specs.type = precision >= 0 ? presentation_type::fixed_lower
-                              : presentation_type::general_lower;
-  return write<Char>(out, val, specs);
-}
-
-template <typename Char, typename OutputIt>
-auto copy_unit(string_view unit, OutputIt out, Char) -> OutputIt {
-  return std::copy(unit.begin(), unit.end(), out);
-}
-
-template <typename OutputIt>
-auto copy_unit(string_view unit, OutputIt out, wchar_t) -> OutputIt {
-  // This works when wchar_t is UTF-32 because units only contain characters
-  // that have the same representation in UTF-16 and UTF-32.
-  utf8_to_utf16 u(unit);
-  return std::copy(u.c_str(), u.c_str() + u.size(), out);
-}
-
-template <typename Char, typename Period, typename OutputIt>
-auto format_duration_unit(OutputIt out) -> OutputIt {
-  if (const char* unit = get_units<Period>())
-    return copy_unit(string_view(unit), out, Char());
-  *out++ = '[';
-  out = write<Char>(out, Period::num);
-  if (const_check(Period::den != 1)) {
-    *out++ = '/';
-    out = write<Char>(out, Period::den);
-  }
-  *out++ = ']';
-  *out++ = 's';
-  return out;
-}
-
-class get_locale {
- private:
-  union {
-    std::locale locale_;
-  };
-  bool has_locale_ = false;
-
- public:
-  get_locale(bool localized, locale_ref loc) : has_locale_(localized) {
-    if (localized)
-      ::new (&locale_) std::locale(loc.template get<std::locale>());
-  }
-  ~get_locale() {
-    if (has_locale_) locale_.~locale();
-  }
-  operator const std::locale&() const {
-    return has_locale_ ? locale_ : get_classic_locale();
-  }
-};
-
-template <typename FormatContext, typename OutputIt, typename Rep,
-          typename Period>
-struct chrono_formatter {
-  FormatContext& context;
-  OutputIt out;
-  int precision;
-  bool localized = false;
-  // rep is unsigned to avoid overflow.
-  using rep =
-      conditional_t<std::is_integral<Rep>::value && sizeof(Rep) < sizeof(int),
-                    unsigned, typename make_unsigned_or_unchanged<Rep>::type>;
-  rep val;
-  using seconds = std::chrono::duration<rep>;
-  seconds s;
-  using milliseconds = std::chrono::duration<rep, std::milli>;
-  bool negative;
-
-  using char_type = typename FormatContext::char_type;
-  using tm_writer_type = tm_writer<OutputIt, char_type>;
-
-  chrono_formatter(FormatContext& ctx, OutputIt o,
-                   std::chrono::duration<Rep, Period> d)
-      : context(ctx),
-        out(o),
-        val(static_cast<rep>(d.count())),
-        negative(false) {
-    if (d.count() < 0) {
-      val = 0 - val;
-      negative = true;
-    }
-
-    // this may overflow and/or the result may not fit in the
-    // target type.
-    // might need checked conversion (rep!=Rep)
-    s = fmt_duration_cast<seconds>(std::chrono::duration<rep, Period>(val));
-  }
-
-  // returns true if nan or inf, writes to out.
-  auto handle_nan_inf() -> bool {
-    if (isfinite(val)) {
-      return false;
-    }
-    if (isnan(val)) {
-      write_nan();
-      return true;
-    }
-    // must be +-inf
-    if (val > 0) {
-      write_pinf();
-    } else {
-      write_ninf();
-    }
-    return true;
-  }
-
-  auto days() const -> Rep { return static_cast<Rep>(s.count() / 86400); }
-  auto hour() const -> Rep {
-    return static_cast<Rep>(mod((s.count() / 3600), 24));
-  }
-
-  auto hour12() const -> Rep {
-    Rep hour = static_cast<Rep>(mod((s.count() / 3600), 12));
-    return hour <= 0 ? 12 : hour;
-  }
-
-  auto minute() const -> Rep {
-    return static_cast<Rep>(mod((s.count() / 60), 60));
-  }
-  auto second() const -> Rep { return static_cast<Rep>(mod(s.count(), 60)); }
-
-  auto time() const -> std::tm {
-    auto time = std::tm();
-    time.tm_hour = to_nonnegative_int(hour(), 24);
-    time.tm_min = to_nonnegative_int(minute(), 60);
-    time.tm_sec = to_nonnegative_int(second(), 60);
-    return time;
-  }
-
-  void write_sign() {
-    if (negative) {
-      *out++ = '-';
-      negative = false;
-    }
-  }
-
-  void write(Rep value, int width, pad_type pad = pad_type::unspecified) {
-    write_sign();
-    if (isnan(value)) return write_nan();
-    uint32_or_64_or_128_t<int> n =
-        to_unsigned(to_nonnegative_int(value, max_value<int>()));
-    int num_digits = detail::count_digits(n);
-    if (width > num_digits) {
-      out = detail::write_padding(out, pad, width - num_digits);
-    }
-    out = format_decimal<char_type>(out, n, num_digits).end;
-  }
-
-  void write_nan() { std::copy_n("nan", 3, out); }
-  void write_pinf() { std::copy_n("inf", 3, out); }
-  void write_ninf() { std::copy_n("-inf", 4, out); }
-
-  template <typename Callback, typename... Args>
-  void format_tm(const tm& time, Callback cb, Args... args) {
-    if (isnan(val)) return write_nan();
-    get_locale loc(localized, context.locale());
-    auto w = tm_writer_type(loc, out, time);
-    (w.*cb)(args...);
-    out = w.out();
-  }
-
-  void on_text(const char_type* begin, const char_type* end) {
-    std::copy(begin, end, out);
-  }
-
-  // These are not implemented because durations don't have date information.
-  void on_abbr_weekday() {}
-  void on_full_weekday() {}
-  void on_dec0_weekday(numeric_system) {}
-  void on_dec1_weekday(numeric_system) {}
-  void on_abbr_month() {}
-  void on_full_month() {}
-  void on_datetime(numeric_system) {}
-  void on_loc_date(numeric_system) {}
-  void on_loc_time(numeric_system) {}
-  void on_us_date() {}
-  void on_iso_date() {}
-  void on_utc_offset(numeric_system) {}
-  void on_tz_name() {}
-  void on_year(numeric_system) {}
-  void on_short_year(numeric_system) {}
-  void on_offset_year() {}
-  void on_century(numeric_system) {}
-  void on_iso_week_based_year() {}
-  void on_iso_week_based_short_year() {}
-  void on_dec_month(numeric_system) {}
-  void on_dec0_week_of_year(numeric_system) {}
-  void on_dec1_week_of_year(numeric_system) {}
-  void on_iso_week_of_year(numeric_system) {}
-  void on_day_of_month(numeric_system) {}
-  void on_day_of_month_space(numeric_system) {}
-
-  void on_day_of_year() {
-    if (handle_nan_inf()) return;
-    write(days(), 0);
-  }
-
-  void on_24_hour(numeric_system ns, pad_type pad) {
-    if (handle_nan_inf()) return;
-
-    if (ns == numeric_system::standard) return write(hour(), 2, pad);
-    auto time = tm();
-    time.tm_hour = to_nonnegative_int(hour(), 24);
-    format_tm(time, &tm_writer_type::on_24_hour, ns, pad);
-  }
-
-  void on_12_hour(numeric_system ns, pad_type pad) {
-    if (handle_nan_inf()) return;
-
-    if (ns == numeric_system::standard) return write(hour12(), 2, pad);
-    auto time = tm();
-    time.tm_hour = to_nonnegative_int(hour12(), 12);
-    format_tm(time, &tm_writer_type::on_12_hour, ns, pad);
-  }
-
-  void on_minute(numeric_system ns, pad_type pad) {
-    if (handle_nan_inf()) return;
-
-    if (ns == numeric_system::standard) return write(minute(), 2, pad);
-    auto time = tm();
-    time.tm_min = to_nonnegative_int(minute(), 60);
-    format_tm(time, &tm_writer_type::on_minute, ns, pad);
-  }
-
-  void on_second(numeric_system ns, pad_type pad) {
-    if (handle_nan_inf()) return;
-
-    if (ns == numeric_system::standard) {
-      if (std::is_floating_point<rep>::value) {
-        auto buf = memory_buffer();
-        write_floating_seconds(buf, std::chrono::duration<rep, Period>(val),
-                               precision);
-        if (negative) *out++ = '-';
-        if (buf.size() < 2 || buf[1] == '.') {
-          out = detail::write_padding(out, pad);
-        }
-        out = std::copy(buf.begin(), buf.end(), out);
-      } else {
-        write(second(), 2, pad);
-        write_fractional_seconds<char_type>(
-            out, std::chrono::duration<rep, Period>(val), precision);
-      }
-      return;
-    }
-    auto time = tm();
-    time.tm_sec = to_nonnegative_int(second(), 60);
-    format_tm(time, &tm_writer_type::on_second, ns, pad);
-  }
-
-  void on_12_hour_time() {
-    if (handle_nan_inf()) return;
-    format_tm(time(), &tm_writer_type::on_12_hour_time);
-  }
-
-  void on_24_hour_time() {
-    if (handle_nan_inf()) {
-      *out++ = ':';
-      handle_nan_inf();
-      return;
-    }
-
-    write(hour(), 2);
-    *out++ = ':';
-    write(minute(), 2);
-  }
-
-  void on_iso_time() {
-    on_24_hour_time();
-    *out++ = ':';
-    if (handle_nan_inf()) return;
-    on_second(numeric_system::standard, pad_type::unspecified);
-  }
-
-  void on_am_pm() {
-    if (handle_nan_inf()) return;
-    format_tm(time(), &tm_writer_type::on_am_pm);
-  }
-
-  void on_duration_value() {
-    if (handle_nan_inf()) return;
-    write_sign();
-    out = format_duration_value<char_type>(out, val, precision);
-  }
-
-  void on_duration_unit() {
-    out = format_duration_unit<char_type, Period>(out);
-  }
-};
-
-}  // namespace detail
-
-#if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907
-using weekday = std::chrono::weekday;
-#else
-// A fallback version of weekday.
-class weekday {
- private:
-  unsigned char value;
-
- public:
-  weekday() = default;
-  explicit constexpr weekday(unsigned wd) noexcept
-      : value(static_cast<unsigned char>(wd != 7 ? wd : 0)) {}
-  constexpr auto c_encoding() const noexcept -> unsigned { return value; }
-};
-
-class year_month_day {};
-#endif
-
-// A rudimentary weekday formatter.
-template <typename Char> struct formatter<weekday, Char> {
- private:
-  bool localized = false;
-
- public:
-  FMTQUILL_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-      -> decltype(ctx.begin()) {
-    auto begin = ctx.begin(), end = ctx.end();
-    if (begin != end && *begin == 'L') {
-      ++begin;
-      localized = true;
-    }
-    return begin;
-  }
-
-  template <typename FormatContext>
-  auto format(weekday wd, FormatContext& ctx) const -> decltype(ctx.out()) {
-    auto time = std::tm();
-    time.tm_wday = static_cast<int>(wd.c_encoding());
-    detail::get_locale loc(localized, ctx.locale());
-    auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time);
-    w.on_abbr_weekday();
-    return w.out();
-  }
-};
-
-template <typename Rep, typename Period, typename Char>
-struct formatter<std::chrono::duration<Rep, Period>, Char> {
- private:
-  format_specs<Char> specs_;
-  detail::arg_ref<Char> width_ref_;
-  detail::arg_ref<Char> precision_ref_;
-  bool localized_ = false;
-  basic_string_view<Char> format_str_;
-
- public:
-  FMTQUILL_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-      -> decltype(ctx.begin()) {
-    auto it = ctx.begin(), end = ctx.end();
-    if (it == end || *it == '}') return it;
-
-    it = detail::parse_align(it, end, specs_);
-    if (it == end) return it;
-
-    it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
-    if (it == end) return it;
-
-    auto checker = detail::chrono_format_checker();
-    if (*it == '.') {
-      checker.has_precision_integral = !std::is_floating_point<Rep>::value;
-      it = detail::parse_precision(it, end, specs_.precision, precision_ref_,
-                                   ctx);
-    }
-    if (it != end && *it == 'L') {
-      localized_ = true;
-      ++it;
-    }
-    end = detail::parse_chrono_format(it, end, checker);
-    format_str_ = {it, detail::to_unsigned(end - it)};
-    return end;
-  }
-
-  template <typename FormatContext>
-  auto format(std::chrono::duration<Rep, Period> d, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto specs = specs_;
-    auto precision = specs.precision;
-    specs.precision = -1;
-    auto begin = format_str_.begin(), end = format_str_.end();
-    // As a possible future optimization, we could avoid extra copying if width
-    // is not specified.
-    auto buf = basic_memory_buffer<Char>();
-    auto out = std::back_inserter(buf);
-    detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
-                                                       ctx);
-    detail::handle_dynamic_spec<detail::precision_checker>(precision,
-                                                           precision_ref_, ctx);
-    if (begin == end || *begin == '}') {
-      out = detail::format_duration_value<Char>(out, d.count(), precision);
-      detail::format_duration_unit<Char, Period>(out);
-    } else {
-      using chrono_formatter =
-          detail::chrono_formatter<FormatContext, decltype(out), Rep, Period>;
-      auto f = chrono_formatter(ctx, out, d);
-      f.precision = precision;
-      f.localized = localized_;
-      detail::parse_chrono_format(begin, end, f);
-    }
-    return detail::write(
-        ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs);
-  }
-};
-
-template <typename Char, typename Duration>
-struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
-                 Char> : formatter<std::tm, Char> {
-  FMTQUILL_CONSTEXPR formatter() {
-    this->format_str_ = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{};
-  }
-
-  template <typename FormatContext>
-  auto format(std::chrono::time_point<std::chrono::system_clock, Duration> val,
-              FormatContext& ctx) const -> decltype(ctx.out()) {
-    using period = typename Duration::period;
-    if (detail::const_check(
-            period::num != 1 || period::den != 1 ||
-            std::is_floating_point<typename Duration::rep>::value)) {
-      const auto epoch = val.time_since_epoch();
-      auto subsecs = detail::fmt_duration_cast<Duration>(
-          epoch - detail::fmt_duration_cast<std::chrono::seconds>(epoch));
-
-      if (subsecs.count() < 0) {
-        auto second =
-            detail::fmt_duration_cast<Duration>(std::chrono::seconds(1));
-        if (epoch.count() < ((Duration::min)() + second).count())
-          FMTQUILL_THROW(format_error("duration is too small"));
-        subsecs += second;
-        val -= second;
-      }
-
-      return formatter<std::tm, Char>::do_format(gmtime(val), ctx, &subsecs);
-    }
-
-    return formatter<std::tm, Char>::format(gmtime(val), ctx);
-  }
-};
-
-#if FMTQUILL_USE_LOCAL_TIME
-template <typename Char, typename Duration>
-struct formatter<std::chrono::local_time<Duration>, Char>
-    : formatter<std::tm, Char> {
-  FMTQUILL_CONSTEXPR formatter() {
-    this->format_str_ = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{};
-  }
-
-  template <typename FormatContext>
-  auto format(std::chrono::local_time<Duration> val, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    using period = typename Duration::period;
-    if (period::num != 1 || period::den != 1 ||
-        std::is_floating_point<typename Duration::rep>::value) {
-      const auto epoch = val.time_since_epoch();
-      const auto subsecs = detail::fmt_duration_cast<Duration>(
-          epoch - detail::fmt_duration_cast<std::chrono::seconds>(epoch));
-
-      return formatter<std::tm, Char>::do_format(localtime(val), ctx, &subsecs);
-    }
-
-    return formatter<std::tm, Char>::format(localtime(val), ctx);
-  }
-};
-#endif
-
-#if FMTQUILL_USE_UTC_TIME
-template <typename Char, typename Duration>
-struct formatter<std::chrono::time_point<std::chrono::utc_clock, Duration>,
-                 Char>
-    : formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
-                Char> {
-  template <typename FormatContext>
-  auto format(std::chrono::time_point<std::chrono::utc_clock, Duration> val,
-              FormatContext& ctx) const -> decltype(ctx.out()) {
-    return formatter<
-        std::chrono::time_point<std::chrono::system_clock, Duration>,
-        Char>::format(std::chrono::utc_clock::to_sys(val), ctx);
-  }
-};
-#endif
-
-template <typename Char> struct formatter<std::tm, Char> {
- private:
-  format_specs<Char> specs_;
-  detail::arg_ref<Char> width_ref_;
-
- protected:
-  basic_string_view<Char> format_str_;
-
-  template <typename FormatContext, typename Duration>
-  auto do_format(const std::tm& tm, FormatContext& ctx,
-                 const Duration* subsecs) const -> decltype(ctx.out()) {
-    auto specs = specs_;
-    auto buf = basic_memory_buffer<Char>();
-    auto out = std::back_inserter(buf);
-    detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
-                                                       ctx);
-
-    auto loc_ref = ctx.locale();
-    detail::get_locale loc(static_cast<bool>(loc_ref), loc_ref);
-    auto w =
-        detail::tm_writer<decltype(out), Char, Duration>(loc, out, tm, subsecs);
-    detail::parse_chrono_format(format_str_.begin(), format_str_.end(), w);
-    return detail::write(
-        ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs);
-  }
-
- public:
-  FMTQUILL_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-      -> decltype(ctx.begin()) {
-    auto it = ctx.begin(), end = ctx.end();
-    if (it == end || *it == '}') return it;
-
-    it = detail::parse_align(it, end, specs_);
-    if (it == end) return it;
-
-    it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
-    if (it == end) return it;
-
-    end = detail::parse_chrono_format(it, end, detail::tm_format_checker());
-    // Replace the default format_str only if the new spec is not empty.
-    if (end != it) format_str_ = {it, detail::to_unsigned(end - it)};
-    return end;
-  }
-
-  template <typename FormatContext>
-  auto format(const std::tm& tm, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return do_format<FormatContext, std::chrono::seconds>(tm, ctx, nullptr);
-  }
-};
-
-FMTQUILL_END_EXPORT
-FMTQUILL_END_NAMESPACE
-
-#endif  // FMTQUILL_CHRONO_H_
diff --git a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/color.h b/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/color.h
deleted file mode 100644
index 56a12d8..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/color.h
+++ /dev/null
@@ -1,643 +0,0 @@
-// Formatting library for C++ - color support
-//
-// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMTQUILL_COLOR_H_
-#define FMTQUILL_COLOR_H_
-
-#include "format.h"
-
-FMTQUILL_BEGIN_NAMESPACE
-FMTQUILL_BEGIN_EXPORT
-
-enum class color : uint32_t {
-  alice_blue = 0xF0F8FF,               // rgb(240,248,255)
-  antique_white = 0xFAEBD7,            // rgb(250,235,215)
-  aqua = 0x00FFFF,                     // rgb(0,255,255)
-  aquamarine = 0x7FFFD4,               // rgb(127,255,212)
-  azure = 0xF0FFFF,                    // rgb(240,255,255)
-  beige = 0xF5F5DC,                    // rgb(245,245,220)
-  bisque = 0xFFE4C4,                   // rgb(255,228,196)
-  black = 0x000000,                    // rgb(0,0,0)
-  blanched_almond = 0xFFEBCD,          // rgb(255,235,205)
-  blue = 0x0000FF,                     // rgb(0,0,255)
-  blue_violet = 0x8A2BE2,              // rgb(138,43,226)
-  brown = 0xA52A2A,                    // rgb(165,42,42)
-  burly_wood = 0xDEB887,               // rgb(222,184,135)
-  cadet_blue = 0x5F9EA0,               // rgb(95,158,160)
-  chartreuse = 0x7FFF00,               // rgb(127,255,0)
-  chocolate = 0xD2691E,                // rgb(210,105,30)
-  coral = 0xFF7F50,                    // rgb(255,127,80)
-  cornflower_blue = 0x6495ED,          // rgb(100,149,237)
-  cornsilk = 0xFFF8DC,                 // rgb(255,248,220)
-  crimson = 0xDC143C,                  // rgb(220,20,60)
-  cyan = 0x00FFFF,                     // rgb(0,255,255)
-  dark_blue = 0x00008B,                // rgb(0,0,139)
-  dark_cyan = 0x008B8B,                // rgb(0,139,139)
-  dark_golden_rod = 0xB8860B,          // rgb(184,134,11)
-  dark_gray = 0xA9A9A9,                // rgb(169,169,169)
-  dark_green = 0x006400,               // rgb(0,100,0)
-  dark_khaki = 0xBDB76B,               // rgb(189,183,107)
-  dark_magenta = 0x8B008B,             // rgb(139,0,139)
-  dark_olive_green = 0x556B2F,         // rgb(85,107,47)
-  dark_orange = 0xFF8C00,              // rgb(255,140,0)
-  dark_orchid = 0x9932CC,              // rgb(153,50,204)
-  dark_red = 0x8B0000,                 // rgb(139,0,0)
-  dark_salmon = 0xE9967A,              // rgb(233,150,122)
-  dark_sea_green = 0x8FBC8F,           // rgb(143,188,143)
-  dark_slate_blue = 0x483D8B,          // rgb(72,61,139)
-  dark_slate_gray = 0x2F4F4F,          // rgb(47,79,79)
-  dark_turquoise = 0x00CED1,           // rgb(0,206,209)
-  dark_violet = 0x9400D3,              // rgb(148,0,211)
-  deep_pink = 0xFF1493,                // rgb(255,20,147)
-  deep_sky_blue = 0x00BFFF,            // rgb(0,191,255)
-  dim_gray = 0x696969,                 // rgb(105,105,105)
-  dodger_blue = 0x1E90FF,              // rgb(30,144,255)
-  fire_brick = 0xB22222,               // rgb(178,34,34)
-  floral_white = 0xFFFAF0,             // rgb(255,250,240)
-  forest_green = 0x228B22,             // rgb(34,139,34)
-  fuchsia = 0xFF00FF,                  // rgb(255,0,255)
-  gainsboro = 0xDCDCDC,                // rgb(220,220,220)
-  ghost_white = 0xF8F8FF,              // rgb(248,248,255)
-  gold = 0xFFD700,                     // rgb(255,215,0)
-  golden_rod = 0xDAA520,               // rgb(218,165,32)
-  gray = 0x808080,                     // rgb(128,128,128)
-  green = 0x008000,                    // rgb(0,128,0)
-  green_yellow = 0xADFF2F,             // rgb(173,255,47)
-  honey_dew = 0xF0FFF0,                // rgb(240,255,240)
-  hot_pink = 0xFF69B4,                 // rgb(255,105,180)
-  indian_red = 0xCD5C5C,               // rgb(205,92,92)
-  indigo = 0x4B0082,                   // rgb(75,0,130)
-  ivory = 0xFFFFF0,                    // rgb(255,255,240)
-  khaki = 0xF0E68C,                    // rgb(240,230,140)
-  lavender = 0xE6E6FA,                 // rgb(230,230,250)
-  lavender_blush = 0xFFF0F5,           // rgb(255,240,245)
-  lawn_green = 0x7CFC00,               // rgb(124,252,0)
-  lemon_chiffon = 0xFFFACD,            // rgb(255,250,205)
-  light_blue = 0xADD8E6,               // rgb(173,216,230)
-  light_coral = 0xF08080,              // rgb(240,128,128)
-  light_cyan = 0xE0FFFF,               // rgb(224,255,255)
-  light_golden_rod_yellow = 0xFAFAD2,  // rgb(250,250,210)
-  light_gray = 0xD3D3D3,               // rgb(211,211,211)
-  light_green = 0x90EE90,              // rgb(144,238,144)
-  light_pink = 0xFFB6C1,               // rgb(255,182,193)
-  light_salmon = 0xFFA07A,             // rgb(255,160,122)
-  light_sea_green = 0x20B2AA,          // rgb(32,178,170)
-  light_sky_blue = 0x87CEFA,           // rgb(135,206,250)
-  light_slate_gray = 0x778899,         // rgb(119,136,153)
-  light_steel_blue = 0xB0C4DE,         // rgb(176,196,222)
-  light_yellow = 0xFFFFE0,             // rgb(255,255,224)
-  lime = 0x00FF00,                     // rgb(0,255,0)
-  lime_green = 0x32CD32,               // rgb(50,205,50)
-  linen = 0xFAF0E6,                    // rgb(250,240,230)
-  magenta = 0xFF00FF,                  // rgb(255,0,255)
-  maroon = 0x800000,                   // rgb(128,0,0)
-  medium_aquamarine = 0x66CDAA,        // rgb(102,205,170)
-  medium_blue = 0x0000CD,              // rgb(0,0,205)
-  medium_orchid = 0xBA55D3,            // rgb(186,85,211)
-  medium_purple = 0x9370DB,            // rgb(147,112,219)
-  medium_sea_green = 0x3CB371,         // rgb(60,179,113)
-  medium_slate_blue = 0x7B68EE,        // rgb(123,104,238)
-  medium_spring_green = 0x00FA9A,      // rgb(0,250,154)
-  medium_turquoise = 0x48D1CC,         // rgb(72,209,204)
-  medium_violet_red = 0xC71585,        // rgb(199,21,133)
-  midnight_blue = 0x191970,            // rgb(25,25,112)
-  mint_cream = 0xF5FFFA,               // rgb(245,255,250)
-  misty_rose = 0xFFE4E1,               // rgb(255,228,225)
-  moccasin = 0xFFE4B5,                 // rgb(255,228,181)
-  navajo_white = 0xFFDEAD,             // rgb(255,222,173)
-  navy = 0x000080,                     // rgb(0,0,128)
-  old_lace = 0xFDF5E6,                 // rgb(253,245,230)
-  olive = 0x808000,                    // rgb(128,128,0)
-  olive_drab = 0x6B8E23,               // rgb(107,142,35)
-  orange = 0xFFA500,                   // rgb(255,165,0)
-  orange_red = 0xFF4500,               // rgb(255,69,0)
-  orchid = 0xDA70D6,                   // rgb(218,112,214)
-  pale_golden_rod = 0xEEE8AA,          // rgb(238,232,170)
-  pale_green = 0x98FB98,               // rgb(152,251,152)
-  pale_turquoise = 0xAFEEEE,           // rgb(175,238,238)
-  pale_violet_red = 0xDB7093,          // rgb(219,112,147)
-  papaya_whip = 0xFFEFD5,              // rgb(255,239,213)
-  peach_puff = 0xFFDAB9,               // rgb(255,218,185)
-  peru = 0xCD853F,                     // rgb(205,133,63)
-  pink = 0xFFC0CB,                     // rgb(255,192,203)
-  plum = 0xDDA0DD,                     // rgb(221,160,221)
-  powder_blue = 0xB0E0E6,              // rgb(176,224,230)
-  purple = 0x800080,                   // rgb(128,0,128)
-  rebecca_purple = 0x663399,           // rgb(102,51,153)
-  red = 0xFF0000,                      // rgb(255,0,0)
-  rosy_brown = 0xBC8F8F,               // rgb(188,143,143)
-  royal_blue = 0x4169E1,               // rgb(65,105,225)
-  saddle_brown = 0x8B4513,             // rgb(139,69,19)
-  salmon = 0xFA8072,                   // rgb(250,128,114)
-  sandy_brown = 0xF4A460,              // rgb(244,164,96)
-  sea_green = 0x2E8B57,                // rgb(46,139,87)
-  sea_shell = 0xFFF5EE,                // rgb(255,245,238)
-  sienna = 0xA0522D,                   // rgb(160,82,45)
-  silver = 0xC0C0C0,                   // rgb(192,192,192)
-  sky_blue = 0x87CEEB,                 // rgb(135,206,235)
-  slate_blue = 0x6A5ACD,               // rgb(106,90,205)
-  slate_gray = 0x708090,               // rgb(112,128,144)
-  snow = 0xFFFAFA,                     // rgb(255,250,250)
-  spring_green = 0x00FF7F,             // rgb(0,255,127)
-  steel_blue = 0x4682B4,               // rgb(70,130,180)
-  tan = 0xD2B48C,                      // rgb(210,180,140)
-  teal = 0x008080,                     // rgb(0,128,128)
-  thistle = 0xD8BFD8,                  // rgb(216,191,216)
-  tomato = 0xFF6347,                   // rgb(255,99,71)
-  turquoise = 0x40E0D0,                // rgb(64,224,208)
-  violet = 0xEE82EE,                   // rgb(238,130,238)
-  wheat = 0xF5DEB3,                    // rgb(245,222,179)
-  white = 0xFFFFFF,                    // rgb(255,255,255)
-  white_smoke = 0xF5F5F5,              // rgb(245,245,245)
-  yellow = 0xFFFF00,                   // rgb(255,255,0)
-  yellow_green = 0x9ACD32              // rgb(154,205,50)
-};                                     // enum class color
-
-enum class terminal_color : uint8_t {
-  black = 30,
-  red,
-  green,
-  yellow,
-  blue,
-  magenta,
-  cyan,
-  white,
-  bright_black = 90,
-  bright_red,
-  bright_green,
-  bright_yellow,
-  bright_blue,
-  bright_magenta,
-  bright_cyan,
-  bright_white
-};
-
-enum class emphasis : uint8_t {
-  bold = 1,
-  faint = 1 << 1,
-  italic = 1 << 2,
-  underline = 1 << 3,
-  blink = 1 << 4,
-  reverse = 1 << 5,
-  conceal = 1 << 6,
-  strikethrough = 1 << 7,
-};
-
-// rgb is a struct for red, green and blue colors.
-// Using the name "rgb" makes some editors show the color in a tooltip.
-struct rgb {
-  FMTQUILL_CONSTEXPR rgb() : r(0), g(0), b(0) {}
-  FMTQUILL_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
-  FMTQUILL_CONSTEXPR rgb(uint32_t hex)
-      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
-  FMTQUILL_CONSTEXPR rgb(color hex)
-      : r((uint32_t(hex) >> 16) & 0xFF),
-        g((uint32_t(hex) >> 8) & 0xFF),
-        b(uint32_t(hex) & 0xFF) {}
-  uint8_t r;
-  uint8_t g;
-  uint8_t b;
-};
-
-namespace detail {
-
-// color is a struct of either a rgb color or a terminal color.
-struct color_type {
-  FMTQUILL_CONSTEXPR color_type() noexcept : is_rgb(), value{} {}
-  FMTQUILL_CONSTEXPR color_type(color rgb_color) noexcept : is_rgb(true), value{} {
-    value.rgb_color = static_cast<uint32_t>(rgb_color);
-  }
-  FMTQUILL_CONSTEXPR color_type(rgb rgb_color) noexcept : is_rgb(true), value{} {
-    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
-                      (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
-  }
-  FMTQUILL_CONSTEXPR color_type(terminal_color term_color) noexcept
-      : is_rgb(), value{} {
-    value.term_color = static_cast<uint8_t>(term_color);
-  }
-  bool is_rgb;
-  union color_union {
-    uint8_t term_color;
-    uint32_t rgb_color;
-  } value;
-};
-}  // namespace detail
-
-/** A text style consisting of foreground and background colors and emphasis. */
-class text_style {
- public:
-  FMTQUILL_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
-      : set_foreground_color(), set_background_color(), ems(em) {}
-
-  FMTQUILL_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& {
-    if (!set_foreground_color) {
-      set_foreground_color = rhs.set_foreground_color;
-      foreground_color = rhs.foreground_color;
-    } else if (rhs.set_foreground_color) {
-      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
-        FMTQUILL_THROW(format_error("can't OR a terminal color"));
-      foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
-    }
-
-    if (!set_background_color) {
-      set_background_color = rhs.set_background_color;
-      background_color = rhs.background_color;
-    } else if (rhs.set_background_color) {
-      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
-        FMTQUILL_THROW(format_error("can't OR a terminal color"));
-      background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
-    }
-
-    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
-                                static_cast<uint8_t>(rhs.ems));
-    return *this;
-  }
-
-  friend FMTQUILL_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs)
-      -> text_style {
-    return lhs |= rhs;
-  }
-
-  FMTQUILL_CONSTEXPR auto has_foreground() const noexcept -> bool {
-    return set_foreground_color;
-  }
-  FMTQUILL_CONSTEXPR auto has_background() const noexcept -> bool {
-    return set_background_color;
-  }
-  FMTQUILL_CONSTEXPR auto has_emphasis() const noexcept -> bool {
-    return static_cast<uint8_t>(ems) != 0;
-  }
-  FMTQUILL_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {
-    FMTQUILL_ASSERT(has_foreground(), "no foreground specified for this style");
-    return foreground_color;
-  }
-  FMTQUILL_CONSTEXPR auto get_background() const noexcept -> detail::color_type {
-    FMTQUILL_ASSERT(has_background(), "no background specified for this style");
-    return background_color;
-  }
-  FMTQUILL_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {
-    FMTQUILL_ASSERT(has_emphasis(), "no emphasis specified for this style");
-    return ems;
-  }
-
- private:
-  FMTQUILL_CONSTEXPR text_style(bool is_foreground,
-                           detail::color_type text_color) noexcept
-      : set_foreground_color(), set_background_color(), ems() {
-    if (is_foreground) {
-      foreground_color = text_color;
-      set_foreground_color = true;
-    } else {
-      background_color = text_color;
-      set_background_color = true;
-    }
-  }
-
-  friend FMTQUILL_CONSTEXPR auto fg(detail::color_type foreground) noexcept
-      -> text_style;
-
-  friend FMTQUILL_CONSTEXPR auto bg(detail::color_type background) noexcept
-      -> text_style;
-
-  detail::color_type foreground_color;
-  detail::color_type background_color;
-  bool set_foreground_color;
-  bool set_background_color;
-  emphasis ems;
-};
-
-/** Creates a text style from the foreground (text) color. */
-FMTQUILL_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
-    -> text_style {
-  return text_style(true, foreground);
-}
-
-/** Creates a text style from the background color. */
-FMTQUILL_CONSTEXPR inline auto bg(detail::color_type background) noexcept
-    -> text_style {
-  return text_style(false, background);
-}
-
-FMTQUILL_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
-    -> text_style {
-  return text_style(lhs) | rhs;
-}
-
-namespace detail {
-
-template <typename Char> struct ansi_color_escape {
-  FMTQUILL_CONSTEXPR ansi_color_escape(detail::color_type text_color,
-                                  const char* esc) noexcept {
-    // If we have a terminal color, we need to output another escape code
-    // sequence.
-    if (!text_color.is_rgb) {
-      bool is_background = esc == string_view("\x1b[48;2;");
-      uint32_t value = text_color.value.term_color;
-      // Background ASCII codes are the same as the foreground ones but with
-      // 10 more.
-      if (is_background) value += 10u;
-
-      size_t index = 0;
-      buffer[index++] = static_cast<Char>('\x1b');
-      buffer[index++] = static_cast<Char>('[');
-
-      if (value >= 100u) {
-        buffer[index++] = static_cast<Char>('1');
-        value %= 100u;
-      }
-      buffer[index++] = static_cast<Char>('0' + value / 10u);
-      buffer[index++] = static_cast<Char>('0' + value % 10u);
-
-      buffer[index++] = static_cast<Char>('m');
-      buffer[index++] = static_cast<Char>('\0');
-      return;
-    }
-
-    for (int i = 0; i < 7; i++) {
-      buffer[i] = static_cast<Char>(esc[i]);
-    }
-    rgb color(text_color.value.rgb_color);
-    to_esc(color.r, buffer + 7, ';');
-    to_esc(color.g, buffer + 11, ';');
-    to_esc(color.b, buffer + 15, 'm');
-    buffer[19] = static_cast<Char>(0);
-  }
-  FMTQUILL_CONSTEXPR ansi_color_escape(emphasis em) noexcept {
-    uint8_t em_codes[num_emphases] = {};
-    if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1;
-    if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2;
-    if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3;
-    if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4;
-    if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5;
-    if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7;
-    if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8;
-    if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9;
-
-    size_t index = 0;
-    for (size_t i = 0; i < num_emphases; ++i) {
-      if (!em_codes[i]) continue;
-      buffer[index++] = static_cast<Char>('\x1b');
-      buffer[index++] = static_cast<Char>('[');
-      buffer[index++] = static_cast<Char>('0' + em_codes[i]);
-      buffer[index++] = static_cast<Char>('m');
-    }
-    buffer[index++] = static_cast<Char>(0);
-  }
-  FMTQUILL_CONSTEXPR operator const Char*() const noexcept { return buffer; }
-
-  FMTQUILL_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
-  FMTQUILL_CONSTEXPR_CHAR_TRAITS auto end() const noexcept -> const Char* {
-    return buffer + std::char_traits<Char>::length(buffer);
-  }
-
- private:
-  static constexpr size_t num_emphases = 8;
-  Char buffer[7u + 3u * num_emphases + 1u];
-
-  static FMTQUILL_CONSTEXPR void to_esc(uint8_t c, Char* out,
-                                   char delimiter) noexcept {
-    out[0] = static_cast<Char>('0' + c / 100);
-    out[1] = static_cast<Char>('0' + c / 10 % 10);
-    out[2] = static_cast<Char>('0' + c % 10);
-    out[3] = static_cast<Char>(delimiter);
-  }
-  static FMTQUILL_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept
-      -> bool {
-    return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
-  }
-};
-
-template <typename Char>
-FMTQUILL_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept
-    -> ansi_color_escape<Char> {
-  return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
-}
-
-template <typename Char>
-FMTQUILL_CONSTEXPR auto make_background_color(detail::color_type background) noexcept
-    -> ansi_color_escape<Char> {
-  return ansi_color_escape<Char>(background, "\x1b[48;2;");
-}
-
-template <typename Char>
-FMTQUILL_CONSTEXPR auto make_emphasis(emphasis em) noexcept
-    -> ansi_color_escape<Char> {
-  return ansi_color_escape<Char>(em);
-}
-
-template <typename Char> inline void reset_color(buffer<Char>& buffer) {
-  auto reset_color = string_view("\x1b[0m");
-  buffer.append(reset_color.begin(), reset_color.end());
-}
-
-template <typename T> struct styled_arg : detail::view {
-  const T& value;
-  text_style style;
-  styled_arg(const T& v, text_style s) : value(v), style(s) {}
-};
-
-template <typename Char>
-void vformat_to(buffer<Char>& buf, const text_style& ts,
-                basic_string_view<Char> format_str,
-                basic_format_args<buffer_context<type_identity_t<Char>>> args) {
-  bool has_style = false;
-  if (ts.has_emphasis()) {
-    has_style = true;
-    auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
-    buf.append(emphasis.begin(), emphasis.end());
-  }
-  if (ts.has_foreground()) {
-    has_style = true;
-    auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
-    buf.append(foreground.begin(), foreground.end());
-  }
-  if (ts.has_background()) {
-    has_style = true;
-    auto background = detail::make_background_color<Char>(ts.get_background());
-    buf.append(background.begin(), background.end());
-  }
-  detail::vformat_to(buf, format_str, args, {});
-  if (has_style) detail::reset_color<Char>(buf);
-}
-
-}  // namespace detail
-
-inline void vprint(std::FILE* f, const text_style& ts, string_view fmt,
-                   format_args args) {
-  // Legacy wide streams are not supported.
-  auto buf = memory_buffer();
-  detail::vformat_to(buf, ts, fmt, args);
-  if (detail::is_utf8()) {
-    detail::print(f, string_view(buf.begin(), buf.size()));
-    return;
-  }
-  buf.push_back('\0');
-  int result = std::fputs(buf.data(), f);
-  if (result < 0)
-    FMTQUILL_THROW(system_error(errno, FMTQUILL_STRING("cannot write to file")));
-}
-
-/**
-  \rst
-  Formats a string and prints it to the specified file stream using ANSI
-  escape sequences to specify text formatting.
-
-  **Example**::
-
-    fmtquill::print(fmtquill::emphasis::bold | fg(fmtquill::color::red),
-               "Elapsed time: {0:.2f} seconds", 1.23);
-  \endrst
- */
-template <typename S, typename... Args,
-          FMTQUILL_ENABLE_IF(detail::is_string<S>::value)>
-void print(std::FILE* f, const text_style& ts, const S& format_str,
-           const Args&... args) {
-  vprint(f, ts, format_str,
-         fmtquill::make_format_args<buffer_context<char_t<S>>>(args...));
-}
-
-/**
-  \rst
-  Formats a string and prints it to stdout using ANSI escape sequences to
-  specify text formatting.
-
-  **Example**::
-
-    fmtquill::print(fmtquill::emphasis::bold | fg(fmtquill::color::red),
-               "Elapsed time: {0:.2f} seconds", 1.23);
-  \endrst
- */
-template <typename S, typename... Args,
-          FMTQUILL_ENABLE_IF(detail::is_string<S>::value)>
-void print(const text_style& ts, const S& format_str, const Args&... args) {
-  return print(stdout, ts, format_str, args...);
-}
-
-template <typename S, typename Char = char_t<S>>
-inline auto vformat(
-    const text_style& ts, const S& format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args)
-    -> std::basic_string<Char> {
-  basic_memory_buffer<Char> buf;
-  detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
-  return fmtquill::to_string(buf);
-}
-
-/**
-  \rst
-  Formats arguments and returns the result as a string using ANSI
-  escape sequences to specify text formatting.
-
-  **Example**::
-
-    #include <fmt/color.h>
-    std::string message = fmtquill::format(fmtquill::emphasis::bold | fg(fmtquill::color::red),
-                                      "The answer is {}", 42);
-  \endrst
-*/
-template <typename S, typename... Args, typename Char = char_t<S>>
-inline auto format(const text_style& ts, const S& format_str,
-                   const Args&... args) -> std::basic_string<Char> {
-  return fmtquill::vformat(ts, detail::to_string_view(format_str),
-                      fmtquill::make_format_args<buffer_context<Char>>(args...));
-}
-
-/**
-  Formats a string with the given text_style and writes the output to ``out``.
- */
-template <typename OutputIt, typename Char,
-          FMTQUILL_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
-auto vformat_to(OutputIt out, const text_style& ts,
-                basic_string_view<Char> format_str,
-                basic_format_args<buffer_context<type_identity_t<Char>>> args)
-    -> OutputIt {
-  auto&& buf = detail::get_buffer<Char>(out);
-  detail::vformat_to(buf, ts, format_str, args);
-  return detail::get_iterator(buf, out);
-}
-
-/**
-  \rst
-  Formats arguments with the given text_style, writes the result to the output
-  iterator ``out`` and returns the iterator past the end of the output range.
-
-  **Example**::
-
-    std::vector<char> out;
-    fmtquill::format_to(std::back_inserter(out),
-                   fmtquill::emphasis::bold | fg(fmtquill::color::red), "{}", 42);
-  \endrst
-*/
-template <
-    typename OutputIt, typename S, typename... Args,
-    bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value &&
-                  detail::is_string<S>::value>
-inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
-                      Args&&... args) ->
-    typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, ts, detail::to_string_view(format_str),
-                    fmtquill::make_format_args<buffer_context<char_t<S>>>(args...));
-}
-
-template <typename T, typename Char>
-struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
-  template <typename FormatContext>
-  auto format(const detail::styled_arg<T>& arg, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    const auto& ts = arg.style;
-    const auto& value = arg.value;
-    auto out = ctx.out();
-
-    bool has_style = false;
-    if (ts.has_emphasis()) {
-      has_style = true;
-      auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
-      out = std::copy(emphasis.begin(), emphasis.end(), out);
-    }
-    if (ts.has_foreground()) {
-      has_style = true;
-      auto foreground =
-          detail::make_foreground_color<Char>(ts.get_foreground());
-      out = std::copy(foreground.begin(), foreground.end(), out);
-    }
-    if (ts.has_background()) {
-      has_style = true;
-      auto background =
-          detail::make_background_color<Char>(ts.get_background());
-      out = std::copy(background.begin(), background.end(), out);
-    }
-    out = formatter<T, Char>::format(value, ctx);
-    if (has_style) {
-      auto reset_color = string_view("\x1b[0m");
-      out = std::copy(reset_color.begin(), reset_color.end(), out);
-    }
-    return out;
-  }
-};
-
-/**
-  \rst
-  Returns an argument that will be formatted using ANSI escape sequences,
-  to be used in a formatting function.
-
-  **Example**::
-
-    fmtquill::print("Elapsed time: {0:.2f} seconds",
-               fmtquill::styled(1.23, fmtquill::fg(fmtquill::color::green) |
-                                 fmtquill::bg(fmtquill::color::blue)));
-  \endrst
- */
-template <typename T>
-FMTQUILL_CONSTEXPR auto styled(const T& value, text_style ts)
-    -> detail::styled_arg<remove_cvref_t<T>> {
-  return detail::styled_arg<remove_cvref_t<T>>{value, ts};
-}
-
-FMTQUILL_END_EXPORT
-FMTQUILL_END_NAMESPACE
-
-#endif  // FMTQUILL_COLOR_H_
diff --git a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/compile.h b/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/compile.h
deleted file mode 100644
index aa43b9c..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/compile.h
+++ /dev/null
@@ -1,535 +0,0 @@
-// Formatting library for C++ - experimental format string compilation
-//
-// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMTQUILL_COMPILE_H_
-#define FMTQUILL_COMPILE_H_
-
-#include "format.h"
-
-FMTQUILL_BEGIN_NAMESPACE
-namespace detail {
-
-template <typename Char, typename InputIt>
-FMTQUILL_CONSTEXPR inline auto copy_str(InputIt begin, InputIt end,
-                                   counting_iterator it) -> counting_iterator {
-  return it + (end - begin);
-}
-
-// A compile-time string which is compiled into fast formatting code.
-class compiled_string {};
-
-template <typename S>
-struct is_compiled_string : std::is_base_of<compiled_string, S> {};
-
-/**
-  \rst
-  Converts a string literal *s* into a format string that will be parsed at
-  compile time and converted into efficient formatting code. Requires C++17
-  ``constexpr if`` compiler support.
-
-  **Example**::
-
-    // Converts 42 into std::string using the most efficient method and no
-    // runtime format string processing.
-    std::string s = fmtquill::format(FMTQUILL_COMPILE("{}"), 42);
-  \endrst
- */
-#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-#  define FMTQUILL_COMPILE(s) \
-    FMTQUILL_STRING_IMPL(s, fmtquill::detail::compiled_string, explicit)
-#else
-#  define FMTQUILL_COMPILE(s) FMTQUILL_STRING(s)
-#endif
-
-#if FMTQUILL_USE_NONTYPE_TEMPLATE_ARGS
-template <typename Char, size_t N,
-          fmtquill::detail_exported::fixed_string<Char, N> Str>
-struct udl_compiled_string : compiled_string {
-  using char_type = Char;
-  explicit constexpr operator basic_string_view<char_type>() const {
-    return {Str.data, N - 1};
-  }
-};
-#endif
-
-template <typename T, typename... Tail>
-auto first(const T& value, const Tail&...) -> const T& {
-  return value;
-}
-
-#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-template <typename... Args> struct type_list {};
-
-// Returns a reference to the argument at index N from [first, rest...].
-template <int N, typename T, typename... Args>
-constexpr const auto& get([[maybe_unused]] const T& first,
-                          [[maybe_unused]] const Args&... rest) {
-  static_assert(N < 1 + sizeof...(Args), "index is out of bounds");
-  if constexpr (N == 0)
-    return first;
-  else
-    return detail::get<N - 1>(rest...);
-}
-
-template <typename Char, typename... Args>
-constexpr int get_arg_index_by_name(basic_string_view<Char> name,
-                                    type_list<Args...>) {
-  return get_arg_index_by_name<Args...>(name);
-}
-
-template <int N, typename> struct get_type_impl;
-
-template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>> {
-  using type =
-      remove_cvref_t<decltype(detail::get<N>(std::declval<Args>()...))>;
-};
-
-template <int N, typename T>
-using get_type = typename get_type_impl<N, T>::type;
-
-template <typename T> struct is_compiled_format : std::false_type {};
-
-template <typename Char> struct text {
-  basic_string_view<Char> data;
-  using char_type = Char;
-
-  template <typename OutputIt, typename... Args>
-  constexpr OutputIt format(OutputIt out, const Args&...) const {
-    return write<Char>(out, data);
-  }
-};
-
-template <typename Char>
-struct is_compiled_format<text<Char>> : std::true_type {};
-
-template <typename Char>
-constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos,
-                               size_t size) {
-  return {{&s[pos], size}};
-}
-
-template <typename Char> struct code_unit {
-  Char value;
-  using char_type = Char;
-
-  template <typename OutputIt, typename... Args>
-  constexpr OutputIt format(OutputIt out, const Args&...) const {
-    *out++ = value;
-    return out;
-  }
-};
-
-// This ensures that the argument type is convertible to `const T&`.
-template <typename T, int N, typename... Args>
-constexpr const T& get_arg_checked(const Args&... args) {
-  const auto& arg = detail::get<N>(args...);
-  if constexpr (detail::is_named_arg<remove_cvref_t<decltype(arg)>>()) {
-    return arg.value;
-  } else {
-    return arg;
-  }
-}
-
-template <typename Char>
-struct is_compiled_format<code_unit<Char>> : std::true_type {};
-
-// A replacement field that refers to argument N.
-template <typename Char, typename T, int N> struct field {
-  using char_type = Char;
-
-  template <typename OutputIt, typename... Args>
-  constexpr OutputIt format(OutputIt out, const Args&... args) const {
-    const T& arg = get_arg_checked<T, N>(args...);
-    if constexpr (std::is_convertible_v<T, basic_string_view<Char>>) {
-      auto s = basic_string_view<Char>(arg);
-      return copy_str<Char>(s.begin(), s.end(), out);
-    }
-    return write<Char>(out, arg);
-  }
-};
-
-template <typename Char, typename T, int N>
-struct is_compiled_format<field<Char, T, N>> : std::true_type {};
-
-// A replacement field that refers to argument with name.
-template <typename Char> struct runtime_named_field {
-  using char_type = Char;
-  basic_string_view<Char> name;
-
-  template <typename OutputIt, typename T>
-  constexpr static bool try_format_argument(
-      OutputIt& out,
-      // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9
-      [[maybe_unused]] basic_string_view<Char> arg_name, const T& arg) {
-    if constexpr (is_named_arg<typename std::remove_cv<T>::type>::value) {
-      if (arg_name == arg.name) {
-        out = write<Char>(out, arg.value);
-        return true;
-      }
-    }
-    return false;
-  }
-
-  template <typename OutputIt, typename... Args>
-  constexpr OutputIt format(OutputIt out, const Args&... args) const {
-    bool found = (try_format_argument(out, name, args) || ...);
-    if (!found) {
-      FMTQUILL_THROW(format_error("argument with specified name is not found"));
-    }
-    return out;
-  }
-};
-
-template <typename Char>
-struct is_compiled_format<runtime_named_field<Char>> : std::true_type {};
-
-// A replacement field that refers to argument N and has format specifiers.
-template <typename Char, typename T, int N> struct spec_field {
-  using char_type = Char;
-  formatter<T, Char> fmt;
-
-  template <typename OutputIt, typename... Args>
-  constexpr FMTQUILL_INLINE OutputIt format(OutputIt out,
-                                       const Args&... args) const {
-    const auto& vargs =
-        fmtquill::make_format_args<basic_format_context<OutputIt, Char>>(args...);
-    basic_format_context<OutputIt, Char> ctx(out, vargs);
-    return fmt.format(get_arg_checked<T, N>(args...), ctx);
-  }
-};
-
-template <typename Char, typename T, int N>
-struct is_compiled_format<spec_field<Char, T, N>> : std::true_type {};
-
-template <typename L, typename R> struct concat {
-  L lhs;
-  R rhs;
-  using char_type = typename L::char_type;
-
-  template <typename OutputIt, typename... Args>
-  constexpr OutputIt format(OutputIt out, const Args&... args) const {
-    out = lhs.format(out, args...);
-    return rhs.format(out, args...);
-  }
-};
-
-template <typename L, typename R>
-struct is_compiled_format<concat<L, R>> : std::true_type {};
-
-template <typename L, typename R>
-constexpr concat<L, R> make_concat(L lhs, R rhs) {
-  return {lhs, rhs};
-}
-
-struct unknown_format {};
-
-template <typename Char>
-constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
-  for (size_t size = str.size(); pos != size; ++pos) {
-    if (str[pos] == '{' || str[pos] == '}') break;
-  }
-  return pos;
-}
-
-template <typename Args, size_t POS, int ID, typename S>
-constexpr auto compile_format_string(S format_str);
-
-template <typename Args, size_t POS, int ID, typename T, typename S>
-constexpr auto parse_tail(T head, S format_str) {
-  if constexpr (POS !=
-                basic_string_view<typename S::char_type>(format_str).size()) {
-    constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
-    if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
-                               unknown_format>())
-      return tail;
-    else
-      return make_concat(head, tail);
-  } else {
-    return head;
-  }
-}
-
-template <typename T, typename Char> struct parse_specs_result {
-  formatter<T, Char> fmt;
-  size_t end;
-  int next_arg_id;
-};
-
-enum { manual_indexing_id = -1 };
-
-template <typename T, typename Char>
-constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
-                                                  size_t pos, int next_arg_id) {
-  str.remove_prefix(pos);
-  auto ctx =
-      compile_parse_context<Char>(str, max_value<int>(), nullptr, next_arg_id);
-  auto f = formatter<T, Char>();
-  auto end = f.parse(ctx);
-  return {f, pos + fmtquill::detail::to_unsigned(end - str.data()),
-          next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
-}
-
-template <typename Char> struct arg_id_handler {
-  arg_ref<Char> arg_id;
-
-  constexpr int on_auto() {
-    FMTQUILL_ASSERT(false, "handler cannot be used with automatic indexing");
-    return 0;
-  }
-  constexpr int on_index(int id) {
-    arg_id = arg_ref<Char>(id);
-    return 0;
-  }
-  constexpr int on_name(basic_string_view<Char> id) {
-    arg_id = arg_ref<Char>(id);
-    return 0;
-  }
-};
-
-template <typename Char> struct parse_arg_id_result {
-  arg_ref<Char> arg_id;
-  const Char* arg_id_end;
-};
-
-template <int ID, typename Char>
-constexpr auto parse_arg_id(const Char* begin, const Char* end) {
-  auto handler = arg_id_handler<Char>{arg_ref<Char>{}};
-  auto arg_id_end = parse_arg_id(begin, end, handler);
-  return parse_arg_id_result<Char>{handler.arg_id, arg_id_end};
-}
-
-template <typename T, typename Enable = void> struct field_type {
-  using type = remove_cvref_t<T>;
-};
-
-template <typename T>
-struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> {
-  using type = remove_cvref_t<decltype(T::value)>;
-};
-
-template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID,
-          typename S>
-constexpr auto parse_replacement_field_then_tail(S format_str) {
-  using char_type = typename S::char_type;
-  constexpr auto str = basic_string_view<char_type>(format_str);
-  constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
-  if constexpr (c == '}') {
-    return parse_tail<Args, END_POS + 1, NEXT_ID>(
-        field<char_type, typename field_type<T>::type, ARG_INDEX>(),
-        format_str);
-  } else if constexpr (c != ':') {
-    FMTQUILL_THROW(format_error("expected ':'"));
-  } else {
-    constexpr auto result = parse_specs<typename field_type<T>::type>(
-        str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);
-    if constexpr (result.end >= str.size() || str[result.end] != '}') {
-      FMTQUILL_THROW(format_error("expected '}'"));
-      return 0;
-    } else {
-      return parse_tail<Args, result.end + 1, result.next_arg_id>(
-          spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
-              result.fmt},
-          format_str);
-    }
-  }
-}
-
-// Compiles a non-empty format string and returns the compiled representation
-// or unknown_format() on unrecognized input.
-template <typename Args, size_t POS, int ID, typename S>
-constexpr auto compile_format_string(S format_str) {
-  using char_type = typename S::char_type;
-  constexpr auto str = basic_string_view<char_type>(format_str);
-  if constexpr (str[POS] == '{') {
-    if constexpr (POS + 1 == str.size())
-      FMTQUILL_THROW(format_error("unmatched '{' in format string"));
-    if constexpr (str[POS + 1] == '{') {
-      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
-    } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {
-      static_assert(ID != manual_indexing_id,
-                    "cannot switch from manual to automatic argument indexing");
-      constexpr auto next_id =
-          ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
-      return parse_replacement_field_then_tail<get_type<ID, Args>, Args,
-                                               POS + 1, ID, next_id>(
-          format_str);
-    } else {
-      constexpr auto arg_id_result =
-          parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
-      constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data();
-      constexpr char_type c =
-          arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
-      static_assert(c == '}' || c == ':', "missing '}' in format string");
-      if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) {
-        static_assert(
-            ID == manual_indexing_id || ID == 0,
-            "cannot switch from automatic to manual argument indexing");
-        constexpr auto arg_index = arg_id_result.arg_id.val.index;
-        return parse_replacement_field_then_tail<get_type<arg_index, Args>,
-                                                 Args, arg_id_end_pos,
-                                                 arg_index, manual_indexing_id>(
-            format_str);
-      } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
-        constexpr auto arg_index =
-            get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
-        if constexpr (arg_index >= 0) {
-          constexpr auto next_id =
-              ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
-          return parse_replacement_field_then_tail<
-              decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
-              arg_index, next_id>(format_str);
-        } else if constexpr (c == '}') {
-          return parse_tail<Args, arg_id_end_pos + 1, ID>(
-              runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
-              format_str);
-        } else if constexpr (c == ':') {
-          return unknown_format();  // no type info for specs parsing
-        }
-      }
-    }
-  } else if constexpr (str[POS] == '}') {
-    if constexpr (POS + 1 == str.size())
-      FMTQUILL_THROW(format_error("unmatched '}' in format string"));
-    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
-  } else {
-    constexpr auto end = parse_text(str, POS + 1);
-    if constexpr (end - POS > 1) {
-      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS),
-                                       format_str);
-    } else {
-      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]},
-                                       format_str);
-    }
-  }
-}
-
-template <typename... Args, typename S,
-          FMTQUILL_ENABLE_IF(detail::is_compiled_string<S>::value)>
-constexpr auto compile(S format_str) {
-  constexpr auto str = basic_string_view<typename S::char_type>(format_str);
-  if constexpr (str.size() == 0) {
-    return detail::make_text(str, 0, 0);
-  } else {
-    constexpr auto result =
-        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(
-            format_str);
-    return result;
-  }
-}
-#endif  // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-}  // namespace detail
-
-FMTQUILL_BEGIN_EXPORT
-
-#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-
-template <typename CompiledFormat, typename... Args,
-          typename Char = typename CompiledFormat::char_type,
-          FMTQUILL_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
-FMTQUILL_INLINE std::basic_string<Char> format(const CompiledFormat& cf,
-                                          const Args&... args) {
-  auto s = std::basic_string<Char>();
-  cf.format(std::back_inserter(s), args...);
-  return s;
-}
-
-template <typename OutputIt, typename CompiledFormat, typename... Args,
-          FMTQUILL_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
-constexpr FMTQUILL_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf,
-                                        const Args&... args) {
-  return cf.format(out, args...);
-}
-
-template <typename S, typename... Args,
-          FMTQUILL_ENABLE_IF(detail::is_compiled_string<S>::value)>
-FMTQUILL_INLINE std::basic_string<typename S::char_type> format(const S&,
-                                                           Args&&... args) {
-  if constexpr (std::is_same<typename S::char_type, char>::value) {
-    constexpr auto str = basic_string_view<typename S::char_type>(S());
-    if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') {
-      const auto& first = detail::first(args...);
-      if constexpr (detail::is_named_arg<
-                        remove_cvref_t<decltype(first)>>::value) {
-        return fmtquill::to_string(first.value);
-      } else {
-        return fmtquill::to_string(first);
-      }
-    }
-  }
-  constexpr auto compiled = detail::compile<Args...>(S());
-  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
-                             detail::unknown_format>()) {
-    return fmtquill::format(
-        static_cast<basic_string_view<typename S::char_type>>(S()),
-        std::forward<Args>(args)...);
-  } else {
-    return fmtquill::format(compiled, std::forward<Args>(args)...);
-  }
-}
-
-template <typename OutputIt, typename S, typename... Args,
-          FMTQUILL_ENABLE_IF(detail::is_compiled_string<S>::value)>
-FMTQUILL_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
-  constexpr auto compiled = detail::compile<Args...>(S());
-  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
-                             detail::unknown_format>()) {
-    return fmtquill::format_to(
-        out, static_cast<basic_string_view<typename S::char_type>>(S()),
-        std::forward<Args>(args)...);
-  } else {
-    return fmtquill::format_to(out, compiled, std::forward<Args>(args)...);
-  }
-}
-#endif
-
-template <typename OutputIt, typename S, typename... Args,
-          FMTQUILL_ENABLE_IF(detail::is_compiled_string<S>::value)>
-auto format_to_n(OutputIt out, size_t n, const S& format_str, Args&&... args)
-    -> format_to_n_result<OutputIt> {
-  using traits = detail::fixed_buffer_traits;
-  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
-  fmtquill::format_to(std::back_inserter(buf), format_str,
-                 std::forward<Args>(args)...);
-  return {buf.out(), buf.count()};
-}
-
-template <typename S, typename... Args,
-          FMTQUILL_ENABLE_IF(detail::is_compiled_string<S>::value)>
-FMTQUILL_CONSTEXPR20 auto formatted_size(const S& format_str, const Args&... args)
-    -> size_t {
-  return fmtquill::format_to(detail::counting_iterator(), format_str, args...)
-      .count();
-}
-
-template <typename S, typename... Args,
-          FMTQUILL_ENABLE_IF(detail::is_compiled_string<S>::value)>
-void print(std::FILE* f, const S& format_str, const Args&... args) {
-  memory_buffer buffer;
-  fmtquill::format_to(std::back_inserter(buffer), format_str, args...);
-  detail::print(f, {buffer.data(), buffer.size()});
-}
-
-template <typename S, typename... Args,
-          FMTQUILL_ENABLE_IF(detail::is_compiled_string<S>::value)>
-void print(const S& format_str, const Args&... args) {
-  print(stdout, format_str, args...);
-}
-
-#if FMTQUILL_USE_NONTYPE_TEMPLATE_ARGS
-inline namespace literals {
-template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
-  using char_t = remove_cvref_t<decltype(Str.data[0])>;
-  return detail::udl_compiled_string<char_t, sizeof(Str.data) / sizeof(char_t),
-                                     Str>();
-}
-}  // namespace literals
-#endif
-
-FMTQUILL_END_EXPORT
-FMTQUILL_END_NAMESPACE
-
-#endif  // FMTQUILL_COMPILE_H_
diff --git a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/core.h b/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/core.h
deleted file mode 100644
index 453ad08..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/core.h
+++ /dev/null
@@ -1,2970 +0,0 @@
-// Formatting library for C++ - the core API for char/UTF-8
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMTQUILL_CORE_H_
-#define FMTQUILL_CORE_H_
-
-#if !defined(FMTQUILL_HEADER_ONLY)
-  #define FMTQUILL_HEADER_ONLY
-#endif
-
-#include <cstddef>  // std::byte
-#include <cstdio>   // std::FILE
-#include <cstring>  // std::strlen
-#include <iterator>
-#include <limits>
-#include <memory>  // std::addressof
-#include <string>
-#include <type_traits>
-
-// The fmt library version in the form major * 10000 + minor * 100 + patch.
-#define FMTQUILL_VERSION 100201
-
-#if defined(__clang__) && !defined(__ibmxl__)
-#  define FMTQUILL_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
-#else
-#  define FMTQUILL_CLANG_VERSION 0
-#endif
-
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && \
-    !defined(__NVCOMPILER)
-#  define FMTQUILL_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#else
-#  define FMTQUILL_GCC_VERSION 0
-#endif
-
-#ifndef FMTQUILL_GCC_PRAGMA
-// Workaround _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884.
-#  if FMTQUILL_GCC_VERSION >= 504
-#    define FMTQUILL_GCC_PRAGMA(arg) _Pragma(arg)
-#  else
-#    define FMTQUILL_GCC_PRAGMA(arg)
-#  endif
-#endif
-
-#ifdef __ICL
-#  define FMTQUILL_ICC_VERSION __ICL
-#elif defined(__INTEL_COMPILER)
-#  define FMTQUILL_ICC_VERSION __INTEL_COMPILER
-#else
-#  define FMTQUILL_ICC_VERSION 0
-#endif
-
-#ifdef _MSC_VER
-#  define FMTQUILL_MSC_VERSION _MSC_VER
-#  define FMTQUILL_MSC_WARNING(...) __pragma(warning(__VA_ARGS__))
-#else
-#  define FMTQUILL_MSC_VERSION 0
-#  define FMTQUILL_MSC_WARNING(...)
-#endif
-
-#ifdef _MSVC_LANG
-#  define FMTQUILL_CPLUSPLUS _MSVC_LANG
-#else
-#  define FMTQUILL_CPLUSPLUS __cplusplus
-#endif
-
-#ifdef __has_feature
-#  define FMTQUILL_HAS_FEATURE(x) __has_feature(x)
-#else
-#  define FMTQUILL_HAS_FEATURE(x) 0
-#endif
-
-#if defined(__has_include) || FMTQUILL_ICC_VERSION >= 1600 || FMTQUILL_MSC_VERSION > 1900
-#  define FMTQUILL_HAS_INCLUDE(x) __has_include(x)
-#else
-#  define FMTQUILL_HAS_INCLUDE(x) 0
-#endif
-
-#ifdef __has_cpp_attribute
-#  define FMTQUILL_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-#  define FMTQUILL_HAS_CPP_ATTRIBUTE(x) 0
-#endif
-
-#define FMTQUILL_HAS_CPP14_ATTRIBUTE(attribute) \
-  (FMTQUILL_CPLUSPLUS >= 201402L && FMTQUILL_HAS_CPP_ATTRIBUTE(attribute))
-
-#define FMTQUILL_HAS_CPP17_ATTRIBUTE(attribute) \
-  (FMTQUILL_CPLUSPLUS >= 201703L && FMTQUILL_HAS_CPP_ATTRIBUTE(attribute))
-
-// Check if relaxed C++14 constexpr is supported.
-// GCC doesn't allow throw in constexpr until version 6 (bug 67371).
-#ifndef FMTQUILL_USE_CONSTEXPR
-#  if (FMTQUILL_HAS_FEATURE(cxx_relaxed_constexpr) || FMTQUILL_MSC_VERSION >= 1912 || \
-       (FMTQUILL_GCC_VERSION >= 600 && FMTQUILL_CPLUSPLUS >= 201402L)) &&             \
-      !FMTQUILL_ICC_VERSION && (!defined(__NVCC__) || FMTQUILL_CPLUSPLUS >= 202002L)
-#    define FMTQUILL_USE_CONSTEXPR 1
-#  else
-#    define FMTQUILL_USE_CONSTEXPR 0
-#  endif
-#endif
-#if FMTQUILL_USE_CONSTEXPR
-#  define FMTQUILL_CONSTEXPR constexpr
-#else
-#  define FMTQUILL_CONSTEXPR
-#endif
-
-#if (FMTQUILL_CPLUSPLUS >= 202002L ||                                \
-     (FMTQUILL_CPLUSPLUS >= 201709L && FMTQUILL_GCC_VERSION >= 1002)) &&  \
-    ((!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 10) &&  \
-     (!defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 10000) && \
-     (!FMTQUILL_MSC_VERSION || FMTQUILL_MSC_VERSION >= 1928)) &&          \
-    defined(__cpp_lib_is_constant_evaluated)
-#  define FMTQUILL_CONSTEXPR20 constexpr
-#else
-#  define FMTQUILL_CONSTEXPR20
-#endif
-
-// Check if constexpr std::char_traits<>::{compare,length} are supported.
-#if defined(__GLIBCXX__)
-#  if FMTQUILL_CPLUSPLUS >= 201703L && defined(_GLIBCXX_RELEASE) && \
-      _GLIBCXX_RELEASE >= 7  // GCC 7+ libstdc++ has _GLIBCXX_RELEASE.
-#    define FMTQUILL_CONSTEXPR_CHAR_TRAITS constexpr
-#  endif
-#elif defined(_LIBCPP_VERSION) && FMTQUILL_CPLUSPLUS >= 201703L && \
-    _LIBCPP_VERSION >= 4000
-#  define FMTQUILL_CONSTEXPR_CHAR_TRAITS constexpr
-#elif FMTQUILL_MSC_VERSION >= 1914 && FMTQUILL_CPLUSPLUS >= 201703L
-#  define FMTQUILL_CONSTEXPR_CHAR_TRAITS constexpr
-#endif
-#ifndef FMTQUILL_CONSTEXPR_CHAR_TRAITS
-#  define FMTQUILL_CONSTEXPR_CHAR_TRAITS
-#endif
-
-// Check if exceptions are disabled.
-#ifndef FMTQUILL_EXCEPTIONS
-#  if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
-      (FMTQUILL_MSC_VERSION && !_HAS_EXCEPTIONS)
-#    define FMTQUILL_EXCEPTIONS 0
-#  else
-#    define FMTQUILL_EXCEPTIONS 1
-#  endif
-#endif
-
-// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings.
-#if FMTQUILL_EXCEPTIONS && FMTQUILL_HAS_CPP_ATTRIBUTE(noreturn) && !FMTQUILL_MSC_VERSION && \
-    !defined(__NVCC__)
-#  define FMTQUILL_NORETURN [[noreturn]]
-#else
-#  define FMTQUILL_NORETURN
-#endif
-
-#ifndef FMTQUILL_NODISCARD
-#  if FMTQUILL_HAS_CPP17_ATTRIBUTE(nodiscard)
-#    define FMTQUILL_NODISCARD [[nodiscard]]
-#  else
-#    define FMTQUILL_NODISCARD
-#  endif
-#endif
-
-#ifndef FMTQUILL_INLINE
-#  if FMTQUILL_GCC_VERSION || FMTQUILL_CLANG_VERSION
-#    define FMTQUILL_INLINE inline __attribute__((always_inline))
-#  else
-#    define FMTQUILL_INLINE inline
-#  endif
-#endif
-
-#ifdef _MSC_VER
-#  define FMTQUILL_UNCHECKED_ITERATOR(It) \
-    using _Unchecked_type = It  // Mark iterator as checked.
-#else
-#  define FMTQUILL_UNCHECKED_ITERATOR(It) using unchecked_type = It
-#endif
-
-#ifndef FMTQUILL_BEGIN_NAMESPACE
-#  define FMTQUILL_BEGIN_NAMESPACE \
-    namespace fmtquill {           \
-    inline namespace v10 {
-#  define FMTQUILL_END_NAMESPACE \
-    }                       \
-    }
-#endif
-
-#ifndef FMTQUILL_EXPORT
-#  define FMTQUILL_EXPORT
-#  define FMTQUILL_BEGIN_EXPORT
-#  define FMTQUILL_END_EXPORT
-#endif
-
-#if FMTQUILL_GCC_VERSION || FMTQUILL_CLANG_VERSION
-#  define FMTQUILL_VISIBILITY(value) __attribute__((visibility(value)))
-#else
-#  define FMTQUILL_VISIBILITY(value)
-#endif
-
-#if !defined(FMTQUILL_HEADER_ONLY) && defined(_WIN32)
-#  if defined(FMTQUILL_LIB_EXPORT)
-#    define FMTQUILL_API __declspec(dllexport)
-#  elif defined(FMTQUILL_SHARED)
-#    define FMTQUILL_API __declspec(dllimport)
-#  endif
-#elif defined(FMTQUILL_LIB_EXPORT) || defined(FMTQUILL_SHARED)
-#  define FMTQUILL_API FMTQUILL_VISIBILITY("default")
-#endif
-#ifndef FMTQUILL_API
-#  define FMTQUILL_API
-#endif
-
-// libc++ supports string_view in pre-c++17.
-#if FMTQUILL_HAS_INCLUDE(<string_view>) && \
-    (FMTQUILL_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION))
-#  include <string_view>
-#  define FMTQUILL_USE_STRING_VIEW
-#elif FMTQUILL_HAS_INCLUDE("experimental/string_view") && FMTQUILL_CPLUSPLUS >= 201402L
-#  include <experimental/string_view>
-#  define FMTQUILL_USE_EXPERIMENTAL_STRING_VIEW
-#endif
-
-#ifndef FMTQUILL_UNICODE
-#  define FMTQUILL_UNICODE !FMTQUILL_MSC_VERSION
-#endif
-
-#ifndef FMTQUILL_CONSTEVAL
-#  if ((FMTQUILL_GCC_VERSION >= 1000 || FMTQUILL_CLANG_VERSION >= 1101) && \
-       (!defined(__apple_build_version__) ||                     \
-        __apple_build_version__ >= 14000029L) &&                 \
-       FMTQUILL_CPLUSPLUS >= 202002L) ||                              \
-      (defined(__cpp_consteval) &&                               \
-       (!FMTQUILL_MSC_VERSION || FMTQUILL_MSC_VERSION >= 1929))
-// consteval is broken in MSVC before VS2019 version 16.10 and Apple clang
-// before 14.
-#    define FMTQUILL_CONSTEVAL consteval
-#    define FMTQUILL_HAS_CONSTEVAL
-#  else
-#    define FMTQUILL_CONSTEVAL
-#  endif
-#endif
-
-#ifndef FMTQUILL_USE_NONTYPE_TEMPLATE_ARGS
-#  if defined(__cpp_nontype_template_args) &&                  \
-      ((FMTQUILL_GCC_VERSION >= 903 && FMTQUILL_CPLUSPLUS >= 201709L) || \
-       __cpp_nontype_template_args >= 201911L) &&              \
-      !defined(__NVCOMPILER) && !defined(__LCC__)
-#    define FMTQUILL_USE_NONTYPE_TEMPLATE_ARGS 1
-#  else
-#    define FMTQUILL_USE_NONTYPE_TEMPLATE_ARGS 0
-#  endif
-#endif
-
-// GCC < 5 requires this-> in decltype
-#ifndef FMTQUILL_DECLTYPE_THIS
-#  if FMTQUILL_GCC_VERSION && FMTQUILL_GCC_VERSION < 500
-#    define FMTQUILL_DECLTYPE_THIS this->
-#  else
-#    define FMTQUILL_DECLTYPE_THIS
-#  endif
-#endif
-
-// Enable minimal optimizations for more compact code in debug mode.
-FMTQUILL_GCC_PRAGMA("GCC push_options")
-#if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER) && !defined(__LCC__) && \
-    !defined(__CUDACC__)
-FMTQUILL_GCC_PRAGMA("GCC optimize(\"Og\")")
-#endif
-
-FMTQUILL_BEGIN_NAMESPACE
-
-// Implementations of enable_if_t and other metafunctions for older systems.
-template <bool B, typename T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-template <bool B, typename T, typename F>
-using conditional_t = typename std::conditional<B, T, F>::type;
-template <bool B> using bool_constant = std::integral_constant<bool, B>;
-template <typename T>
-using remove_reference_t = typename std::remove_reference<T>::type;
-template <typename T>
-using remove_const_t = typename std::remove_const<T>::type;
-template <typename T>
-using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
-template <typename T> struct type_identity {
-  using type = T;
-};
-template <typename T> using type_identity_t = typename type_identity<T>::type;
-template <typename T>
-using underlying_t = typename std::underlying_type<T>::type;
-
-// Checks whether T is a container with contiguous storage.
-template <typename T> struct is_contiguous : std::false_type {};
-template <typename Char>
-struct is_contiguous<std::basic_string<Char>> : std::true_type {};
-
-struct monostate {
-  constexpr monostate() {}
-};
-
-// An enable_if helper to be used in template parameters which results in much
-// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
-// to workaround a bug in MSVC 2019 (see #1140 and #1186).
-#ifdef FMTQUILL_DOC
-#  define FMTQUILL_ENABLE_IF(...)
-#else
-#  define FMTQUILL_ENABLE_IF(...) fmtquill::enable_if_t<(__VA_ARGS__), int> = 0
-#endif
-
-// This is defined in core.h instead of format.h to avoid injecting in std.
-// It is a template to avoid undesirable implicit conversions to std::byte.
-#ifdef __cpp_lib_byte
-template <typename T, FMTQUILL_ENABLE_IF(std::is_same<T, std::byte>::value)>
-inline auto format_as(T b) -> unsigned char {
-  return static_cast<unsigned char>(b);
-}
-#endif
-
-namespace detail {
-// Suppresses "unused variable" warnings with the method described in
-// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/.
-// (void)var does not work on many Intel compilers.
-template <typename... T> FMTQUILL_CONSTEXPR void ignore_unused(const T&...) {}
-
-constexpr FMTQUILL_INLINE auto is_constant_evaluated(
-    bool default_value = false) noexcept -> bool {
-// Workaround for incompatibility between libstdc++ consteval-based
-// std::is_constant_evaluated() implementation and clang-14.
-// https://github.com/fmtlib/fmt/issues/3247
-#if FMTQUILL_CPLUSPLUS >= 202002L && defined(_GLIBCXX_RELEASE) && \
-    _GLIBCXX_RELEASE >= 12 &&                                \
-    (FMTQUILL_CLANG_VERSION >= 1400 && FMTQUILL_CLANG_VERSION < 1500)
-  ignore_unused(default_value);
-  return __builtin_is_constant_evaluated();
-#elif defined(__cpp_lib_is_constant_evaluated)
-  ignore_unused(default_value);
-  return std::is_constant_evaluated();
-#else
-  return default_value;
-#endif
-}
-
-// Suppresses "conditional expression is constant" warnings.
-template <typename T> constexpr FMTQUILL_INLINE auto const_check(T value) -> T {
-  return value;
-}
-
-FMTQUILL_NORETURN FMTQUILL_API void assert_fail(const char* file, int line,
-                                      const char* message);
-
-#ifndef FMTQUILL_ASSERT
-#  ifdef NDEBUG
-// FMTQUILL_ASSERT is not empty to avoid -Wempty-body.
-#    define FMTQUILL_ASSERT(condition, message) \
-      fmtquill::detail::ignore_unused((condition), (message))
-#  else
-#    define FMTQUILL_ASSERT(condition, message)                                    \
-      ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
-           ? (void)0                                                          \
-           : fmtquill::detail::assert_fail(__FILE__, __LINE__, (message)))
-#  endif
-#endif
-
-#if defined(FMTQUILL_USE_STRING_VIEW)
-template <typename Char> using std_string_view = std::basic_string_view<Char>;
-#elif defined(FMTQUILL_USE_EXPERIMENTAL_STRING_VIEW)
-template <typename Char>
-using std_string_view = std::experimental::basic_string_view<Char>;
-#else
-template <typename T> struct std_string_view {};
-#endif
-
-#ifdef FMTQUILL_USE_INT128
-// Do nothing.
-#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \
-    !(FMTQUILL_CLANG_VERSION && FMTQUILL_MSC_VERSION)
-#  define FMTQUILL_USE_INT128 1
-using int128_opt = __int128_t;  // An optional native 128-bit integer.
-using uint128_opt = __uint128_t;
-template <typename T> inline auto convert_for_visit(T value) -> T {
-  return value;
-}
-#else
-#  define FMTQUILL_USE_INT128 0
-#endif
-#if !FMTQUILL_USE_INT128
-enum class int128_opt {};
-enum class uint128_opt {};
-// Reduce template instantiations.
-template <typename T> auto convert_for_visit(T) -> monostate { return {}; }
-#endif
-
-// Casts a nonnegative integer to unsigned.
-template <typename Int>
-FMTQUILL_CONSTEXPR auto to_unsigned(Int value) ->
-    typename std::make_unsigned<Int>::type {
-  FMTQUILL_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
-  return static_cast<typename std::make_unsigned<Int>::type>(value);
-}
-
-FMTQUILL_CONSTEXPR inline auto is_utf8() -> bool {
-  FMTQUILL_MSC_WARNING(suppress : 4566) constexpr unsigned char section[] = "\u00A7";
-
-  // Avoid buggy sign extensions in MSVC's constant evaluation mode (#2297).
-  using uchar = unsigned char;
-  return FMTQUILL_UNICODE || (sizeof(section) == 3 && uchar(section[0]) == 0xC2 &&
-                         uchar(section[1]) == 0xA7);
-}
-}  // namespace detail
-
-/**
-  An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
-  subset of the API. ``fmtquill::basic_string_view`` is used for format strings even
-  if ``std::string_view`` is available to prevent issues when a library is
-  compiled with a different ``-std`` option than the client code (which is not
-  recommended).
- */
-FMTQUILL_EXPORT
-template <typename Char> class basic_string_view {
- private:
-  const Char* data_;
-  size_t size_;
-
- public:
-  using value_type = Char;
-  using iterator = const Char*;
-
-  constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {}
-
-  /** Constructs a string reference object from a C string and a size. */
-  constexpr basic_string_view(const Char* s, size_t count) noexcept
-      : data_(s), size_(count) {}
-
-  /**
-    \rst
-    Constructs a string reference object from a C string computing
-    the size with ``std::char_traits<Char>::length``.
-    \endrst
-   */
-  FMTQUILL_CONSTEXPR_CHAR_TRAITS
-  FMTQUILL_INLINE
-  basic_string_view(const Char* s)
-      : data_(s),
-        size_(detail::const_check(std::is_same<Char, char>::value &&
-                                  !detail::is_constant_evaluated(true))
-                  ? std::strlen(reinterpret_cast<const char*>(s))
-                  : std::char_traits<Char>::length(s)) {}
-
-  /** Constructs a string reference from a ``std::basic_string`` object. */
-  template <typename Traits, typename Alloc>
-  FMTQUILL_CONSTEXPR basic_string_view(
-      const std::basic_string<Char, Traits, Alloc>& s) noexcept
-      : data_(s.data()), size_(s.size()) {}
-
-  template <typename S, FMTQUILL_ENABLE_IF(std::is_same<
-                                      S, detail::std_string_view<Char>>::value)>
-  FMTQUILL_CONSTEXPR basic_string_view(S s) noexcept
-      : data_(s.data()), size_(s.size()) {}
-
-  /** Returns a pointer to the string data. */
-  constexpr auto data() const noexcept -> const Char* { return data_; }
-
-  /** Returns the string size. */
-  constexpr auto size() const noexcept -> size_t { return size_; }
-
-  constexpr auto begin() const noexcept -> iterator { return data_; }
-  constexpr auto end() const noexcept -> iterator { return data_ + size_; }
-
-  constexpr auto operator[](size_t pos) const noexcept -> const Char& {
-    return data_[pos];
-  }
-
-  FMTQUILL_CONSTEXPR void remove_prefix(size_t n) noexcept {
-    data_ += n;
-    size_ -= n;
-  }
-
-  FMTQUILL_CONSTEXPR_CHAR_TRAITS auto starts_with(
-      basic_string_view<Char> sv) const noexcept -> bool {
-    return size_ >= sv.size_ &&
-           std::char_traits<Char>::compare(data_, sv.data_, sv.size_) == 0;
-  }
-  FMTQUILL_CONSTEXPR_CHAR_TRAITS auto starts_with(Char c) const noexcept -> bool {
-    return size_ >= 1 && std::char_traits<Char>::eq(*data_, c);
-  }
-  FMTQUILL_CONSTEXPR_CHAR_TRAITS auto starts_with(const Char* s) const -> bool {
-    return starts_with(basic_string_view<Char>(s));
-  }
-
-  // Lexicographically compare this string reference to other.
-  FMTQUILL_CONSTEXPR_CHAR_TRAITS auto compare(basic_string_view other) const -> int {
-    size_t str_size = size_ < other.size_ ? size_ : other.size_;
-    int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
-    if (result == 0)
-      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
-    return result;
-  }
-
-  FMTQUILL_CONSTEXPR_CHAR_TRAITS friend auto operator==(basic_string_view lhs,
-                                                   basic_string_view rhs)
-      -> bool {
-    return lhs.compare(rhs) == 0;
-  }
-  friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {
-    return lhs.compare(rhs) != 0;
-  }
-  friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool {
-    return lhs.compare(rhs) < 0;
-  }
-  friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool {
-    return lhs.compare(rhs) <= 0;
-  }
-  friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool {
-    return lhs.compare(rhs) > 0;
-  }
-  friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool {
-    return lhs.compare(rhs) >= 0;
-  }
-};
-
-FMTQUILL_EXPORT
-using string_view = basic_string_view<char>;
-
-/** Specifies if ``T`` is a character type. Can be specialized by users. */
-FMTQUILL_EXPORT
-template <typename T> struct is_char : std::false_type {};
-template <> struct is_char<char> : std::true_type {};
-
-namespace detail {
-
-// A base class for compile-time strings.
-struct compile_string {};
-
-template <typename S>
-struct is_compile_string : std::is_base_of<compile_string, S> {};
-
-template <typename Char, FMTQUILL_ENABLE_IF(is_char<Char>::value)>
-FMTQUILL_INLINE auto to_string_view(const Char* s) -> basic_string_view<Char> {
-  return s;
-}
-template <typename Char, typename Traits, typename Alloc>
-inline auto to_string_view(const std::basic_string<Char, Traits, Alloc>& s)
-    -> basic_string_view<Char> {
-  return s;
-}
-template <typename Char>
-constexpr auto to_string_view(basic_string_view<Char> s)
-    -> basic_string_view<Char> {
-  return s;
-}
-template <typename Char,
-          FMTQUILL_ENABLE_IF(!std::is_empty<std_string_view<Char>>::value)>
-inline auto to_string_view(std_string_view<Char> s) -> basic_string_view<Char> {
-  return s;
-}
-template <typename S, FMTQUILL_ENABLE_IF(is_compile_string<S>::value)>
-constexpr auto to_string_view(const S& s)
-    -> basic_string_view<typename S::char_type> {
-  return basic_string_view<typename S::char_type>(s);
-}
-void to_string_view(...);
-
-// Specifies whether S is a string type convertible to fmtquill::basic_string_view.
-// It should be a constexpr function but MSVC 2017 fails to compile it in
-// enable_if and MSVC 2015 fails to compile it as an alias template.
-// ADL is intentionally disabled as to_string_view is not an extension point.
-template <typename S>
-struct is_string
-    : std::is_class<decltype(detail::to_string_view(std::declval<S>()))> {};
-
-template <typename S, typename = void> struct char_t_impl {};
-template <typename S> struct char_t_impl<S, enable_if_t<is_string<S>::value>> {
-  using result = decltype(to_string_view(std::declval<S>()));
-  using type = typename result::value_type;
-};
-
-enum class type {
-  none_type,
-  // Integer types should go first,
-  int_type,
-  uint_type,
-  long_long_type,
-  ulong_long_type,
-  int128_type,
-  uint128_type,
-  bool_type,
-  char_type,
-  last_integer_type = char_type,
-  // followed by floating-point types.
-  float_type,
-  double_type,
-  long_double_type,
-  last_numeric_type = long_double_type,
-  cstring_type,
-  string_type,
-  pointer_type,
-  custom_type
-};
-
-// Maps core type T to the corresponding type enum constant.
-template <typename T, typename Char>
-struct type_constant : std::integral_constant<type, type::custom_type> {};
-
-#define FMTQUILL_TYPE_CONSTANT(Type, constant) \
-  template <typename Char>                \
-  struct type_constant<Type, Char>        \
-      : std::integral_constant<type, type::constant> {}
-
-FMTQUILL_TYPE_CONSTANT(int, int_type);
-FMTQUILL_TYPE_CONSTANT(unsigned, uint_type);
-FMTQUILL_TYPE_CONSTANT(long long, long_long_type);
-FMTQUILL_TYPE_CONSTANT(unsigned long long, ulong_long_type);
-FMTQUILL_TYPE_CONSTANT(int128_opt, int128_type);
-FMTQUILL_TYPE_CONSTANT(uint128_opt, uint128_type);
-FMTQUILL_TYPE_CONSTANT(bool, bool_type);
-FMTQUILL_TYPE_CONSTANT(Char, char_type);
-FMTQUILL_TYPE_CONSTANT(float, float_type);
-FMTQUILL_TYPE_CONSTANT(double, double_type);
-FMTQUILL_TYPE_CONSTANT(long double, long_double_type);
-FMTQUILL_TYPE_CONSTANT(const Char*, cstring_type);
-FMTQUILL_TYPE_CONSTANT(basic_string_view<Char>, string_type);
-FMTQUILL_TYPE_CONSTANT(const void*, pointer_type);
-
-constexpr auto is_integral_type(type t) -> bool {
-  return t > type::none_type && t <= type::last_integer_type;
-}
-constexpr auto is_arithmetic_type(type t) -> bool {
-  return t > type::none_type && t <= type::last_numeric_type;
-}
-
-constexpr auto set(type rhs) -> int { return 1 << static_cast<int>(rhs); }
-constexpr auto in(type t, int set) -> bool {
-  return ((set >> static_cast<int>(t)) & 1) != 0;
-}
-
-// Bitsets of types.
-enum {
-  sint_set =
-      set(type::int_type) | set(type::long_long_type) | set(type::int128_type),
-  uint_set = set(type::uint_type) | set(type::ulong_long_type) |
-             set(type::uint128_type),
-  bool_set = set(type::bool_type),
-  char_set = set(type::char_type),
-  float_set = set(type::float_type) | set(type::double_type) |
-              set(type::long_double_type),
-  string_set = set(type::string_type),
-  cstring_set = set(type::cstring_type),
-  pointer_set = set(type::pointer_type)
-};
-
-// DEPRECATED!
-FMTQUILL_NORETURN FMTQUILL_API void throw_format_error(const char* message);
-
-struct error_handler {
-  constexpr error_handler() = default;
-
-  // This function is intentionally not constexpr to give a compile-time error.
-  FMTQUILL_NORETURN void on_error(const char* message) {
-    throw_format_error(message);
-  }
-};
-}  // namespace detail
-
-/** Throws ``format_error`` with a given message. */
-using detail::throw_format_error;
-
-/** String's character type. */
-template <typename S> using char_t = typename detail::char_t_impl<S>::type;
-
-/**
-  \rst
-  Parsing context consisting of a format string range being parsed and an
-  argument counter for automatic indexing.
-  You can use the ``format_parse_context`` type alias for ``char`` instead.
-  \endrst
- */
-FMTQUILL_EXPORT
-template <typename Char> class basic_format_parse_context {
- private:
-  basic_string_view<Char> format_str_;
-  int next_arg_id_;
-
-  FMTQUILL_CONSTEXPR void do_check_arg_id(int id);
-
- public:
-  using char_type = Char;
-  using iterator = const Char*;
-
-  explicit constexpr basic_format_parse_context(
-      basic_string_view<Char> format_str, int next_arg_id = 0)
-      : format_str_(format_str), next_arg_id_(next_arg_id) {}
-
-  /**
-    Returns an iterator to the beginning of the format string range being
-    parsed.
-   */
-  constexpr auto begin() const noexcept -> iterator {
-    return format_str_.begin();
-  }
-
-  /**
-    Returns an iterator past the end of the format string range being parsed.
-   */
-  constexpr auto end() const noexcept -> iterator { return format_str_.end(); }
-
-  /** Advances the begin iterator to ``it``. */
-  FMTQUILL_CONSTEXPR void advance_to(iterator it) {
-    format_str_.remove_prefix(detail::to_unsigned(it - begin()));
-  }
-
-  /**
-    Reports an error if using the manual argument indexing; otherwise returns
-    the next argument index and switches to the automatic indexing.
-   */
-  FMTQUILL_CONSTEXPR auto next_arg_id() -> int {
-    if (next_arg_id_ < 0) {
-      detail::throw_format_error(
-          "cannot switch from manual to automatic argument indexing");
-      return 0;
-    }
-    int id = next_arg_id_++;
-    do_check_arg_id(id);
-    return id;
-  }
-
-  /**
-    Reports an error if using the automatic argument indexing; otherwise
-    switches to the manual indexing.
-   */
-  FMTQUILL_CONSTEXPR void check_arg_id(int id) {
-    if (next_arg_id_ > 0) {
-      detail::throw_format_error(
-          "cannot switch from automatic to manual argument indexing");
-      return;
-    }
-    next_arg_id_ = -1;
-    do_check_arg_id(id);
-  }
-  FMTQUILL_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}
-  FMTQUILL_CONSTEXPR void check_dynamic_spec(int arg_id);
-};
-
-FMTQUILL_EXPORT
-using format_parse_context = basic_format_parse_context<char>;
-
-namespace detail {
-// A parse context with extra data used only in compile-time checks.
-template <typename Char>
-class compile_parse_context : public basic_format_parse_context<Char> {
- private:
-  int num_args_;
-  const type* types_;
-  using base = basic_format_parse_context<Char>;
-
- public:
-  explicit FMTQUILL_CONSTEXPR compile_parse_context(
-      basic_string_view<Char> format_str, int num_args, const type* types,
-      int next_arg_id = 0)
-      : base(format_str, next_arg_id), num_args_(num_args), types_(types) {}
-
-  constexpr auto num_args() const -> int { return num_args_; }
-  constexpr auto arg_type(int id) const -> type { return types_[id]; }
-
-  FMTQUILL_CONSTEXPR auto next_arg_id() -> int {
-    int id = base::next_arg_id();
-    if (id >= num_args_) throw_format_error("argument not found");
-    return id;
-  }
-
-  FMTQUILL_CONSTEXPR void check_arg_id(int id) {
-    base::check_arg_id(id);
-    if (id >= num_args_) throw_format_error("argument not found");
-  }
-  using base::check_arg_id;
-
-  FMTQUILL_CONSTEXPR void check_dynamic_spec(int arg_id) {
-    detail::ignore_unused(arg_id);
-#if !defined(__LCC__)
-    if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id]))
-      throw_format_error("width/precision is not integer");
-#endif
-  }
-};
-
-// Extracts a reference to the container from back_insert_iterator.
-template <typename Container>
-inline auto get_container(std::back_insert_iterator<Container> it)
-    -> Container& {
-  using base = std::back_insert_iterator<Container>;
-  struct accessor : base {
-    accessor(base b) : base(b) {}
-    using base::container;
-  };
-  return *accessor(it).container;
-}
-
-template <typename Char, typename InputIt, typename OutputIt>
-FMTQUILL_CONSTEXPR auto copy_str(InputIt begin, InputIt end, OutputIt out)
-    -> OutputIt {
-  while (begin != end) *out++ = static_cast<Char>(*begin++);
-  return out;
-}
-
-template <typename Char, typename T, typename U,
-          FMTQUILL_ENABLE_IF(
-              std::is_same<remove_const_t<T>, U>::value&& is_char<U>::value)>
-FMTQUILL_CONSTEXPR auto copy_str(T* begin, T* end, U* out) -> U* {
-  if (is_constant_evaluated()) return copy_str<Char, T*, U*>(begin, end, out);
-  auto size = to_unsigned(end - begin);
-  if (size > 0) memcpy(out, begin, size * sizeof(U));
-  return out + size;
-}
-
-/**
-  \rst
-  A contiguous memory buffer with an optional growing ability. It is an internal
-  class and shouldn't be used directly, only via `~fmtquill::basic_memory_buffer`.
-  \endrst
- */
-template <typename T> class buffer {
-protected:
-  T* ptr_;
-  size_t size_;
-  size_t capacity_;
-
-  // Don't initialize ptr_ since it is not accessed to save a few cycles.
-  FMTQUILL_MSC_WARNING(suppress : 26495)
-  FMTQUILL_CONSTEXPR buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {}
-
-  FMTQUILL_CONSTEXPR20 buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept
-      : ptr_(p), size_(sz), capacity_(cap) {}
-
-  FMTQUILL_CONSTEXPR20 ~buffer() = default;
-  buffer(buffer&&) = default;
-
-  /** Sets the buffer data and capacity. */
-  FMTQUILL_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
-    ptr_ = buf_data;
-    capacity_ = buf_capacity;
-  }
-
-  /** Increases the buffer capacity to hold at least *capacity* elements. */
-  // DEPRECATED!
-  virtual FMTQUILL_CONSTEXPR20 void grow(size_t capacity) = 0;
-
- public:
-  using value_type = T;
-  using const_reference = const T&;
-
-  buffer(const buffer&) = delete;
-  void operator=(const buffer&) = delete;
-
-  FMTQUILL_INLINE auto begin() noexcept -> T* { return ptr_; }
-  FMTQUILL_INLINE auto end() noexcept -> T* { return ptr_ + size_; }
-
-  FMTQUILL_INLINE auto begin() const noexcept -> const T* { return ptr_; }
-  FMTQUILL_INLINE auto end() const noexcept -> const T* { return ptr_ + size_; }
-
-  /** Returns the size of this buffer. */
-  constexpr auto size() const noexcept -> size_t { return size_; }
-
-  /** Returns the capacity of this buffer. */
-  constexpr auto capacity() const noexcept -> size_t { return capacity_; }
-
-  /** Returns a pointer to the buffer data (not null-terminated). */
-  FMTQUILL_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
-  FMTQUILL_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }
-
-  /** Clears this buffer. */
-  void clear() { size_ = 0; }
-
-  // Tries resizing the buffer to contain *count* elements. If T is a POD type
-  // the new elements may not be initialized.
-  FMTQUILL_CONSTEXPR20 void try_resize(size_t count) {
-    try_reserve(count);
-    size_ = count <= capacity_ ? count : capacity_;
-  }
-
-  // Tries increasing the buffer capacity to *new_capacity*. It can increase the
-  // capacity by a smaller amount than requested but guarantees there is space
-  // for at least one additional element either by increasing the capacity or by
-  // flushing the buffer if it is full.
-  FMTQUILL_CONSTEXPR20 void try_reserve(size_t new_capacity) {
-    if (new_capacity > capacity_) grow(new_capacity);
-  }
-
-  FMTQUILL_CONSTEXPR20 void push_back(const T& value) {
-    try_reserve(size_ + 1);
-    ptr_[size_++] = value;
-  }
-
-  /** Appends data to the end of the buffer. */
-  template <typename U> void append(const U* begin, const U* end);
-
-  template <typename Idx> FMTQUILL_CONSTEXPR auto operator[](Idx index) -> T& {
-    return ptr_[index];
-  }
-  template <typename Idx>
-  FMTQUILL_CONSTEXPR auto operator[](Idx index) const -> const T& {
-    return ptr_[index];
-  }
-};
-
-struct buffer_traits {
-  explicit buffer_traits(size_t) {}
-  auto count() const -> size_t { return 0; }
-  auto limit(size_t size) -> size_t { return size; }
-};
-
-class fixed_buffer_traits {
- private:
-  size_t count_ = 0;
-  size_t limit_;
-
- public:
-  explicit fixed_buffer_traits(size_t limit) : limit_(limit) {}
-  auto count() const -> size_t { return count_; }
-  auto limit(size_t size) -> size_t {
-    size_t n = limit_ > count_ ? limit_ - count_ : 0;
-    count_ += size;
-    return size < n ? size : n;
-  }
-};
-
-// A buffer that writes to an output iterator when flushed.
-template <typename OutputIt, typename T, typename Traits = buffer_traits>
-class iterator_buffer final : public Traits, public buffer<T> {
- private:
-  OutputIt out_;
-  enum { buffer_size = 256 };
-  T data_[buffer_size];
-
- protected:
-  FMTQUILL_CONSTEXPR20 void grow(size_t) override {
-    if (this->size() == buffer_size) flush();
-  }
-
-  void flush() {
-    auto size = this->size();
-    this->clear();
-    out_ = copy_str<T>(data_, data_ + this->limit(size), out_);
-  }
-
- public:
-  explicit iterator_buffer(OutputIt out, size_t n = buffer_size)
-      : Traits(n), buffer<T>(data_, 0, buffer_size), out_(out) {}
-  iterator_buffer(iterator_buffer&& other)
-      : Traits(other), buffer<T>(data_, 0, buffer_size), out_(other.out_) {}
-  ~iterator_buffer() { flush(); }
-
-  auto out() -> OutputIt {
-    flush();
-    return out_;
-  }
-  auto count() const -> size_t { return Traits::count() + this->size(); }
-};
-
-template <typename T>
-class iterator_buffer<T*, T, fixed_buffer_traits> final
-    : public fixed_buffer_traits,
-      public buffer<T> {
- private:
-  T* out_;
-  enum { buffer_size = 256 };
-  T data_[buffer_size];
-
- protected:
-  FMTQUILL_CONSTEXPR20 void grow(size_t) override {
-    if (this->size() == this->capacity()) flush();
-  }
-
-  void flush() {
-    size_t n = this->limit(this->size());
-    if (this->data() == out_) {
-      out_ += n;
-      this->set(data_, buffer_size);
-    }
-    this->clear();
-  }
-
- public:
-  explicit iterator_buffer(T* out, size_t n = buffer_size)
-      : fixed_buffer_traits(n), buffer<T>(out, 0, n), out_(out) {}
-  iterator_buffer(iterator_buffer&& other)
-      : fixed_buffer_traits(other),
-        buffer<T>(std::move(other)),
-        out_(other.out_) {
-    if (this->data() != out_) {
-      this->set(data_, buffer_size);
-      this->clear();
-    }
-  }
-  ~iterator_buffer() { flush(); }
-
-  auto out() -> T* {
-    flush();
-    return out_;
-  }
-  auto count() const -> size_t {
-    return fixed_buffer_traits::count() + this->size();
-  }
-};
-
-template <typename T> class iterator_buffer<T*, T> final : public buffer<T> {
- protected:
-  FMTQUILL_CONSTEXPR20 void grow(size_t) override {}
-
- public:
-  explicit iterator_buffer(T* out, size_t = 0) : buffer<T>(out, 0, ~size_t()) {}
-
-  auto out() -> T* { return &*this->end(); }
-};
-
-// A buffer that writes to a container with the contiguous storage.
-template <typename Container>
-class iterator_buffer<std::back_insert_iterator<Container>,
-                      enable_if_t<is_contiguous<Container>::value,
-                                  typename Container::value_type>>
-    final : public buffer<typename Container::value_type> {
- private:
-  Container& container_;
-
- protected:
-  FMTQUILL_CONSTEXPR20 void grow(size_t capacity) override {
-    container_.resize(capacity);
-    this->set(&container_[0], capacity);
-  }
-
- public:
-  explicit iterator_buffer(Container& c)
-      : buffer<typename Container::value_type>(c.size()), container_(c) {}
-  explicit iterator_buffer(std::back_insert_iterator<Container> out, size_t = 0)
-      : iterator_buffer(get_container(out)) {}
-
-  auto out() -> std::back_insert_iterator<Container> {
-    return std::back_inserter(container_);
-  }
-};
-
-// A buffer that counts the number of code units written discarding the output.
-template <typename T = char> class counting_buffer final : public buffer<T> {
- private:
-  enum { buffer_size = 256 };
-  T data_[buffer_size];
-  size_t count_ = 0;
-
- protected:
-  FMTQUILL_CONSTEXPR20 void grow(size_t) override {
-    if (this->size() != buffer_size) return;
-    count_ += this->size();
-    this->clear();
-  }
-
- public:
-  counting_buffer() : buffer<T>(data_, 0, buffer_size) {}
-
-  auto count() -> size_t { return count_ + this->size(); }
-};
-}  // namespace detail
-
-template <typename Char>
-FMTQUILL_CONSTEXPR void basic_format_parse_context<Char>::do_check_arg_id(int id) {
-  // Argument id is only checked at compile-time during parsing because
-  // formatting has its own validation.
-  if (detail::is_constant_evaluated() &&
-      (!FMTQUILL_GCC_VERSION || FMTQUILL_GCC_VERSION >= 1200)) {
-    using context = detail::compile_parse_context<Char>;
-    if (id >= static_cast<context*>(this)->num_args())
-      detail::throw_format_error("argument not found");
-  }
-}
-
-template <typename Char>
-FMTQUILL_CONSTEXPR void basic_format_parse_context<Char>::check_dynamic_spec(
-    int arg_id) {
-  if (detail::is_constant_evaluated() &&
-      (!FMTQUILL_GCC_VERSION || FMTQUILL_GCC_VERSION >= 1200)) {
-    using context = detail::compile_parse_context<Char>;
-    static_cast<context*>(this)->check_dynamic_spec(arg_id);
-  }
-}
-
-FMTQUILL_EXPORT template <typename Context> class basic_format_arg;
-FMTQUILL_EXPORT template <typename Context> class basic_format_args;
-FMTQUILL_EXPORT template <typename Context> class dynamic_format_arg_store;
-
-// A formatter for objects of type T.
-FMTQUILL_EXPORT
-template <typename T, typename Char = char, typename Enable = void>
-struct formatter {
-  // A deleted default constructor indicates a disabled formatter.
-  formatter() = delete;
-};
-
-// Specifies if T has an enabled formatter specialization. A type can be
-// formattable even if it doesn't have a formatter e.g. via a conversion.
-template <typename T, typename Context>
-using has_formatter =
-    std::is_constructible<typename Context::template formatter_type<T>>;
-
-// An output iterator that appends to a buffer.
-// It is used to reduce symbol sizes for the common case.
-class appender : public std::back_insert_iterator<detail::buffer<char>> {
-  using base = std::back_insert_iterator<detail::buffer<char>>;
-
- public:
-  using std::back_insert_iterator<detail::buffer<char>>::back_insert_iterator;
-  appender(base it) noexcept : base(it) {}
-  FMTQUILL_UNCHECKED_ITERATOR(appender);
-
-  auto operator++() noexcept -> appender& { return *this; }
-  auto operator++(int) noexcept -> appender { return *this; }
-};
-
-namespace detail {
-
-template <typename Context, typename T>
-constexpr auto has_const_formatter_impl(T*)
-    -> decltype(typename Context::template formatter_type<T>().format(
-                    std::declval<const T&>(), std::declval<Context&>()),
-                true) {
-  return true;
-}
-template <typename Context>
-constexpr auto has_const_formatter_impl(...) -> bool {
-  return false;
-}
-template <typename T, typename Context>
-constexpr auto has_const_formatter() -> bool {
-  return has_const_formatter_impl<Context>(static_cast<T*>(nullptr));
-}
-
-template <typename T>
-using buffer_appender = conditional_t<std::is_same<T, char>::value, appender,
-                                      std::back_insert_iterator<buffer<T>>>;
-
-// Maps an output iterator to a buffer.
-template <typename T, typename OutputIt>
-auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> {
-  return iterator_buffer<OutputIt, T>(out);
-}
-template <typename T, typename Buf,
-          FMTQUILL_ENABLE_IF(std::is_base_of<buffer<char>, Buf>::value)>
-auto get_buffer(std::back_insert_iterator<Buf> out) -> buffer<char>& {
-  return get_container(out);
-}
-
-template <typename Buf, typename OutputIt>
-FMTQUILL_INLINE auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) {
-  return buf.out();
-}
-template <typename T, typename OutputIt>
-auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt {
-  return out;
-}
-
-struct view {};
-
-template <typename Char, typename T> struct named_arg : view {
-  const Char* name;
-  const T& value;
-  named_arg(const Char* n, const T& v) : name(n), value(v) {}
-};
-
-template <typename Char> struct named_arg_info {
-  const Char* name;
-  int id;
-};
-
-template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
-struct arg_data {
-  // args_[0].named_args points to named_args_ to avoid bloating format_args.
-  // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
-  T args_[1 + (NUM_ARGS != 0 ? NUM_ARGS : +1)];
-  named_arg_info<Char> named_args_[NUM_NAMED_ARGS];
-
-  template <typename... U>
-  arg_data(const U&... init) : args_{T(named_args_, NUM_NAMED_ARGS), init...} {}
-  arg_data(const arg_data& other) = delete;
-  auto args() const -> const T* { return args_ + 1; }
-  auto named_args() -> named_arg_info<Char>* { return named_args_; }
-};
-
-template <typename T, typename Char, size_t NUM_ARGS>
-struct arg_data<T, Char, NUM_ARGS, 0> {
-  // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
-  T args_[NUM_ARGS != 0 ? NUM_ARGS : +1];
-
-  template <typename... U>
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE arg_data(const U&... init) : args_{init...} {}
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto args() const -> const T* { return args_; }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto named_args() -> std::nullptr_t {
-    return nullptr;
-  }
-};
-
-template <typename Char>
-inline void init_named_args(named_arg_info<Char>*, int, int) {}
-
-template <typename T> struct is_named_arg : std::false_type {};
-template <typename T> struct is_statically_named_arg : std::false_type {};
-
-template <typename T, typename Char>
-struct is_named_arg<named_arg<Char, T>> : std::true_type {};
-
-template <typename Char, typename T, typename... Tail,
-          FMTQUILL_ENABLE_IF(!is_named_arg<T>::value)>
-void init_named_args(named_arg_info<Char>* named_args, int arg_count,
-                     int named_arg_count, const T&, const Tail&... args) {
-  init_named_args(named_args, arg_count + 1, named_arg_count, args...);
-}
-
-template <typename Char, typename T, typename... Tail,
-          FMTQUILL_ENABLE_IF(is_named_arg<T>::value)>
-void init_named_args(named_arg_info<Char>* named_args, int arg_count,
-                     int named_arg_count, const T& arg, const Tail&... args) {
-  named_args[named_arg_count++] = {arg.name, arg_count};
-  init_named_args(named_args, arg_count + 1, named_arg_count, args...);
-}
-
-template <typename... Args>
-FMTQUILL_CONSTEXPR FMTQUILL_INLINE void init_named_args(std::nullptr_t, int, int,
-                                              const Args&...) {}
-
-template <bool B = false> constexpr auto count() -> size_t { return B ? 1 : 0; }
-template <bool B1, bool B2, bool... Tail> constexpr auto count() -> size_t {
-  return (B1 ? 1 : 0) + count<B2, Tail...>();
-}
-
-template <typename... Args> constexpr auto count_named_args() -> size_t {
-  return count<is_named_arg<Args>::value...>();
-}
-
-template <typename... Args>
-constexpr auto count_statically_named_args() -> size_t {
-  return count<is_statically_named_arg<Args>::value...>();
-}
-
-struct unformattable {};
-struct unformattable_char : unformattable {};
-struct unformattable_pointer : unformattable {};
-
-template <typename Char> struct string_value {
-  const Char* data;
-  size_t size;
-};
-
-template <typename Char> struct named_arg_value {
-  const named_arg_info<Char>* data;
-  size_t size;
-};
-
-template <typename Context> struct custom_value {
-  using parse_context = typename Context::parse_context_type;
-  void* value;
-  void (*format)(void* arg, parse_context& parse_ctx, Context& ctx);
-};
-
-// A formatting argument value.
-template <typename Context> class value {
- public:
-  using char_type = typename Context::char_type;
-
-  union {
-    monostate no_value;
-    int int_value;
-    unsigned uint_value;
-    long long long_long_value;
-    unsigned long long ulong_long_value;
-    int128_opt int128_value;
-    uint128_opt uint128_value;
-    bool bool_value;
-    char_type char_value;
-    float float_value;
-    double double_value;
-    long double long_double_value;
-    const void* pointer;
-    string_value<char_type> string;
-    custom_value<Context> custom;
-    named_arg_value<char_type> named_args;
-  };
-
-  constexpr FMTQUILL_INLINE value() : no_value() {}
-  constexpr FMTQUILL_INLINE value(int val) : int_value(val) {}
-  constexpr FMTQUILL_INLINE value(unsigned val) : uint_value(val) {}
-  constexpr FMTQUILL_INLINE value(long long val) : long_long_value(val) {}
-  constexpr FMTQUILL_INLINE value(unsigned long long val) : ulong_long_value(val) {}
-  FMTQUILL_INLINE value(int128_opt val) : int128_value(val) {}
-  FMTQUILL_INLINE value(uint128_opt val) : uint128_value(val) {}
-  constexpr FMTQUILL_INLINE value(float val) : float_value(val) {}
-  constexpr FMTQUILL_INLINE value(double val) : double_value(val) {}
-  FMTQUILL_INLINE value(long double val) : long_double_value(val) {}
-  constexpr FMTQUILL_INLINE value(bool val) : bool_value(val) {}
-  constexpr FMTQUILL_INLINE value(char_type val) : char_value(val) {}
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE value(const char_type* val) {
-    string.data = val;
-    if (is_constant_evaluated()) string.size = {};
-  }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE value(basic_string_view<char_type> val) {
-    string.data = val.data();
-    string.size = val.size();
-  }
-  FMTQUILL_INLINE value(const void* val) : pointer(val) {}
-  FMTQUILL_INLINE value(const named_arg_info<char_type>* args, size_t size)
-      : named_args{args, size} {}
-
-  template <typename T> FMTQUILL_CONSTEXPR20 FMTQUILL_INLINE value(T& val) {
-    using value_type = remove_const_t<T>;
-    custom.value = const_cast<value_type*>(std::addressof(val));
-    // Get the formatter type through the context to allow different contexts
-    // have different extension points, e.g. `formatter<T>` for `format` and
-    // `printf_formatter<T>` for `printf`.
-    custom.format = format_custom_arg<
-        value_type, typename Context::template formatter_type<value_type>>;
-  }
-  value(unformattable);
-  value(unformattable_char);
-  value(unformattable_pointer);
-
- private:
-  // Formats an argument of a custom type, such as a user-defined class.
-  template <typename T, typename Formatter>
-  static void format_custom_arg(void* arg,
-                                typename Context::parse_context_type& parse_ctx,
-                                Context& ctx) {
-    auto f = Formatter();
-    parse_ctx.advance_to(f.parse(parse_ctx));
-    using qualified_type =
-        conditional_t<has_const_formatter<T, Context>(), const T, T>;
-    // Calling format through a mutable reference is deprecated.
-    ctx.advance_to(f.format(*static_cast<qualified_type*>(arg), ctx));
-  }
-};
-
-// To minimize the number of types we need to deal with, long is translated
-// either to int or to long long depending on its size.
-enum { long_short = sizeof(long) == sizeof(int) };
-using long_type = conditional_t<long_short, int, long long>;
-using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;
-
-template <typename T> struct format_as_result {
-  template <typename U,
-            FMTQUILL_ENABLE_IF(std::is_enum<U>::value || std::is_class<U>::value)>
-  static auto map(U*) -> remove_cvref_t<decltype(format_as(std::declval<U>()))>;
-  static auto map(...) -> void;
-
-  using type = decltype(map(static_cast<T*>(nullptr)));
-};
-template <typename T> using format_as_t = typename format_as_result<T>::type;
-
-template <typename T>
-struct has_format_as
-    : bool_constant<!std::is_same<format_as_t<T>, void>::value> {};
-
-// Maps formatting arguments to core types.
-// arg_mapper reports errors by returning unformattable instead of using
-// static_assert because it's used in the is_formattable trait.
-template <typename Context> struct arg_mapper {
-  using char_type = typename Context::char_type;
-
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(signed char val) -> int { return val; }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(unsigned char val) -> unsigned {
-    return val;
-  }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(short val) -> int { return val; }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(unsigned short val) -> unsigned {
-    return val;
-  }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(int val) -> int { return val; }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(unsigned val) -> unsigned { return val; }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(long val) -> long_type { return val; }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(unsigned long val) -> ulong_type {
-    return val;
-  }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(long long val) -> long long { return val; }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(unsigned long long val)
-      -> unsigned long long {
-    return val;
-  }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(int128_opt val) -> int128_opt {
-    return val;
-  }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(uint128_opt val) -> uint128_opt {
-    return val;
-  }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(bool val) -> bool { return val; }
-
-  template <typename T, FMTQUILL_ENABLE_IF(std::is_same<T, char>::value ||
-                                      std::is_same<T, char_type>::value)>
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(T val) -> char_type {
-    return val;
-  }
-  template <typename T, enable_if_t<(std::is_same<T, wchar_t>::value ||
-#ifdef __cpp_char8_t
-                                     std::is_same<T, char8_t>::value ||
-#endif
-                                     std::is_same<T, char16_t>::value ||
-                                     std::is_same<T, char32_t>::value) &&
-                                        !std::is_same<T, char_type>::value,
-                                    int> = 0>
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(T) -> unformattable_char {
-    return {};
-  }
-
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(float val) -> float { return val; }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(double val) -> double { return val; }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(long double val) -> long double {
-    return val;
-  }
-
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(char_type* val) -> const char_type* {
-    return val;
-  }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(const char_type* val) -> const char_type* {
-    return val;
-  }
-  template <typename T,
-            FMTQUILL_ENABLE_IF(is_string<T>::value && !std::is_pointer<T>::value &&
-                          std::is_same<char_type, char_t<T>>::value)>
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(const T& val)
-      -> basic_string_view<char_type> {
-    return to_string_view(val);
-  }
-  template <typename T,
-            FMTQUILL_ENABLE_IF(is_string<T>::value && !std::is_pointer<T>::value &&
-                          !std::is_same<char_type, char_t<T>>::value)>
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(const T&) -> unformattable_char {
-    return {};
-  }
-
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(void* val) -> const void* { return val; }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(const void* val) -> const void* {
-    return val;
-  }
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(std::nullptr_t val) -> const void* {
-    return val;
-  }
-
-  // Use SFINAE instead of a const T* parameter to avoid a conflict with the
-  // array overload.
-  template <
-      typename T,
-      FMTQUILL_ENABLE_IF(
-          std::is_pointer<T>::value || std::is_member_pointer<T>::value ||
-          std::is_function<typename std::remove_pointer<T>::type>::value ||
-          (std::is_array<T>::value &&
-           !std::is_convertible<T, const char_type*>::value))>
-  FMTQUILL_CONSTEXPR auto map(const T&) -> unformattable_pointer {
-    return {};
-  }
-
-  template <typename T, std::size_t N,
-            FMTQUILL_ENABLE_IF(!std::is_same<T, wchar_t>::value)>
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(const T (&values)[N]) -> const T (&)[N] {
-    return values;
-  }
-
-  // Only map owning types because mapping views can be unsafe.
-  template <typename T, typename U = format_as_t<T>,
-            FMTQUILL_ENABLE_IF(std::is_arithmetic<U>::value)>
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(const T& val)
-      -> decltype(FMTQUILL_DECLTYPE_THIS map(U())) {
-    return map(format_as(val));
-  }
-
-  template <typename T, typename U = remove_const_t<T>>
-  struct formattable : bool_constant<has_const_formatter<U, Context>() ||
-                                     (has_formatter<U, Context>::value &&
-                                      !std::is_const<T>::value)> {};
-
-  template <typename T, FMTQUILL_ENABLE_IF(formattable<T>::value)>
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto do_map(T& val) -> T& {
-    return val;
-  }
-  template <typename T, FMTQUILL_ENABLE_IF(!formattable<T>::value)>
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto do_map(T&) -> unformattable {
-    return {};
-  }
-
-  template <typename T, typename U = remove_const_t<T>,
-            FMTQUILL_ENABLE_IF((std::is_class<U>::value || std::is_enum<U>::value ||
-                           std::is_union<U>::value) &&
-                          !is_string<U>::value && !is_char<U>::value &&
-                          !is_named_arg<U>::value &&
-                          !std::is_arithmetic<format_as_t<U>>::value)>
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(T& val)
-      -> decltype(FMTQUILL_DECLTYPE_THIS do_map(val)) {
-    return do_map(val);
-  }
-
-  template <typename T, FMTQUILL_ENABLE_IF(is_named_arg<T>::value)>
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto map(const T& named_arg)
-      -> decltype(FMTQUILL_DECLTYPE_THIS map(named_arg.value)) {
-    return map(named_arg.value);
-  }
-
-  auto map(...) -> unformattable { return {}; }
-};
-
-// A type constant after applying arg_mapper<Context>.
-template <typename T, typename Context>
-using mapped_type_constant =
-    type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())),
-                  typename Context::char_type>;
-
-enum { packed_arg_bits = 4 };
-// Maximum number of arguments with packed types.
-enum { max_packed_args = 62 / packed_arg_bits };
-enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
-enum : unsigned long long { has_named_args_bit = 1ULL << 62 };
-
-template <typename Char, typename InputIt>
-auto copy_str(InputIt begin, InputIt end, appender out) -> appender {
-  get_container(out).append(begin, end);
-  return out;
-}
-template <typename Char, typename InputIt>
-auto copy_str(InputIt begin, InputIt end,
-              std::back_insert_iterator<std::string> out)
-    -> std::back_insert_iterator<std::string> {
-  get_container(out).append(begin, end);
-  return out;
-}
-
-template <typename Char, typename R, typename OutputIt>
-FMTQUILL_CONSTEXPR auto copy_str(R&& rng, OutputIt out) -> OutputIt {
-  return detail::copy_str<Char>(rng.begin(), rng.end(), out);
-}
-
-#if FMTQUILL_GCC_VERSION && FMTQUILL_GCC_VERSION < 500
-// A workaround for gcc 4.8 to make void_t work in a SFINAE context.
-template <typename...> struct void_t_impl {
-  using type = void;
-};
-template <typename... T> using void_t = typename void_t_impl<T...>::type;
-#else
-template <typename...> using void_t = void;
-#endif
-
-template <typename It, typename T, typename Enable = void>
-struct is_output_iterator : std::false_type {};
-
-template <typename It, typename T>
-struct is_output_iterator<
-    It, T,
-    void_t<typename std::iterator_traits<It>::iterator_category,
-           decltype(*std::declval<It>() = std::declval<T>())>>
-    : std::true_type {};
-
-template <typename It> struct is_back_insert_iterator : std::false_type {};
-template <typename Container>
-struct is_back_insert_iterator<std::back_insert_iterator<Container>>
-    : std::true_type {};
-
-// A type-erased reference to an std::locale to avoid a heavy <locale> include.
-class locale_ref {
- private:
-  const void* locale_;  // A type-erased pointer to std::locale.
-
- public:
-  constexpr FMTQUILL_INLINE locale_ref() : locale_(nullptr) {}
-  template <typename Locale> explicit locale_ref(const Locale& loc);
-
-  explicit operator bool() const noexcept { return locale_ != nullptr; }
-
-  template <typename Locale> auto get() const -> Locale;
-};
-
-template <typename> constexpr auto encode_types() -> unsigned long long {
-  return 0;
-}
-
-template <typename Context, typename Arg, typename... Args>
-constexpr auto encode_types() -> unsigned long long {
-  return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) |
-         (encode_types<Context, Args...>() << packed_arg_bits);
-}
-
-#if defined(__cpp_if_constexpr)
-// This type is intentionally undefined, only used for errors
-template <typename T, typename Char> struct type_is_unformattable_for;
-#endif
-
-template <bool PACKED, typename Context, typename T, FMTQUILL_ENABLE_IF(PACKED)>
-FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto make_arg(T& val) -> value<Context> {
-  using arg_type = remove_cvref_t<decltype(arg_mapper<Context>().map(val))>;
-
-  constexpr bool formattable_char =
-      !std::is_same<arg_type, unformattable_char>::value;
-  static_assert(formattable_char, "Mixing character types is disallowed.");
-
-  // Formatting of arbitrary pointers is disallowed. If you want to format a
-  // pointer cast it to `void*` or `const void*`. In particular, this forbids
-  // formatting of `[const] volatile char*` printed as bool by iostreams.
-  constexpr bool formattable_pointer =
-      !std::is_same<arg_type, unformattable_pointer>::value;
-  static_assert(formattable_pointer,
-                "Formatting of non-void pointers is disallowed.");
-
-  constexpr bool formattable = !std::is_same<arg_type, unformattable>::value;
-#if defined(__cpp_if_constexpr)
-  if constexpr (!formattable) {
-    type_is_unformattable_for<T, typename Context::char_type> _;
-  }
-#endif
-  static_assert(
-      formattable,
-      "Cannot format an argument. To make type T formattable provide a "
-      "formatter<T> specialization: https://fmt.dev/latest/api.html#udt");
-  return {arg_mapper<Context>().map(val)};
-}
-
-template <typename Context, typename T>
-FMTQUILL_CONSTEXPR auto make_arg(T& val) -> basic_format_arg<Context> {
-  auto arg = basic_format_arg<Context>();
-  arg.type_ = mapped_type_constant<T, Context>::value;
-  arg.value_ = make_arg<true, Context>(val);
-  return arg;
-}
-
-template <bool PACKED, typename Context, typename T, FMTQUILL_ENABLE_IF(!PACKED)>
-FMTQUILL_CONSTEXPR inline auto make_arg(T& val) -> basic_format_arg<Context> {
-  return make_arg<Context>(val);
-}
-}  // namespace detail
-FMTQUILL_BEGIN_EXPORT
-
-// A formatting argument. Context is a template parameter for the compiled API
-// where output can be unbuffered.
-template <typename Context> class basic_format_arg {
- private:
-  detail::value<Context> value_;
-  detail::type type_;
-
-  template <typename ContextType, typename T>
-  friend FMTQUILL_CONSTEXPR auto detail::make_arg(T& value)
-      -> basic_format_arg<ContextType>;
-
-  template <typename Visitor, typename Ctx>
-  friend FMTQUILL_CONSTEXPR auto visit_format_arg(Visitor&& vis,
-                                             const basic_format_arg<Ctx>& arg)
-      -> decltype(vis(0));
-
-  friend class basic_format_args<Context>;
-  friend class dynamic_format_arg_store<Context>;
-
-  using char_type = typename Context::char_type;
-
-  template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
-  friend struct detail::arg_data;
-
-  basic_format_arg(const detail::named_arg_info<char_type>* args, size_t size)
-      : value_(args, size) {}
-
- public:
-  class handle {
-   public:
-    explicit handle(detail::custom_value<Context> custom) : custom_(custom) {}
-
-    void format(typename Context::parse_context_type& parse_ctx,
-                Context& ctx) const {
-      custom_.format(custom_.value, parse_ctx, ctx);
-    }
-
-   private:
-    detail::custom_value<Context> custom_;
-  };
-
-  constexpr basic_format_arg() : type_(detail::type::none_type) {}
-
-  constexpr explicit operator bool() const noexcept {
-    return type_ != detail::type::none_type;
-  }
-
-  auto type() const -> detail::type { return type_; }
-
-  auto is_integral() const -> bool { return detail::is_integral_type(type_); }
-  auto is_arithmetic() const -> bool {
-    return detail::is_arithmetic_type(type_);
-  }
-
-  FMTQUILL_INLINE auto format_custom(const char_type* parse_begin,
-                                typename Context::parse_context_type& parse_ctx,
-                                Context& ctx) -> bool {
-    if (type_ != detail::type::custom_type) return false;
-    parse_ctx.advance_to(parse_begin);
-    value_.custom.format(value_.custom.value, parse_ctx, ctx);
-    return true;
-  }
-};
-
-/**
-  \rst
-  Visits an argument dispatching to the appropriate visit method based on
-  the argument type. For example, if the argument type is ``double`` then
-  ``vis(value)`` will be called with the value of type ``double``.
-  \endrst
- */
-// DEPRECATED!
-template <typename Visitor, typename Context>
-FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto visit_format_arg(
-    Visitor&& vis, const basic_format_arg<Context>& arg) -> decltype(vis(0)) {
-  switch (arg.type_) {
-  case detail::type::none_type:
-    break;
-  case detail::type::int_type:
-    return vis(arg.value_.int_value);
-  case detail::type::uint_type:
-    return vis(arg.value_.uint_value);
-  case detail::type::long_long_type:
-    return vis(arg.value_.long_long_value);
-  case detail::type::ulong_long_type:
-    return vis(arg.value_.ulong_long_value);
-  case detail::type::int128_type:
-    return vis(detail::convert_for_visit(arg.value_.int128_value));
-  case detail::type::uint128_type:
-    return vis(detail::convert_for_visit(arg.value_.uint128_value));
-  case detail::type::bool_type:
-    return vis(arg.value_.bool_value);
-  case detail::type::char_type:
-    return vis(arg.value_.char_value);
-  case detail::type::float_type:
-    return vis(arg.value_.float_value);
-  case detail::type::double_type:
-    return vis(arg.value_.double_value);
-  case detail::type::long_double_type:
-    return vis(arg.value_.long_double_value);
-  case detail::type::cstring_type:
-    return vis(arg.value_.string.data);
-  case detail::type::string_type:
-    using sv = basic_string_view<typename Context::char_type>;
-    return vis(sv(arg.value_.string.data, arg.value_.string.size));
-  case detail::type::pointer_type:
-    return vis(arg.value_.pointer);
-  case detail::type::custom_type:
-    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
-  }
-  return vis(monostate());
-}
-
-// Formatting context.
-template <typename OutputIt, typename Char> class basic_format_context {
- private:
-  OutputIt out_;
-  basic_format_args<basic_format_context> args_;
-  detail::locale_ref loc_;
-
- public:
-  using iterator = OutputIt;
-  using format_arg = basic_format_arg<basic_format_context>;
-  using format_args = basic_format_args<basic_format_context>;
-  using parse_context_type = basic_format_parse_context<Char>;
-  template <typename T> using formatter_type = formatter<T, Char>;
-
-  /** The character type for the output. */
-  using char_type = Char;
-
-  basic_format_context(basic_format_context&&) = default;
-  basic_format_context(const basic_format_context&) = delete;
-  void operator=(const basic_format_context&) = delete;
-  /**
-    Constructs a ``basic_format_context`` object. References to the arguments
-    are stored in the object so make sure they have appropriate lifetimes.
-   */
-  constexpr basic_format_context(OutputIt out, format_args ctx_args,
-                                 detail::locale_ref loc = {})
-      : out_(out), args_(ctx_args), loc_(loc) {}
-
-  constexpr auto arg(int id) const -> format_arg { return args_.get(id); }
-  FMTQUILL_CONSTEXPR auto arg(basic_string_view<Char> name) -> format_arg {
-    return args_.get(name);
-  }
-  FMTQUILL_CONSTEXPR auto arg_id(basic_string_view<Char> name) -> int {
-    return args_.get_id(name);
-  }
-  auto args() const -> const format_args& { return args_; }
-
-  // DEPRECATED!
-  FMTQUILL_CONSTEXPR auto error_handler() -> detail::error_handler { return {}; }
-  void on_error(const char* message) { error_handler().on_error(message); }
-
-  // Returns an iterator to the beginning of the output range.
-  FMTQUILL_CONSTEXPR auto out() -> iterator { return out_; }
-
-  // Advances the begin iterator to ``it``.
-  void advance_to(iterator it) {
-    if (!detail::is_back_insert_iterator<iterator>()) out_ = it;
-  }
-
-  FMTQUILL_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; }
-};
-
-template <typename Char>
-using buffer_context =
-    basic_format_context<detail::buffer_appender<Char>, Char>;
-using format_context = buffer_context<char>;
-
-template <typename T, typename Char = char>
-using is_formattable = bool_constant<!std::is_base_of<
-    detail::unformattable, decltype(detail::arg_mapper<buffer_context<Char>>()
-                                        .map(std::declval<T&>()))>::value>;
-
-/**
-  \rst
-  An array of references to arguments. It can be implicitly converted into
-  `~fmtquill::basic_format_args` for passing into type-erased formatting functions
-  such as `~fmtquill::vformat`.
-  \endrst
- */
-template <typename Context, typename... Args>
-class format_arg_store
-#if FMTQUILL_GCC_VERSION && FMTQUILL_GCC_VERSION < 409
-    // Workaround a GCC template argument substitution bug.
-    : public basic_format_args<Context>
-#endif
-{
- private:
-  static const size_t num_args = sizeof...(Args);
-  static constexpr size_t num_named_args = detail::count_named_args<Args...>();
-  static const bool is_packed = num_args <= detail::max_packed_args;
-
-  using value_type = conditional_t<is_packed, detail::value<Context>,
-                                   basic_format_arg<Context>>;
-
-  detail::arg_data<value_type, typename Context::char_type, num_args,
-                   num_named_args>
-      data_;
-
-  friend class basic_format_args<Context>;
-
-  static constexpr unsigned long long desc =
-      (is_packed ? detail::encode_types<Context, Args...>()
-                 : detail::is_unpacked_bit | num_args) |
-      (num_named_args != 0
-           ? static_cast<unsigned long long>(detail::has_named_args_bit)
-           : 0);
-
- public:
-  template <typename... T>
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE format_arg_store(T&... args)
-      :
-#if FMTQUILL_GCC_VERSION && FMTQUILL_GCC_VERSION < 409
-        basic_format_args<Context>(*this),
-#endif
-        data_{detail::make_arg<is_packed, Context>(args)...} {
-    if (detail::const_check(num_named_args != 0))
-      detail::init_named_args(data_.named_args(), 0, 0, args...);
-  }
-};
-
-/**
-  \rst
-  Constructs a `~fmtquill::format_arg_store` object that contains references to
-  arguments and can be implicitly converted to `~fmtquill::format_args`. `Context`
-  can be omitted in which case it defaults to `~fmtquill::format_context`.
-  See `~fmtquill::arg` for lifetime considerations.
-  \endrst
- */
-// Arguments are taken by lvalue references to avoid some lifetime issues.
-template <typename Context = format_context, typename... T>
-constexpr auto make_format_args(T&... args)
-    -> format_arg_store<Context, remove_cvref_t<T>...> {
-  return {args...};
-}
-
-/**
-  \rst
-  Returns a named argument to be used in a formatting function.
-  It should only be used in a call to a formatting function or
-  `dynamic_format_arg_store::push_back`.
-
-  **Example**::
-
-    fmtquill::print("Elapsed time: {s:.2f} seconds", fmtquill::arg("s", 1.23));
-  \endrst
- */
-template <typename Char, typename T>
-inline auto arg(const Char* name, const T& arg) -> detail::named_arg<Char, T> {
-  static_assert(!detail::is_named_arg<T>(), "nested named arguments");
-  return {name, arg};
-}
-FMTQUILL_END_EXPORT
-
-/**
-  \rst
-  A view of a collection of formatting arguments. To avoid lifetime issues it
-  should only be used as a parameter type in type-erased functions such as
-  ``vformat``::
-
-    void vlog(string_view format_str, format_args args);  // OK
-    format_args args = make_format_args();  // Error: dangling reference
-  \endrst
- */
-template <typename Context> class basic_format_args {
- public:
-  using size_type = int;
-  using format_arg = basic_format_arg<Context>;
-
- private:
-  // A descriptor that contains information about formatting arguments.
-  // If the number of arguments is less or equal to max_packed_args then
-  // argument types are passed in the descriptor. This reduces binary code size
-  // per formatting function call.
-  unsigned long long desc_;
-  union {
-    // If is_packed() returns true then argument values are stored in values_;
-    // otherwise they are stored in args_. This is done to improve cache
-    // locality and reduce compiled code size since storing larger objects
-    // may require more code (at least on x86-64) even if the same amount of
-    // data is actually copied to stack. It saves ~10% on the bloat test.
-    const detail::value<Context>* values_;
-    const format_arg* args_;
-  };
-
-  constexpr auto is_packed() const -> bool {
-    return (desc_ & detail::is_unpacked_bit) == 0;
-  }
-  auto has_named_args() const -> bool {
-    return (desc_ & detail::has_named_args_bit) != 0;
-  }
-
-  FMTQUILL_CONSTEXPR auto type(int index) const -> detail::type {
-    int shift = index * detail::packed_arg_bits;
-    unsigned int mask = (1 << detail::packed_arg_bits) - 1;
-    return static_cast<detail::type>((desc_ >> shift) & mask);
-  }
-
-  constexpr FMTQUILL_INLINE basic_format_args(unsigned long long desc,
-                                         const detail::value<Context>* values)
-      : desc_(desc), values_(values) {}
-
- public:
-  constexpr basic_format_args() : desc_(0), args_(nullptr) {}
-
-  /**
-   \rst
-   Constructs a `basic_format_args` object from `~fmtquill::format_arg_store`.
-   \endrst
-   */
-  template <typename... Args>
-  constexpr FMTQUILL_INLINE basic_format_args(
-      const format_arg_store<Context, Args...>& store)
-      : basic_format_args(format_arg_store<Context, Args...>::desc,
-                          store.data_.args()) {}
-
-  /**
-   \rst
-   Constructs a `basic_format_args` object from
-   `~fmtquill::dynamic_format_arg_store`.
-   \endrst
-   */
-  constexpr FMTQUILL_INLINE basic_format_args(
-      const dynamic_format_arg_store<Context>& store)
-      : basic_format_args(store.get_types(), store.data()) {}
-
-  constexpr basic_format_args(unsigned long long desc, const format_arg* args)
-    : desc_(desc), args_(args) {}
-
-  /**
-   \rst
-   Constructs a `basic_format_args` object from a dynamic set of arguments.
-   \endrst
-   */
-  constexpr basic_format_args(const format_arg* args, int count)
-      : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count),
-                          args) {}
-
-  /** Returns the argument with the specified id. */
-  FMTQUILL_CONSTEXPR auto get(int id) const -> format_arg {
-    format_arg arg;
-    if (!is_packed()) {
-      if (id < max_size()) arg = args_[id];
-      return arg;
-    }
-    if (id >= detail::max_packed_args) return arg;
-    arg.type_ = type(id);
-    if (arg.type_ == detail::type::none_type) return arg;
-    arg.value_ = values_[id];
-    return arg;
-  }
-
-  template <typename Char>
-  auto get(basic_string_view<Char> name) const -> format_arg {
-    int id = get_id(name);
-    return id >= 0 ? get(id) : format_arg();
-  }
-
-  template <typename Char>
-  auto get_id(basic_string_view<Char> name) const -> int {
-    if (!has_named_args()) return -1;
-    const auto& named_args =
-        (is_packed() ? values_[-1] : args_[-1].value_).named_args;
-    for (size_t i = 0; i < named_args.size; ++i) {
-      if (named_args.data[i].name == name) return named_args.data[i].id;
-    }
-    return -1;
-  }
-
-  auto max_size() const -> int {
-    unsigned long long max_packed = detail::max_packed_args;
-    return static_cast<int>(is_packed() ? max_packed
-                                        : desc_ & ~detail::is_unpacked_bit);
-  }
-};
-
-/** An alias to ``basic_format_args<format_context>``. */
-// A separate type would result in shorter symbols but break ABI compatibility
-// between clang and gcc on ARM (#1919).
-FMTQUILL_EXPORT using format_args = basic_format_args<format_context>;
-
-// We cannot use enum classes as bit fields because of a gcc bug, so we put them
-// in namespaces instead (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414).
-// Additionally, if an underlying type is specified, older gcc incorrectly warns
-// that the type is too small. Both bugs are fixed in gcc 9.3.
-#if FMTQUILL_GCC_VERSION && FMTQUILL_GCC_VERSION < 903
-#  define FMTQUILL_ENUM_UNDERLYING_TYPE(type)
-#else
-#  define FMTQUILL_ENUM_UNDERLYING_TYPE(type) : type
-#endif
-namespace align {
-enum type FMTQUILL_ENUM_UNDERLYING_TYPE(unsigned char){none, left, right, center,
-                                                  numeric};
-}
-using align_t = align::type;
-namespace sign {
-enum type FMTQUILL_ENUM_UNDERLYING_TYPE(unsigned char){none, minus, plus, space};
-}
-using sign_t = sign::type;
-
-namespace detail {
-
-// Workaround an array initialization issue in gcc 4.8.
-template <typename Char> struct fill_t {
- private:
-  enum { max_size = 4 };
-  Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)};
-  unsigned char size_ = 1;
-
- public:
-  FMTQUILL_CONSTEXPR void operator=(basic_string_view<Char> s) {
-    auto size = s.size();
-    FMTQUILL_ASSERT(size <= max_size, "invalid fill");
-    for (size_t i = 0; i < size; ++i) data_[i] = s[i];
-    size_ = static_cast<unsigned char>(size);
-  }
-
-  constexpr auto size() const -> size_t { return size_; }
-  constexpr auto data() const -> const Char* { return data_; }
-
-  FMTQUILL_CONSTEXPR auto operator[](size_t index) -> Char& { return data_[index]; }
-  FMTQUILL_CONSTEXPR auto operator[](size_t index) const -> const Char& {
-    return data_[index];
-  }
-};
-}  // namespace detail
-
-enum class presentation_type : unsigned char {
-  none,
-  dec,             // 'd'
-  oct,             // 'o'
-  hex_lower,       // 'x'
-  hex_upper,       // 'X'
-  bin_lower,       // 'b'
-  bin_upper,       // 'B'
-  hexfloat_lower,  // 'a'
-  hexfloat_upper,  // 'A'
-  exp_lower,       // 'e'
-  exp_upper,       // 'E'
-  fixed_lower,     // 'f'
-  fixed_upper,     // 'F'
-  general_lower,   // 'g'
-  general_upper,   // 'G'
-  chr,             // 'c'
-  string,          // 's'
-  pointer,         // 'p'
-  debug            // '?'
-};
-
-// Format specifiers for built-in and string types.
-template <typename Char = char> struct format_specs {
-  int width;
-  int precision;
-  presentation_type type;
-  align_t align : 4;
-  sign_t sign : 3;
-  bool alt : 1;  // Alternate form ('#').
-  bool localized : 1;
-  detail::fill_t<Char> fill;
-
-  constexpr format_specs()
-      : width(0),
-        precision(-1),
-        type(presentation_type::none),
-        align(align::none),
-        sign(sign::none),
-        alt(false),
-        localized(false) {}
-};
-
-namespace detail {
-
-enum class arg_id_kind { none, index, name };
-
-// An argument reference.
-template <typename Char> struct arg_ref {
-  FMTQUILL_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
-
-  FMTQUILL_CONSTEXPR explicit arg_ref(int index)
-      : kind(arg_id_kind::index), val(index) {}
-  FMTQUILL_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
-      : kind(arg_id_kind::name), val(name) {}
-
-  FMTQUILL_CONSTEXPR auto operator=(int idx) -> arg_ref& {
-    kind = arg_id_kind::index;
-    val.index = idx;
-    return *this;
-  }
-
-  arg_id_kind kind;
-  union value {
-    FMTQUILL_CONSTEXPR value(int idx = 0) : index(idx) {}
-    FMTQUILL_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}
-
-    int index;
-    basic_string_view<Char> name;
-  } val;
-};
-
-// Format specifiers with width and precision resolved at formatting rather
-// than parsing time to allow reusing the same parsed specifiers with
-// different sets of arguments (precompilation of format strings).
-template <typename Char = char>
-struct dynamic_format_specs : format_specs<Char> {
-  arg_ref<Char> width_ref;
-  arg_ref<Char> precision_ref;
-};
-
-// Converts a character to ASCII. Returns '\0' on conversion failure.
-template <typename Char, FMTQUILL_ENABLE_IF(std::is_integral<Char>::value)>
-constexpr auto to_ascii(Char c) -> char {
-  return c <= 0xff ? static_cast<char>(c) : '\0';
-}
-template <typename Char, FMTQUILL_ENABLE_IF(std::is_enum<Char>::value)>
-constexpr auto to_ascii(Char c) -> char {
-  return c <= 0xff ? static_cast<char>(c) : '\0';
-}
-
-// Returns the number of code units in a code point or 1 on error.
-template <typename Char>
-FMTQUILL_CONSTEXPR auto code_point_length(const Char* begin) -> int {
-  if (const_check(sizeof(Char) != 1)) return 1;
-  auto c = static_cast<unsigned char>(*begin);
-  return static_cast<int>((0x3a55000000000000ull >> (2 * (c >> 3))) & 0x3) + 1;
-}
-
-// Return the result via the out param to workaround gcc bug 77539.
-template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
-FMTQUILL_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool {
-  for (out = first; out != last; ++out) {
-    if (*out == value) return true;
-  }
-  return false;
-}
-
-template <>
-inline auto find<false, char>(const char* first, const char* last, char value,
-                              const char*& out) -> bool {
-  out = static_cast<const char*>(
-      std::memchr(first, value, to_unsigned(last - first)));
-  return out != nullptr;
-}
-
-// Parses the range [begin, end) as an unsigned integer. This function assumes
-// that the range is non-empty and the first character is a digit.
-template <typename Char>
-FMTQUILL_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end,
-                                         int error_value) noexcept -> int {
-  FMTQUILL_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
-  unsigned value = 0, prev = 0;
-  auto p = begin;
-  do {
-    prev = value;
-    value = value * 10 + unsigned(*p - '0');
-    ++p;
-  } while (p != end && '0' <= *p && *p <= '9');
-  auto num_digits = p - begin;
-  begin = p;
-  if (num_digits <= std::numeric_limits<int>::digits10)
-    return static_cast<int>(value);
-  // Check for overflow.
-  const unsigned max = to_unsigned((std::numeric_limits<int>::max)());
-  return num_digits == std::numeric_limits<int>::digits10 + 1 &&
-                 prev * 10ull + unsigned(p[-1] - '0') <= max
-             ? static_cast<int>(value)
-             : error_value;
-}
-
-FMTQUILL_CONSTEXPR inline auto parse_align(char c) -> align_t {
-  switch (c) {
-  case '<':
-    return align::left;
-  case '>':
-    return align::right;
-  case '^':
-    return align::center;
-  }
-  return align::none;
-}
-
-template <typename Char> constexpr auto is_name_start(Char c) -> bool {
-  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_';
-}
-
-template <typename Char, typename Handler>
-FMTQUILL_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end,
-                                   Handler&& handler) -> const Char* {
-  Char c = *begin;
-  if (c >= '0' && c <= '9') {
-    int index = 0;
-    constexpr int max = (std::numeric_limits<int>::max)();
-    if (c != '0')
-      index = parse_nonnegative_int(begin, end, max);
-    else
-      ++begin;
-    if (begin == end || (*begin != '}' && *begin != ':'))
-      throw_format_error("invalid format string");
-    else
-      handler.on_index(index);
-    return begin;
-  }
-  if (!is_name_start(c)) {
-    throw_format_error("invalid format string");
-    return begin;
-  }
-  auto it = begin;
-  do {
-    ++it;
-  } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9')));
-  handler.on_name({begin, to_unsigned(it - begin)});
-  return it;
-}
-
-template <typename Char, typename Handler>
-FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto parse_arg_id(const Char* begin, const Char* end,
-                                           Handler&& handler) -> const Char* {
-  FMTQUILL_ASSERT(begin != end, "");
-  Char c = *begin;
-  if (c != '}' && c != ':') return do_parse_arg_id(begin, end, handler);
-  handler.on_auto();
-  return begin;
-}
-
-template <typename Char> struct dynamic_spec_id_handler {
-  basic_format_parse_context<Char>& ctx;
-  arg_ref<Char>& ref;
-
-  FMTQUILL_CONSTEXPR void on_auto() {
-    int id = ctx.next_arg_id();
-    ref = arg_ref<Char>(id);
-    ctx.check_dynamic_spec(id);
-  }
-  FMTQUILL_CONSTEXPR void on_index(int id) {
-    ref = arg_ref<Char>(id);
-    ctx.check_arg_id(id);
-    ctx.check_dynamic_spec(id);
-  }
-  FMTQUILL_CONSTEXPR void on_name(basic_string_view<Char> id) {
-    ref = arg_ref<Char>(id);
-    ctx.check_arg_id(id);
-  }
-};
-
-// Parses [integer | "{" [arg_id] "}"].
-template <typename Char>
-FMTQUILL_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end,
-                                      int& value, arg_ref<Char>& ref,
-                                      basic_format_parse_context<Char>& ctx)
-    -> const Char* {
-  FMTQUILL_ASSERT(begin != end, "");
-  if ('0' <= *begin && *begin <= '9') {
-    int val = parse_nonnegative_int(begin, end, -1);
-    if (val != -1)
-      value = val;
-    else
-      throw_format_error("number is too big");
-  } else if (*begin == '{') {
-    ++begin;
-    auto handler = dynamic_spec_id_handler<Char>{ctx, ref};
-    if (begin != end) begin = parse_arg_id(begin, end, handler);
-    if (begin != end && *begin == '}') return ++begin;
-    throw_format_error("invalid format string");
-  }
-  return begin;
-}
-
-template <typename Char>
-FMTQUILL_CONSTEXPR auto parse_precision(const Char* begin, const Char* end,
-                                   int& value, arg_ref<Char>& ref,
-                                   basic_format_parse_context<Char>& ctx)
-    -> const Char* {
-  ++begin;
-  if (begin == end || *begin == '}') {
-    throw_format_error("invalid precision");
-    return begin;
-  }
-  return parse_dynamic_spec(begin, end, value, ref, ctx);
-}
-
-enum class state { start, align, sign, hash, zero, width, precision, locale };
-
-// Parses standard format specifiers.
-template <typename Char>
-FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto parse_format_specs(
-    const Char* begin, const Char* end, dynamic_format_specs<Char>& specs,
-    basic_format_parse_context<Char>& ctx, type arg_type) -> const Char* {
-  auto c = '\0';
-  if (end - begin > 1) {
-    auto next = to_ascii(begin[1]);
-    c = parse_align(next) == align::none ? to_ascii(*begin) : '\0';
-  } else {
-    if (begin == end) return begin;
-    c = to_ascii(*begin);
-  }
-
-  struct {
-    state current_state = state::start;
-    FMTQUILL_CONSTEXPR void operator()(state s, bool valid = true) {
-      if (current_state >= s || !valid)
-        throw_format_error("invalid format specifier");
-      current_state = s;
-    }
-  } enter_state;
-
-  using pres = presentation_type;
-  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
-  struct {
-    const Char*& begin;
-    dynamic_format_specs<Char>& specs;
-    type arg_type;
-
-    FMTQUILL_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
-      if (!in(arg_type, set)) {
-        if (arg_type == type::none_type) return begin;
-        throw_format_error("invalid format specifier");
-      }
-      specs.type = pres_type;
-      return begin + 1;
-    }
-  } parse_presentation_type{begin, specs, arg_type};
-
-  for (;;) {
-    switch (c) {
-    case '<':
-    case '>':
-    case '^':
-      enter_state(state::align);
-      specs.align = parse_align(c);
-      ++begin;
-      break;
-    case '+':
-    case '-':
-    case ' ':
-      if (arg_type == type::none_type) return begin;
-      enter_state(state::sign, in(arg_type, sint_set | float_set));
-      switch (c) {
-      case '+':
-        specs.sign = sign::plus;
-        break;
-      case '-':
-        specs.sign = sign::minus;
-        break;
-      case ' ':
-        specs.sign = sign::space;
-        break;
-      }
-      ++begin;
-      break;
-    case '#':
-      if (arg_type == type::none_type) return begin;
-      enter_state(state::hash, is_arithmetic_type(arg_type));
-      specs.alt = true;
-      ++begin;
-      break;
-    case '0':
-      enter_state(state::zero);
-      if (!is_arithmetic_type(arg_type)) {
-        if (arg_type == type::none_type) return begin;
-        throw_format_error("format specifier requires numeric argument");
-      }
-      if (specs.align == align::none) {
-        // Ignore 0 if align is specified for compatibility with std::format.
-        specs.align = align::numeric;
-        specs.fill[0] = Char('0');
-      }
-      ++begin;
-      break;
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-    case '{':
-      enter_state(state::width);
-      begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx);
-      break;
-    case '.':
-      if (arg_type == type::none_type) return begin;
-      enter_state(state::precision,
-                  in(arg_type, float_set | string_set | cstring_set));
-      begin = parse_precision(begin, end, specs.precision, specs.precision_ref,
-                              ctx);
-      break;
-    case 'L':
-      if (arg_type == type::none_type) return begin;
-      enter_state(state::locale, is_arithmetic_type(arg_type));
-      specs.localized = true;
-      ++begin;
-      break;
-    case 'd':
-      return parse_presentation_type(pres::dec, integral_set);
-    case 'o':
-      return parse_presentation_type(pres::oct, integral_set);
-    case 'x':
-      return parse_presentation_type(pres::hex_lower, integral_set);
-    case 'X':
-      return parse_presentation_type(pres::hex_upper, integral_set);
-    case 'b':
-      return parse_presentation_type(pres::bin_lower, integral_set);
-    case 'B':
-      return parse_presentation_type(pres::bin_upper, integral_set);
-    case 'a':
-      return parse_presentation_type(pres::hexfloat_lower, float_set);
-    case 'A':
-      return parse_presentation_type(pres::hexfloat_upper, float_set);
-    case 'e':
-      return parse_presentation_type(pres::exp_lower, float_set);
-    case 'E':
-      return parse_presentation_type(pres::exp_upper, float_set);
-    case 'f':
-      return parse_presentation_type(pres::fixed_lower, float_set);
-    case 'F':
-      return parse_presentation_type(pres::fixed_upper, float_set);
-    case 'g':
-      return parse_presentation_type(pres::general_lower, float_set);
-    case 'G':
-      return parse_presentation_type(pres::general_upper, float_set);
-    case 'c':
-      if (arg_type == type::bool_type)
-        throw_format_error("invalid format specifier");
-      return parse_presentation_type(pres::chr, integral_set);
-    case 's':
-      return parse_presentation_type(pres::string,
-                                     bool_set | string_set | cstring_set);
-    case 'p':
-      return parse_presentation_type(pres::pointer, pointer_set | cstring_set);
-    case '?':
-      return parse_presentation_type(pres::debug,
-                                     char_set | string_set | cstring_set);
-    case '}':
-      return begin;
-    default: {
-      if (*begin == '}') return begin;
-      // Parse fill and alignment.
-      auto fill_end = begin + code_point_length(begin);
-      if (end - fill_end <= 0) {
-        throw_format_error("invalid format specifier");
-        return begin;
-      }
-      if (*begin == '{') {
-        throw_format_error("invalid fill character '{'");
-        return begin;
-      }
-      auto align = parse_align(to_ascii(*fill_end));
-      enter_state(state::align, align != align::none);
-      specs.fill = {begin, to_unsigned(fill_end - begin)};
-      specs.align = align;
-      begin = fill_end + 1;
-    }
-    }
-    if (begin == end) return begin;
-    c = to_ascii(*begin);
-  }
-}
-
-template <typename Char, typename Handler>
-FMTQUILL_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end,
-                                           Handler&& handler) -> const Char* {
-  struct id_adapter {
-    Handler& handler;
-    int arg_id;
-
-    FMTQUILL_CONSTEXPR void on_auto() { arg_id = handler.on_arg_id(); }
-    FMTQUILL_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); }
-    FMTQUILL_CONSTEXPR void on_name(basic_string_view<Char> id) {
-      arg_id = handler.on_arg_id(id);
-    }
-  };
-
-  ++begin;
-  if (begin == end) return handler.on_error("invalid format string"), end;
-  if (*begin == '}') {
-    handler.on_replacement_field(handler.on_arg_id(), begin);
-  } else if (*begin == '{') {
-    handler.on_text(begin, begin + 1);
-  } else {
-    auto adapter = id_adapter{handler, 0};
-    begin = parse_arg_id(begin, end, adapter);
-    Char c = begin != end ? *begin : Char();
-    if (c == '}') {
-      handler.on_replacement_field(adapter.arg_id, begin);
-    } else if (c == ':') {
-      begin = handler.on_format_specs(adapter.arg_id, begin + 1, end);
-      if (begin == end || *begin != '}')
-        return handler.on_error("unknown format specifier"), end;
-    } else {
-      return handler.on_error("missing '}' in format string"), end;
-    }
-  }
-  return begin + 1;
-}
-
-template <bool IS_CONSTEXPR, typename Char, typename Handler>
-FMTQUILL_CONSTEXPR FMTQUILL_INLINE void parse_format_string(
-    basic_string_view<Char> format_str, Handler&& handler) {
-  auto begin = format_str.data();
-  auto end = begin + format_str.size();
-  if (end - begin < 32) {
-    // Use a simple loop instead of memchr for small strings.
-    const Char* p = begin;
-    while (p != end) {
-      auto c = *p++;
-      if (c == '{') {
-        handler.on_text(begin, p - 1);
-        begin = p = parse_replacement_field(p - 1, end, handler);
-      } else if (c == '}') {
-        if (p == end || *p != '}')
-          return handler.on_error("unmatched '}' in format string");
-        handler.on_text(begin, p);
-        begin = ++p;
-      }
-    }
-    handler.on_text(begin, end);
-    return;
-  }
-  struct writer {
-    FMTQUILL_CONSTEXPR void operator()(const Char* from, const Char* to) {
-      if (from == to) return;
-      for (;;) {
-        const Char* p = nullptr;
-        if (!find<IS_CONSTEXPR>(from, to, Char('}'), p))
-          return handler_.on_text(from, to);
-        ++p;
-        if (p == to || *p != '}')
-          return handler_.on_error("unmatched '}' in format string");
-        handler_.on_text(from, p);
-        from = p + 1;
-      }
-    }
-    Handler& handler_;
-  } write = {handler};
-  while (begin != end) {
-    // Doing two passes with memchr (one for '{' and another for '}') is up to
-    // 2.5x faster than the naive one-pass implementation on big format strings.
-    const Char* p = begin;
-    if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, Char('{'), p))
-      return write(begin, end);
-    write(begin, p);
-    begin = parse_replacement_field(p, end, handler);
-  }
-}
-
-template <typename T, bool = is_named_arg<T>::value> struct strip_named_arg {
-  using type = T;
-};
-template <typename T> struct strip_named_arg<T, true> {
-  using type = remove_cvref_t<decltype(T::value)>;
-};
-
-template <typename T, typename ParseContext>
-FMTQUILL_CONSTEXPR auto parse_format_specs(ParseContext& ctx)
-    -> decltype(ctx.begin()) {
-  using char_type = typename ParseContext::char_type;
-  using context = buffer_context<char_type>;
-  using mapped_type = conditional_t<
-      mapped_type_constant<T, context>::value != type::custom_type,
-      decltype(arg_mapper<context>().map(std::declval<const T&>())),
-      typename strip_named_arg<T>::type>;
-#if defined(__cpp_if_constexpr)
-  if constexpr (std::is_default_constructible<
-                    formatter<mapped_type, char_type>>::value) {
-    return formatter<mapped_type, char_type>().parse(ctx);
-  } else {
-    type_is_unformattable_for<T, char_type> _;
-    return ctx.begin();
-  }
-#else
-  return formatter<mapped_type, char_type>().parse(ctx);
-#endif
-}
-
-// Checks char specs and returns true iff the presentation type is char-like.
-template <typename Char>
-FMTQUILL_CONSTEXPR auto check_char_specs(const format_specs<Char>& specs) -> bool {
-  if (specs.type != presentation_type::none &&
-      specs.type != presentation_type::chr &&
-      specs.type != presentation_type::debug) {
-    return false;
-  }
-  if (specs.align == align::numeric || specs.sign != sign::none || specs.alt)
-    throw_format_error("invalid format specifier for char");
-  return true;
-}
-
-#if FMTQUILL_USE_NONTYPE_TEMPLATE_ARGS
-template <int N, typename T, typename... Args, typename Char>
-constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
-  if constexpr (is_statically_named_arg<T>()) {
-    if (name == T::name) return N;
-  }
-  if constexpr (sizeof...(Args) > 0)
-    return get_arg_index_by_name<N + 1, Args...>(name);
-  (void)name;  // Workaround an MSVC bug about "unused" parameter.
-  return -1;
-}
-#endif
-
-template <typename... Args, typename Char>
-FMTQUILL_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
-#if FMTQUILL_USE_NONTYPE_TEMPLATE_ARGS
-  if constexpr (sizeof...(Args) > 0)
-    return get_arg_index_by_name<0, Args...>(name);
-#endif
-  (void)name;
-  return -1;
-}
-
-template <typename Char, typename... Args> class format_string_checker {
- private:
-  using parse_context_type = compile_parse_context<Char>;
-  static constexpr int num_args = sizeof...(Args);
-
-  // Format specifier parsing function.
-  // In the future basic_format_parse_context will replace compile_parse_context
-  // here and will use is_constant_evaluated and downcasting to access the data
-  // needed for compile-time checks: https://godbolt.org/z/GvWzcTjh1.
-  using parse_func = const Char* (*)(parse_context_type&);
-
-  type types_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
-  parse_context_type context_;
-  parse_func parse_funcs_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
-
- public:
-  explicit FMTQUILL_CONSTEXPR format_string_checker(basic_string_view<Char> fmt)
-      : types_{mapped_type_constant<Args, buffer_context<Char>>::value...},
-        context_(fmt, num_args, types_),
-        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
-
-  FMTQUILL_CONSTEXPR void on_text(const Char*, const Char*) {}
-
-  FMTQUILL_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); }
-  FMTQUILL_CONSTEXPR auto on_arg_id(int id) -> int {
-    return context_.check_arg_id(id), id;
-  }
-  FMTQUILL_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
-#if FMTQUILL_USE_NONTYPE_TEMPLATE_ARGS
-    auto index = get_arg_index_by_name<Args...>(id);
-    if (index < 0) on_error("named argument is not found");
-    return index;
-#else
-    (void)id;
-    on_error("compile-time checks for named arguments require C++20 support");
-    return 0;
-#endif
-  }
-
-  FMTQUILL_CONSTEXPR void on_replacement_field(int id, const Char* begin) {
-    on_format_specs(id, begin, begin);  // Call parse() on empty specs.
-  }
-
-  FMTQUILL_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*)
-      -> const Char* {
-    context_.advance_to(begin);
-    // id >= 0 check is a workaround for gcc 10 bug (#2065).
-    return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin;
-  }
-
-  FMTQUILL_CONSTEXPR void on_error(const char* message) {
-    throw_format_error(message);
-  }
-};
-
-// Reports a compile-time error if S is not a valid format string.
-template <typename..., typename S, FMTQUILL_ENABLE_IF(!is_compile_string<S>::value)>
-FMTQUILL_INLINE void check_format_string(const S&) {
-#ifdef FMTQUILL_ENFORCE_COMPILE_STRING
-  static_assert(is_compile_string<S>::value,
-                "FMTQUILL_ENFORCE_COMPILE_STRING requires all format strings to use "
-                "FMTQUILL_STRING.");
-#endif
-}
-template <typename... Args, typename S,
-          FMTQUILL_ENABLE_IF(is_compile_string<S>::value)>
-void check_format_string(S format_str) {
-  using char_t = typename S::char_type;
-  FMTQUILL_CONSTEXPR auto s = basic_string_view<char_t>(format_str);
-  using checker = format_string_checker<char_t, remove_cvref_t<Args>...>;
-  FMTQUILL_CONSTEXPR bool error = (parse_format_string<true>(s, checker(s)), true);
-  ignore_unused(error);
-}
-
-template <typename Char = char> struct vformat_args {
-  using type = basic_format_args<
-      basic_format_context<std::back_insert_iterator<buffer<Char>>, Char>>;
-};
-template <> struct vformat_args<char> {
-  using type = format_args;
-};
-
-// Use vformat_args and avoid type_identity to keep symbols short.
-template <typename Char>
-void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
-                typename vformat_args<Char>::type args, locale_ref loc = {});
-
-FMTQUILL_API void vprint_mojibake(std::FILE*, string_view, format_args);
-#ifndef _WIN32
-inline void vprint_mojibake(std::FILE*, string_view, format_args) {}
-#endif
-}  // namespace detail
-
-FMTQUILL_BEGIN_EXPORT
-
-// A formatter specialization for natively supported types.
-template <typename T, typename Char>
-struct formatter<T, Char,
-                 enable_if_t<detail::type_constant<T, Char>::value !=
-                             detail::type::custom_type>> {
- private:
-  detail::dynamic_format_specs<Char> specs_;
-
- public:
-  template <typename ParseContext>
-  FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* {
-    auto type = detail::type_constant<T, Char>::value;
-    auto end =
-        detail::parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, type);
-    if (type == detail::type::char_type) detail::check_char_specs(specs_);
-    return end;
-  }
-
-  template <detail::type U = detail::type_constant<T, Char>::value,
-            FMTQUILL_ENABLE_IF(U == detail::type::string_type ||
-                          U == detail::type::cstring_type ||
-                          U == detail::type::char_type)>
-  FMTQUILL_CONSTEXPR void set_debug_format(bool set = true) {
-    specs_.type = set ? presentation_type::debug : presentation_type::none;
-  }
-
-  template <typename FormatContext>
-  FMTQUILL_CONSTEXPR auto format(const T& val, FormatContext& ctx) const
-      -> decltype(ctx.out());
-};
-
-template <typename Char = char> struct runtime_format_string {
-  basic_string_view<Char> str;
-};
-
-/** A compile-time format string. */
-template <typename Char, typename... Args> class basic_format_string {
- private:
-  basic_string_view<Char> str_;
-
- public:
-  template <typename S,
-            FMTQUILL_ENABLE_IF(
-                std::is_convertible<const S&, basic_string_view<Char>>::value)>
-  FMTQUILL_CONSTEVAL FMTQUILL_INLINE basic_format_string(const S& s) : str_(s) {
-    static_assert(
-        detail::count<
-            (std::is_base_of<detail::view, remove_reference_t<Args>>::value &&
-             std::is_reference<Args>::value)...>() == 0,
-        "passing views as lvalues is disallowed");
-#ifdef FMTQUILL_HAS_CONSTEVAL
-    if constexpr (detail::count_named_args<Args...>() ==
-                  detail::count_statically_named_args<Args...>()) {
-      using checker =
-          detail::format_string_checker<Char, remove_cvref_t<Args>...>;
-      detail::parse_format_string<true>(str_, checker(s));
-    }
-#else
-    detail::check_format_string<Args...>(s);
-#endif
-  }
-  basic_format_string(runtime_format_string<Char> fmt) : str_(fmt.str) {}
-
-  FMTQUILL_INLINE operator basic_string_view<Char>() const { return str_; }
-  FMTQUILL_INLINE auto get() const -> basic_string_view<Char> { return str_; }
-};
-
-#if FMTQUILL_GCC_VERSION && FMTQUILL_GCC_VERSION < 409
-// Workaround broken conversion on older gcc.
-template <typename...> using format_string = string_view;
-inline auto runtime(string_view s) -> string_view { return s; }
-#else
-template <typename... Args>
-using format_string = basic_format_string<char, type_identity_t<Args>...>;
-/**
-  \rst
-  Creates a runtime format string.
-
-  **Example**::
-
-    // Check format string at runtime instead of compile-time.
-    fmtquill::print(fmtquill::runtime("{:d}"), "I am not a number");
-  \endrst
- */
-inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; }
-#endif
-
-FMTQUILL_API auto vformat(string_view fmt, format_args args) -> std::string;
-
-/**
-  \rst
-  Formats ``args`` according to specifications in ``fmt`` and returns the result
-  as a string.
-
-  **Example**::
-
-    #include <fmt/core.h>
-    std::string message = fmtquill::format("The answer is {}.", 42);
-  \endrst
-*/
-template <typename... T>
-FMTQUILL_NODISCARD FMTQUILL_INLINE auto format(format_string<T...> fmt, T&&... args)
-    -> std::string {
-  return vformat(fmt, fmtquill::make_format_args(args...));
-}
-
-/** Formats a string and writes the output to ``out``. */
-template <typename OutputIt,
-          FMTQUILL_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt {
-  auto&& buf = detail::get_buffer<char>(out);
-  detail::vformat_to(buf, fmt, args, {});
-  return detail::get_iterator(buf, out);
-}
-
-/**
- \rst
- Formats ``args`` according to specifications in ``fmt``, writes the result to
- the output iterator ``out`` and returns the iterator past the end of the output
- range. `format_to` does not append a terminating null character.
-
- **Example**::
-
-   auto out = std::vector<char>();
-   fmtquill::format_to(std::back_inserter(out), "{}", 42);
- \endrst
- */
-template <typename OutputIt, typename... T,
-          FMTQUILL_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-FMTQUILL_INLINE auto format_to(OutputIt out, format_string<T...> fmt, T&&... args)
-    -> OutputIt {
-  return vformat_to(out, fmt, fmtquill::make_format_args(args...));
-}
-
-template <typename OutputIt> struct format_to_n_result {
-  /** Iterator past the end of the output range. */
-  OutputIt out;
-  /** Total (not truncated) output size. */
-  size_t size;
-};
-
-template <typename OutputIt, typename... T,
-          FMTQUILL_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args)
-    -> format_to_n_result<OutputIt> {
-  using traits = detail::fixed_buffer_traits;
-  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
-  detail::vformat_to(buf, fmt, args, {});
-  return {buf.out(), buf.count()};
-}
-
-/**
-  \rst
-  Formats ``args`` according to specifications in ``fmt``, writes up to ``n``
-  characters of the result to the output iterator ``out`` and returns the total
-  (not truncated) output size and the iterator past the end of the output range.
-  `format_to_n` does not append a terminating null character.
-  \endrst
- */
-template <typename OutputIt, typename... T,
-          FMTQUILL_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-FMTQUILL_INLINE auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt,
-                            T&&... args) -> format_to_n_result<OutputIt> {
-  return vformat_to_n(out, n, fmt, fmtquill::make_format_args(args...));
-}
-
-/** Returns the number of chars in the output of ``format(fmt, args...)``. */
-template <typename... T>
-FMTQUILL_NODISCARD FMTQUILL_INLINE auto formatted_size(format_string<T...> fmt,
-                                             T&&... args) -> size_t {
-  auto buf = detail::counting_buffer<>();
-  detail::vformat_to<char>(buf, fmt, fmtquill::make_format_args(args...), {});
-  return buf.count();
-}
-
-FMTQUILL_API void vprint(string_view fmt, format_args args);
-FMTQUILL_API void vprint(std::FILE* f, string_view fmt, format_args args);
-
-/**
-  \rst
-  Formats ``args`` according to specifications in ``fmt`` and writes the output
-  to ``stdout``.
-
-  **Example**::
-
-    fmtquill::print("Elapsed time: {0:.2f} seconds", 1.23);
-  \endrst
- */
-template <typename... T>
-FMTQUILL_INLINE void print(format_string<T...> fmt, T&&... args) {
-  const auto& vargs = fmtquill::make_format_args(args...);
-  return detail::is_utf8() ? vprint(fmt, vargs)
-                           : detail::vprint_mojibake(stdout, fmt, vargs);
-}
-
-/**
-  \rst
-  Formats ``args`` according to specifications in ``fmt`` and writes the
-  output to the file ``f``.
-
-  **Example**::
-
-    fmtquill::print(stderr, "Don't {}!", "panic");
-  \endrst
- */
-template <typename... T>
-FMTQUILL_INLINE void print(std::FILE* f, format_string<T...> fmt, T&&... args) {
-  const auto& vargs = fmtquill::make_format_args(args...);
-  return detail::is_utf8() ? vprint(f, fmt, vargs)
-                           : detail::vprint_mojibake(f, fmt, vargs);
-}
-
-/**
-  Formats ``args`` according to specifications in ``fmt`` and writes the
-  output to the file ``f`` followed by a newline.
- */
-template <typename... T>
-FMTQUILL_INLINE void println(std::FILE* f, format_string<T...> fmt, T&&... args) {
-  return fmtquill::print(f, "{}\n", fmtquill::format(fmt, std::forward<T>(args)...));
-}
-
-/**
-  Formats ``args`` according to specifications in ``fmt`` and writes the output
-  to ``stdout`` followed by a newline.
- */
-template <typename... T>
-FMTQUILL_INLINE void println(format_string<T...> fmt, T&&... args) {
-  return fmtquill::println(stdout, fmt, std::forward<T>(args)...);
-}
-
-FMTQUILL_END_EXPORT
-FMTQUILL_GCC_PRAGMA("GCC pop_options")
-FMTQUILL_END_NAMESPACE
-
-#endif  // FMTQUILL_CORE_H_
diff --git a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/format-inl.h b/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/format-inl.h
deleted file mode 100644
index 919c512..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/format-inl.h
+++ /dev/null
@@ -1,1678 +0,0 @@
-// Formatting library for C++ - implementation
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMTQUILL_FORMAT_INL_H_
-#define FMTQUILL_FORMAT_INL_H_
-
-#include <algorithm>
-#include <cerrno>  // errno
-#include <climits>
-#include <cmath>
-#include <exception>
-
-#ifndef FMTQUILL_STATIC_THOUSANDS_SEPARATOR
-#  include <locale>
-#endif
-
-#if defined(_WIN32) && !defined(FMTQUILL_WINDOWS_NO_WCHAR)
-#  include <io.h>  // _isatty
-#endif
-
-#include "format.h"
-
-FMTQUILL_BEGIN_NAMESPACE
-namespace detail {
-
-FMTQUILL_FUNC void assert_fail(const char* file, int line, const char* message) {
-  // Use unchecked std::fprintf to avoid triggering another assertion when
-  // writing to stderr fails
-  std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
-  // Chosen instead of std::abort to satisfy Clang in CUDA mode during device
-  // code pass.
-  std::terminate();
-}
-
-FMTQUILL_FUNC void throw_format_error(const char* message) {
-  FMTQUILL_THROW(format_error(message));
-}
-
-FMTQUILL_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
-                                string_view message) noexcept {
-  // Report error code making sure that the output fits into
-  // inline_buffer_size to avoid dynamic memory allocation and potential
-  // bad_alloc.
-  out.try_resize(0);
-  static const char SEP[] = ": ";
-  static const char ERROR_STR[] = "error ";
-  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
-  size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
-  auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code);
-  if (detail::is_negative(error_code)) {
-    abs_value = 0 - abs_value;
-    ++error_code_size;
-  }
-  error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
-  auto it = buffer_appender<char>(out);
-  if (message.size() <= inline_buffer_size - error_code_size)
-    fmtquill::format_to(it, FMTQUILL_STRING("{}{}"), message, SEP);
-  fmtquill::format_to(it, FMTQUILL_STRING("{}{}"), ERROR_STR, error_code);
-  FMTQUILL_ASSERT(out.size() <= inline_buffer_size, "");
-}
-
-FMTQUILL_FUNC void report_error(format_func func, int error_code,
-                           const char* message) noexcept {
-  memory_buffer full_message;
-  func(full_message, error_code, message);
-  // Don't use fwrite_fully because the latter may throw.
-  if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0)
-    std::fputc('\n', stderr);
-}
-
-// A wrapper around fwrite that throws on error.
-inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) {
-  size_t written = std::fwrite(ptr, 1, count, stream);
-  if (written < count)
-    FMTQUILL_THROW(system_error(errno, FMTQUILL_STRING("cannot write to file")));
-}
-
-#ifndef FMTQUILL_STATIC_THOUSANDS_SEPARATOR
-template <typename Locale>
-locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-}
-
-template <typename Locale> auto locale_ref::get() const -> Locale {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
-}
-
-template <typename Char>
-FMTQUILL_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
-  auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
-  auto grouping = facet.grouping();
-  auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
-  return {std::move(grouping), thousands_sep};
-}
-template <typename Char>
-FMTQUILL_FUNC auto decimal_point_impl(locale_ref loc) -> Char {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
-      .decimal_point();
-}
-#else
-template <typename Char>
-FMTQUILL_FUNC auto thousands_sep_impl(locale_ref) -> thousands_sep_result<Char> {
-  return {"\03", FMTQUILL_STATIC_THOUSANDS_SEPARATOR};
-}
-template <typename Char> FMTQUILL_FUNC Char decimal_point_impl(locale_ref) {
-  return '.';
-}
-#endif
-
-FMTQUILL_FUNC auto write_loc(appender out, loc_value value,
-                        const format_specs<>& specs, locale_ref loc) -> bool {
-#ifndef FMTQUILL_STATIC_THOUSANDS_SEPARATOR
-  auto locale = loc.get<std::locale>();
-  // We cannot use the num_put<char> facet because it may produce output in
-  // a wrong encoding.
-  using facet = format_facet<std::locale>;
-  if (std::has_facet<facet>(locale))
-    return std::use_facet<facet>(locale).put(out, value, specs);
-  return facet(locale).put(out, value, specs);
-#endif
-  return false;
-}
-}  // namespace detail
-
-template <typename Locale> typename Locale::id format_facet<Locale>::id;
-
-#ifndef FMTQUILL_STATIC_THOUSANDS_SEPARATOR
-template <typename Locale> format_facet<Locale>::format_facet(Locale& loc) {
-  auto& numpunct = std::use_facet<std::numpunct<char>>(loc);
-  grouping_ = numpunct.grouping();
-  if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep());
-}
-
-template <>
-FMTQUILL_API FMTQUILL_FUNC auto format_facet<std::locale>::do_put(
-    appender out, loc_value val, const format_specs<>& specs) const -> bool {
-  return val.visit(
-      detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_});
-}
-#endif
-
-FMTQUILL_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args)
-    -> std::system_error {
-  auto ec = std::error_code(error_code, std::generic_category());
-  return std::system_error(ec, vformat(fmt, args));
-}
-
-namespace detail {
-
-template <typename F>
-inline auto operator==(basic_fp<F> x, basic_fp<F> y) -> bool {
-  return x.f == y.f && x.e == y.e;
-}
-
-// Compilers should be able to optimize this into the ror instruction.
-FMTQUILL_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t {
-  r &= 31;
-  return (n >> r) | (n << (32 - r));
-}
-FMTQUILL_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t {
-  r &= 63;
-  return (n >> r) | (n << (64 - r));
-}
-
-// Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
-namespace dragonbox {
-// Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a
-// 64-bit unsigned integer.
-inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t {
-  return umul128_upper64(static_cast<uint64_t>(x) << 32, y);
-}
-
-// Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a
-// 128-bit unsigned integer.
-inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept
-    -> uint128_fallback {
-  uint64_t high = x * y.high();
-  uint128_fallback high_low = umul128(x, y.low());
-  return {high + high_low.high(), high_low.low()};
-}
-
-// Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
-// 64-bit unsigned integer.
-inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t {
-  return x * y;
-}
-
-// Various fast log computations.
-inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int {
-  FMTQUILL_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
-  return (e * 631305 - 261663) >> 21;
-}
-
-FMTQUILL_INLINE_VARIABLE constexpr struct {
-  uint32_t divisor;
-  int shift_amount;
-} div_small_pow10_infos[] = {{10, 16}, {100, 16}};
-
-// Replaces n by floor(n / pow(10, N)) returning true if and only if n is
-// divisible by pow(10, N).
-// Precondition: n <= pow(10, N + 1).
-template <int N>
-auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool {
-  // The numbers below are chosen such that:
-  //   1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100,
-  //   2. nm mod 2^k < m if and only if n is divisible by d,
-  // where m is magic_number, k is shift_amount
-  // and d is divisor.
-  //
-  // Item 1 is a common technique of replacing division by a constant with
-  // multiplication, see e.g. "Division by Invariant Integers Using
-  // Multiplication" by Granlund and Montgomery (1994). magic_number (m) is set
-  // to ceil(2^k/d) for large enough k.
-  // The idea for item 2 originates from Schubfach.
-  constexpr auto info = div_small_pow10_infos[N - 1];
-  FMTQUILL_ASSERT(n <= info.divisor * 10, "n is too large");
-  constexpr uint32_t magic_number =
-      (1u << info.shift_amount) / info.divisor + 1;
-  n *= magic_number;
-  const uint32_t comparison_mask = (1u << info.shift_amount) - 1;
-  bool result = (n & comparison_mask) < magic_number;
-  n >>= info.shift_amount;
-  return result;
-}
-
-// Computes floor(n / pow(10, N)) for small n and N.
-// Precondition: n <= pow(10, N + 1).
-template <int N> auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t {
-  constexpr auto info = div_small_pow10_infos[N - 1];
-  FMTQUILL_ASSERT(n <= info.divisor * 10, "n is too large");
-  constexpr uint32_t magic_number =
-      (1u << info.shift_amount) / info.divisor + 1;
-  return (n * magic_number) >> info.shift_amount;
-}
-
-// Computes floor(n / 10^(kappa + 1)) (float)
-inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t {
-  // 1374389535 = ceil(2^37/100)
-  return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37);
-}
-// Computes floor(n / 10^(kappa + 1)) (double)
-inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t {
-  // 2361183241434822607 = ceil(2^(64+7)/1000)
-  return umul128_upper64(n, 2361183241434822607ull) >> 7;
-}
-
-// Various subroutines using pow10 cache
-template <typename T> struct cache_accessor;
-
-template <> struct cache_accessor<float> {
-  using carrier_uint = float_info<float>::carrier_uint;
-  using cache_entry_type = uint64_t;
-
-  static auto get_cached_power(int k) noexcept -> uint64_t {
-    FMTQUILL_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k,
-               "k is out of range");
-    static constexpr const uint64_t pow10_significands[] = {
-        0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f,
-        0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb,
-        0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28,
-        0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb,
-        0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a,
-        0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810,
-        0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff,
-        0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd,
-        0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424,
-        0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b,
-        0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000,
-        0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000,
-        0xc350000000000000, 0xf424000000000000, 0x9896800000000000,
-        0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000,
-        0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000,
-        0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000,
-        0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000,
-        0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000,
-        0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0,
-        0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940985,
-        0xa18f07d736b90be6, 0xc9f2c9cd04674edf, 0xfc6f7c4045812297,
-        0x9dc5ada82b70b59e, 0xc5371912364ce306, 0xf684df56c3e01bc7,
-        0x9a130b963a6c115d, 0xc097ce7bc90715b4, 0xf0bdc21abb48db21,
-        0x96769950b50d88f5, 0xbc143fa4e250eb32, 0xeb194f8e1ae525fe,
-        0x92efd1b8d0cf37bf, 0xb7abc627050305ae, 0xe596b7b0c643c71a,
-        0x8f7e32ce7bea5c70, 0xb35dbf821ae4f38c, 0xe0352f62a19e306f};
-    return pow10_significands[k - float_info<float>::min_k];
-  }
-
-  struct compute_mul_result {
-    carrier_uint result;
-    bool is_integer;
-  };
-  struct compute_mul_parity_result {
-    bool parity;
-    bool is_integer;
-  };
-
-  static auto compute_mul(carrier_uint u,
-                          const cache_entry_type& cache) noexcept
-      -> compute_mul_result {
-    auto r = umul96_upper64(u, cache);
-    return {static_cast<carrier_uint>(r >> 32),
-            static_cast<carrier_uint>(r) == 0};
-  }
-
-  static auto compute_delta(const cache_entry_type& cache, int beta) noexcept
-      -> uint32_t {
-    return static_cast<uint32_t>(cache >> (64 - 1 - beta));
-  }
-
-  static auto compute_mul_parity(carrier_uint two_f,
-                                 const cache_entry_type& cache,
-                                 int beta) noexcept
-      -> compute_mul_parity_result {
-    FMTQUILL_ASSERT(beta >= 1, "");
-    FMTQUILL_ASSERT(beta < 64, "");
-
-    auto r = umul96_lower64(two_f, cache);
-    return {((r >> (64 - beta)) & 1) != 0,
-            static_cast<uint32_t>(r >> (32 - beta)) == 0};
-  }
-
-  static auto compute_left_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
-    return static_cast<carrier_uint>(
-        (cache - (cache >> (num_significand_bits<float>() + 2))) >>
-        (64 - num_significand_bits<float>() - 1 - beta));
-  }
-
-  static auto compute_right_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
-    return static_cast<carrier_uint>(
-        (cache + (cache >> (num_significand_bits<float>() + 1))) >>
-        (64 - num_significand_bits<float>() - 1 - beta));
-  }
-
-  static auto compute_round_up_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
-    return (static_cast<carrier_uint>(
-                cache >> (64 - num_significand_bits<float>() - 2 - beta)) +
-            1) /
-           2;
-  }
-};
-
-template <> struct cache_accessor<double> {
-  using carrier_uint = float_info<double>::carrier_uint;
-  using cache_entry_type = uint128_fallback;
-
-  static auto get_cached_power(int k) noexcept -> uint128_fallback {
-    FMTQUILL_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
-               "k is out of range");
-
-    static constexpr const uint128_fallback pow10_significands[] = {
-#if FMTQUILL_USE_FULL_CACHE_DRAGONBOX
-      {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
-      {0x9faacf3df73609b1, 0x77b191618c54e9ad},
-      {0xc795830d75038c1d, 0xd59df5b9ef6a2418},
-      {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e},
-      {0x9becce62836ac577, 0x4ee367f9430aec33},
-      {0xc2e801fb244576d5, 0x229c41f793cda740},
-      {0xf3a20279ed56d48a, 0x6b43527578c11110},
-      {0x9845418c345644d6, 0x830a13896b78aaaa},
-      {0xbe5691ef416bd60c, 0x23cc986bc656d554},
-      {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9},
-      {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa},
-      {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54},
-      {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69},
-      {0x91376c36d99995be, 0x23100809b9c21fa2},
-      {0xb58547448ffffb2d, 0xabd40a0c2832a78b},
-      {0xe2e69915b3fff9f9, 0x16c90c8f323f516d},
-      {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4},
-      {0xb1442798f49ffb4a, 0x99cd11cfdf41779d},
-      {0xdd95317f31c7fa1d, 0x40405643d711d584},
-      {0x8a7d3eef7f1cfc52, 0x482835ea666b2573},
-      {0xad1c8eab5ee43b66, 0xda3243650005eed0},
-      {0xd863b256369d4a40, 0x90bed43e40076a83},
-      {0x873e4f75e2224e68, 0x5a7744a6e804a292},
-      {0xa90de3535aaae202, 0x711515d0a205cb37},
-      {0xd3515c2831559a83, 0x0d5a5b44ca873e04},
-      {0x8412d9991ed58091, 0xe858790afe9486c3},
-      {0xa5178fff668ae0b6, 0x626e974dbe39a873},
-      {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
-      {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a},
-      {0xa139029f6a239f72, 0x1c1fffc1ebc44e81},
-      {0xc987434744ac874e, 0xa327ffb266b56221},
-      {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9},
-      {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa},
-      {0xc4ce17b399107c22, 0xcb550fb4384d21d4},
-      {0xf6019da07f549b2b, 0x7e2a53a146606a49},
-      {0x99c102844f94e0fb, 0x2eda7444cbfc426e},
-      {0xc0314325637a1939, 0xfa911155fefb5309},
-      {0xf03d93eebc589f88, 0x793555ab7eba27cb},
-      {0x96267c7535b763b5, 0x4bc1558b2f3458df},
-      {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17},
-      {0xea9c227723ee8bcb, 0x465e15a979c1cadd},
-      {0x92a1958a7675175f, 0x0bfacd89ec191eca},
-      {0xb749faed14125d36, 0xcef980ec671f667c},
-      {0xe51c79a85916f484, 0x82b7e12780e7401b},
-      {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811},
-      {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16},
-      {0xdfbdcece67006ac9, 0x67a791e093e1d49b},
-      {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1},
-      {0xaecc49914078536d, 0x58fae9f773886e19},
-      {0xda7f5bf590966848, 0xaf39a475506a899f},
-      {0x888f99797a5e012d, 0x6d8406c952429604},
-      {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84},
-      {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65},
-      {0x855c3be0a17fcd26, 0x5cf2eea09a550680},
-      {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
-      {0xd0601d8efc57b08b, 0xf13b94daf124da27},
-      {0x823c12795db6ce57, 0x76c53d08d6b70859},
-      {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f},
-      {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a},
-      {0xfe5d54150b090b02, 0xd3f93b35435d7c4d},
-      {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0},
-      {0xc6b8e9b0709f109a, 0x359ab6419ca1091c},
-      {0xf867241c8cc6d4c0, 0xc30163d203c94b63},
-      {0x9b407691d7fc44f8, 0x79e0de63425dcf1e},
-      {0xc21094364dfb5636, 0x985915fc12f542e5},
-      {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e},
-      {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43},
-      {0xbd8430bd08277231, 0x50c6ff782a838354},
-      {0xece53cec4a314ebd, 0xa4f8bf5635246429},
-      {0x940f4613ae5ed136, 0x871b7795e136be9a},
-      {0xb913179899f68584, 0x28e2557b59846e40},
-      {0xe757dd7ec07426e5, 0x331aeada2fe589d0},
-      {0x9096ea6f3848984f, 0x3ff0d2c85def7622},
-      {0xb4bca50b065abe63, 0x0fed077a756b53aa},
-      {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895},
-      {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d},
-      {0xb080392cc4349dec, 0xbd8d794d96aacfb4},
-      {0xdca04777f541c567, 0xecf0d7a0fc5583a1},
-      {0x89e42caaf9491b60, 0xf41686c49db57245},
-      {0xac5d37d5b79b6239, 0x311c2875c522ced6},
-      {0xd77485cb25823ac7, 0x7d633293366b828c},
-      {0x86a8d39ef77164bc, 0xae5dff9c02033198},
-      {0xa8530886b54dbdeb, 0xd9f57f830283fdfd},
-      {0xd267caa862a12d66, 0xd072df63c324fd7c},
-      {0x8380dea93da4bc60, 0x4247cb9e59f71e6e},
-      {0xa46116538d0deb78, 0x52d9be85f074e609},
-      {0xcd795be870516656, 0x67902e276c921f8c},
-      {0x806bd9714632dff6, 0x00ba1cd8a3db53b7},
-      {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5},
-      {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce},
-      {0xfad2a4b13d1b5d6c, 0x796b805720085f82},
-      {0x9cc3a6eec6311a63, 0xcbe3303674053bb1},
-      {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d},
-      {0xf4f1b4d515acb93b, 0xee92fb5515482d45},
-      {0x991711052d8bf3c5, 0x751bdd152d4d1c4b},
-      {0xbf5cd54678eef0b6, 0xd262d45a78a0635e},
-      {0xef340a98172aace4, 0x86fb897116c87c35},
-      {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1},
-      {0xbae0a846d2195712, 0x8974836059cca10a},
-      {0xe998d258869facd7, 0x2bd1a438703fc94c},
-      {0x91ff83775423cc06, 0x7b6306a34627ddd0},
-      {0xb67f6455292cbf08, 0x1a3bc84c17b1d543},
-      {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94},
-      {0x8e938662882af53e, 0x547eb47b7282ee9d},
-      {0xb23867fb2a35b28d, 0xe99e619a4f23aa44},
-      {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5},
-      {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05},
-      {0xae0b158b4738705e, 0x9624ab50b148d446},
-      {0xd98ddaee19068c76, 0x3badd624dd9b0958},
-      {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7},
-      {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d},
-      {0xd47487cc8470652b, 0x7647c32000696720},
-      {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074},
-      {0xa5fb0a17c777cf09, 0xf468107100525891},
-      {0xcf79cc9db955c2cc, 0x7182148d4066eeb5},
-      {0x81ac1fe293d599bf, 0xc6f14cd848405531},
-      {0xa21727db38cb002f, 0xb8ada00e5a506a7d},
-      {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d},
-      {0xfd442e4688bd304a, 0x908f4a166d1da664},
-      {0x9e4a9cec15763e2e, 0x9a598e4e043287ff},
-      {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe},
-      {0xf7549530e188c128, 0xd12bee59e68ef47d},
-      {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf},
-      {0xc13a148e3032d6e7, 0xe36a52363c1faf02},
-      {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2},
-      {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba},
-      {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8},
-      {0xebdf661791d60f56, 0x111b495b3464ad22},
-      {0x936b9fcebb25c995, 0xcab10dd900beec35},
-      {0xb84687c269ef3bfb, 0x3d5d514f40eea743},
-      {0xe65829b3046b0afa, 0x0cb4a5a3112a5113},
-      {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac},
-      {0xb3f4e093db73a093, 0x59ed216765690f57},
-      {0xe0f218b8d25088b8, 0x306869c13ec3532d},
-      {0x8c974f7383725573, 0x1e414218c73a13fc},
-      {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
-      {0xdbac6c247d62a583, 0xdf45f746b74abf3a},
-      {0x894bc396ce5da772, 0x6b8bba8c328eb784},
-      {0xab9eb47c81f5114f, 0x066ea92f3f326565},
-      {0xd686619ba27255a2, 0xc80a537b0efefebe},
-      {0x8613fd0145877585, 0xbd06742ce95f5f37},
-      {0xa798fc4196e952e7, 0x2c48113823b73705},
-      {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6},
-      {0x82ef85133de648c4, 0x9a984d73dbe722fc},
-      {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb},
-      {0xcc963fee10b7d1b3, 0x318df905079926a9},
-      {0xffbbcfe994e5c61f, 0xfdf17746497f7053},
-      {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634},
-      {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1},
-      {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1},
-      {0x9c1661a651213e2d, 0x06bea10ca65c084f},
-      {0xc31bfa0fe5698db8, 0x486e494fcff30a63},
-      {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb},
-      {0x986ddb5c6b3a76b7, 0xf89629465a75e01d},
-      {0xbe89523386091465, 0xf6bbb397f1135824},
-      {0xee2ba6c0678b597f, 0x746aa07ded582e2d},
-      {0x94db483840b717ef, 0xa8c2a44eb4571cdd},
-      {0xba121a4650e4ddeb, 0x92f34d62616ce414},
-      {0xe896a0d7e51e1566, 0x77b020baf9c81d18},
-      {0x915e2486ef32cd60, 0x0ace1474dc1d122f},
-      {0xb5b5ada8aaff80b8, 0x0d819992132456bb},
-      {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a},
-      {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
-      {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3},
-      {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf},
-      {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c},
-      {0xad4ab7112eb3929d, 0x86c16c98d2c953c7},
-      {0xd89d64d57a607744, 0xe871c7bf077ba8b8},
-      {0x87625f056c7c4a8b, 0x11471cd764ad4973},
-      {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0},
-      {0xd389b47879823479, 0x4aff1d108d4ec2c4},
-      {0x843610cb4bf160cb, 0xcedf722a585139bb},
-      {0xa54394fe1eedb8fe, 0xc2974eb4ee658829},
-      {0xce947a3da6a9273e, 0x733d226229feea33},
-      {0x811ccc668829b887, 0x0806357d5a3f5260},
-      {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8},
-      {0xc9bcff6034c13052, 0xfc89b393dd02f0b6},
-      {0xfc2c3f3841f17c67, 0xbbac2078d443ace3},
-      {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e},
-      {0xc5029163f384a931, 0x0a9e795e65d4df12},
-      {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6},
-      {0x99ea0196163fa42e, 0x504bced1bf8e4e46},
-      {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7},
-      {0xf07da27a82c37088, 0x5d767327bb4e5a4d},
-      {0x964e858c91ba2655, 0x3a6a07f8d510f870},
-      {0xbbe226efb628afea, 0x890489f70a55368c},
-      {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f},
-      {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e},
-      {0xb77ada0617e3bbcb, 0x09ce6ebb40173745},
-      {0xe55990879ddcaabd, 0xcc420a6a101d0516},
-      {0x8f57fa54c2a9eab6, 0x9fa946824a12232e},
-      {0xb32df8e9f3546564, 0x47939822dc96abfa},
-      {0xdff9772470297ebd, 0x59787e2b93bc56f8},
-      {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b},
-      {0xaefae51477a06b03, 0xede622920b6b23f2},
-      {0xdab99e59958885c4, 0xe95fab368e45ecee},
-      {0x88b402f7fd75539b, 0x11dbcb0218ebb415},
-      {0xaae103b5fcd2a881, 0xd652bdc29f26a11a},
-      {0xd59944a37c0752a2, 0x4be76d3346f04960},
-      {0x857fcae62d8493a5, 0x6f70a4400c562ddc},
-      {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953},
-      {0xd097ad07a71f26b2, 0x7e2000a41346a7a8},
-      {0x825ecc24c873782f, 0x8ed400668c0c28c9},
-      {0xa2f67f2dfa90563b, 0x728900802f0f32fb},
-      {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba},
-      {0xfea126b7d78186bc, 0xe2f610c84987bfa9},
-      {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca},
-      {0xc6ede63fa05d3143, 0x91503d1c79720dbc},
-      {0xf8a95fcf88747d94, 0x75a44c6397ce912b},
-      {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb},
-      {0xc24452da229b021b, 0xfbe85badce996169},
-      {0xf2d56790ab41c2a2, 0xfae27299423fb9c4},
-      {0x97c560ba6b0919a5, 0xdccd879fc967d41b},
-      {0xbdb6b8e905cb600f, 0x5400e987bbc1c921},
-      {0xed246723473e3813, 0x290123e9aab23b69},
-      {0x9436c0760c86e30b, 0xf9a0b6720aaf6522},
-      {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
-      {0xe7958cb87392c2c2, 0xb60b1d1230b20e05},
-      {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3},
-      {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4},
-      {0xe2280b6c20dd5232, 0x25c6da63c38de1b1},
-      {0x8d590723948a535f, 0x579c487e5a38ad0f},
-      {0xb0af48ec79ace837, 0x2d835a9df0c6d852},
-      {0xdcdb1b2798182244, 0xf8e431456cf88e66},
-      {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900},
-      {0xac8b2d36eed2dac5, 0xe272467e3d222f40},
-      {0xd7adf884aa879177, 0x5b0ed81dcc6abb10},
-      {0x86ccbb52ea94baea, 0x98e947129fc2b4ea},
-      {0xa87fea27a539e9a5, 0x3f2398d747b36225},
-      {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae},
-      {0x83a3eeeef9153e89, 0x1953cf68300424ad},
-      {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8},
-      {0xcdb02555653131b6, 0x3792f412cb06794e},
-      {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1},
-      {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5},
-      {0xc8de047564d20a8b, 0xf245825a5a445276},
-      {0xfb158592be068d2e, 0xeed6e2f0f0d56713},
-      {0x9ced737bb6c4183d, 0x55464dd69685606c},
-      {0xc428d05aa4751e4c, 0xaa97e14c3c26b887},
-      {0xf53304714d9265df, 0xd53dd99f4b3066a9},
-      {0x993fe2c6d07b7fab, 0xe546a8038efe402a},
-      {0xbf8fdb78849a5f96, 0xde98520472bdd034},
-      {0xef73d256a5c0f77c, 0x963e66858f6d4441},
-      {0x95a8637627989aad, 0xdde7001379a44aa9},
-      {0xbb127c53b17ec159, 0x5560c018580d5d53},
-      {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7},
-      {0x9226712162ab070d, 0xcab3961304ca70e9},
-      {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23},
-      {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b},
-      {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243},
-      {0xb267ed1940f1c61c, 0x55f038b237591ed4},
-      {0xdf01e85f912e37a3, 0x6b6c46dec52f6689},
-      {0x8b61313bbabce2c6, 0x2323ac4b3b3da016},
-      {0xae397d8aa96c1b77, 0xabec975e0a0d081b},
-      {0xd9c7dced53c72255, 0x96e7bd358c904a22},
-      {0x881cea14545c7575, 0x7e50d64177da2e55},
-      {0xaa242499697392d2, 0xdde50bd1d5d0b9ea},
-      {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865},
-      {0x84ec3c97da624ab4, 0xbd5af13bef0b113f},
-      {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f},
-      {0xcfb11ead453994ba, 0x67de18eda5814af3},
-      {0x81ceb32c4b43fcf4, 0x80eacf948770ced8},
-      {0xa2425ff75e14fc31, 0xa1258379a94d028e},
-      {0xcad2f7f5359a3b3e, 0x096ee45813a04331},
-      {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd},
-      {0x9e74d1b791e07e48, 0x775ea264cf55347e},
-      {0xc612062576589dda, 0x95364afe032a819e},
-      {0xf79687aed3eec551, 0x3a83ddbd83f52205},
-      {0x9abe14cd44753b52, 0xc4926a9672793543},
-      {0xc16d9a0095928a27, 0x75b7053c0f178294},
-      {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
-      {0x971da05074da7bee, 0xd3f6fc16ebca5e04},
-      {0xbce5086492111aea, 0x88f4bb1ca6bcf585},
-      {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6},
-      {0x9392ee8e921d5d07, 0x3aff322e62439fd0},
-      {0xb877aa3236a4b449, 0x09befeb9fad487c3},
-      {0xe69594bec44de15b, 0x4c2ebe687989a9b4},
-      {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11},
-      {0xb424dc35095cd80f, 0x538484c19ef38c95},
-      {0xe12e13424bb40e13, 0x2865a5f206b06fba},
-      {0x8cbccc096f5088cb, 0xf93f87b7442e45d4},
-      {0xafebff0bcb24aafe, 0xf78f69a51539d749},
-      {0xdbe6fecebdedd5be, 0xb573440e5a884d1c},
-      {0x89705f4136b4a597, 0x31680a88f8953031},
-      {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e},
-      {0xd6bf94d5e57a42bc, 0x3d32907604691b4d},
-      {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110},
-      {0xa7c5ac471b478423, 0x0fcf80dc33721d54},
-      {0xd1b71758e219652b, 0xd3c36113404ea4a9},
-      {0x83126e978d4fdf3b, 0x645a1cac083126ea},
-      {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4},
-      {0xcccccccccccccccc, 0xcccccccccccccccd},
-      {0x8000000000000000, 0x0000000000000000},
-      {0xa000000000000000, 0x0000000000000000},
-      {0xc800000000000000, 0x0000000000000000},
-      {0xfa00000000000000, 0x0000000000000000},
-      {0x9c40000000000000, 0x0000000000000000},
-      {0xc350000000000000, 0x0000000000000000},
-      {0xf424000000000000, 0x0000000000000000},
-      {0x9896800000000000, 0x0000000000000000},
-      {0xbebc200000000000, 0x0000000000000000},
-      {0xee6b280000000000, 0x0000000000000000},
-      {0x9502f90000000000, 0x0000000000000000},
-      {0xba43b74000000000, 0x0000000000000000},
-      {0xe8d4a51000000000, 0x0000000000000000},
-      {0x9184e72a00000000, 0x0000000000000000},
-      {0xb5e620f480000000, 0x0000000000000000},
-      {0xe35fa931a0000000, 0x0000000000000000},
-      {0x8e1bc9bf04000000, 0x0000000000000000},
-      {0xb1a2bc2ec5000000, 0x0000000000000000},
-      {0xde0b6b3a76400000, 0x0000000000000000},
-      {0x8ac7230489e80000, 0x0000000000000000},
-      {0xad78ebc5ac620000, 0x0000000000000000},
-      {0xd8d726b7177a8000, 0x0000000000000000},
-      {0x878678326eac9000, 0x0000000000000000},
-      {0xa968163f0a57b400, 0x0000000000000000},
-      {0xd3c21bcecceda100, 0x0000000000000000},
-      {0x84595161401484a0, 0x0000000000000000},
-      {0xa56fa5b99019a5c8, 0x0000000000000000},
-      {0xcecb8f27f4200f3a, 0x0000000000000000},
-      {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, 0xbff8f10e7a8921a5},
-      {0xa321f2d7226895c7, 0xaff72d52192b6a0e},
-      {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491},
-      {0xfee50b7025c36a08, 0x02f236d04753d5b5},
-      {0x9f4f2726179a2245, 0x01d762422c946591},
-      {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6},
-      {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3},
-      {0x9b934c3b330c8577, 0x63cc55f49f88eb30},
-      {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc},
-      {0xf316271c7fc3908a, 0x8bef464e3945ef7b},
-      {0x97edd871cfda3a56, 0x97758bf0e3cbb5ad},
-      {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318},
-      {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde},
-      {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b},
-      {0xb975d6b6ee39e436, 0xb3e2fd538e122b45},
-      {0xe7d34c64a9c85d44, 0x60dbbca87196b617},
-      {0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce},
-      {0xb51d13aea4a488dd, 0x6babab6398bdbe42},
-      {0xe264589a4dcdab14, 0xc696963c7eed2dd2},
-      {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3},
-      {0xb0de65388cc8ada8, 0x3b25a55f43294bcc},
-      {0xdd15fe86affad912, 0x49ef0eb713f39ebf},
-      {0x8a2dbf142dfcc7ab, 0x6e3569326c784338},
-      {0xacb92ed9397bf996, 0x49c2c37f07965405},
-      {0xd7e77a8f87daf7fb, 0xdc33745ec97be907},
-      {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4},
-      {0xa8acd7c0222311bc, 0xc40832ea0d68ce0d},
-      {0xd2d80db02aabd62b, 0xf50a3fa490c30191},
-      {0x83c7088e1aab65db, 0x792667c6da79e0fb},
-      {0xa4b8cab1a1563f52, 0x577001b891185939},
-      {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
-      {0x80b05e5ac60b6178, 0x544f8158315b05b5},
-      {0xa0dc75f1778e39d6, 0x696361ae3db1c722},
-      {0xc913936dd571c84c, 0x03bc3a19cd1e38ea},
-      {0xfb5878494ace3a5f, 0x04ab48a04065c724},
-      {0x9d174b2dcec0e47b, 0x62eb0d64283f9c77},
-      {0xc45d1df942711d9a, 0x3ba5d0bd324f8395},
-      {0xf5746577930d6500, 0xca8f44ec7ee3647a},
-      {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc},
-      {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f},
-      {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f},
-      {0x95d04aee3b80ece5, 0xbba1f1d158724a13},
-      {0xbb445da9ca61281f, 0x2a8a6e45ae8edc98},
-      {0xea1575143cf97226, 0xf52d09d71a3293be},
-      {0x924d692ca61be758, 0x593c2626705f9c57},
-      {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d},
-      {0xe498f455c38b997a, 0x0b6dfb9c0f956448},
-      {0x8edf98b59a373fec, 0x4724bd4189bd5ead},
-      {0xb2977ee300c50fe7, 0x58edec91ec2cb658},
-      {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee},
-      {0x8b865b215899f46c, 0xbd79e0d20082ee75},
-      {0xae67f1e9aec07187, 0xecd8590680a3aa12},
-      {0xda01ee641a708de9, 0xe80e6f4820cc9496},
-      {0x884134fe908658b2, 0x3109058d147fdcde},
-      {0xaa51823e34a7eede, 0xbd4b46f0599fd416},
-      {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b},
-      {0x850fadc09923329e, 0x03e2cf6bc604ddb1},
-      {0xa6539930bf6bff45, 0x84db8346b786151d},
-      {0xcfe87f7cef46ff16, 0xe612641865679a64},
-      {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f},
-      {0xa26da3999aef7749, 0xe3be5e330f38f09e},
-      {0xcb090c8001ab551c, 0x5cadf5bfd3072cc6},
-      {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7},
-      {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb},
-      {0xc646d63501a1511d, 0xb281e1fd541501b9},
-      {0xf7d88bc24209a565, 0x1f225a7ca91a4227},
-      {0x9ae757596946075f, 0x3375788de9b06959},
-      {0xc1a12d2fc3978937, 0x0052d6b1641c83af},
-      {0xf209787bb47d6b84, 0xc0678c5dbd23a49b},
-      {0x9745eb4d50ce6332, 0xf840b7ba963646e1},
-      {0xbd176620a501fbff, 0xb650e5a93bc3d899},
-      {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf},
-      {0x93ba47c980e98cdf, 0xc66f336c36b10138},
-      {0xb8a8d9bbe123f017, 0xb80b0047445d4185},
-      {0xe6d3102ad96cec1d, 0xa60dc059157491e6},
-      {0x9043ea1ac7e41392, 0x87c89837ad68db30},
-      {0xb454e4a179dd1877, 0x29babe4598c311fc},
-      {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b},
-      {0x8ce2529e2734bb1d, 0x1899e4a65f58660d},
-      {0xb01ae745b101e9e4, 0x5ec05dcff72e7f90},
-      {0xdc21a1171d42645d, 0x76707543f4fa1f74},
-      {0x899504ae72497eba, 0x6a06494a791c53a9},
-      {0xabfa45da0edbde69, 0x0487db9d17636893},
-      {0xd6f8d7509292d603, 0x45a9d2845d3c42b7},
-      {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
-      {0xa7f26836f282b732, 0x8e6cac7768d7141f},
-      {0xd1ef0244af2364ff, 0x3207d795430cd927},
-      {0x8335616aed761f1f, 0x7f44e6bd49e807b9},
-      {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7},
-      {0xcd036837130890a1, 0x36dba887c37a8c10},
-      {0x802221226be55a64, 0xc2494954da2c978a},
-      {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d},
-      {0xc83553c5c8965d3d, 0x6f92829494e5acc8},
-      {0xfa42a8b73abbf48c, 0xcb772339ba1f17fa},
-      {0x9c69a97284b578d7, 0xff2a760414536efc},
-      {0xc38413cf25e2d70d, 0xfef5138519684abb},
-      {0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a},
-      {0x98bf2f79d5993802, 0xef2f773ffbd97a62},
-      {0xbeeefb584aff8603, 0xaafb550ffacfd8fb},
-      {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39},
-      {0x952ab45cfa97a0b2, 0xdd945a747bf26184},
-      {0xba756174393d88df, 0x94f971119aeef9e5},
-      {0xe912b9d1478ceb17, 0x7a37cd5601aab85e},
-      {0x91abb422ccb812ee, 0xac62e055c10ab33b},
-      {0xb616a12b7fe617aa, 0x577b986b314d600a},
-      {0xe39c49765fdf9d94, 0xed5a7e85fda0b80c},
-      {0x8e41ade9fbebc27d, 0x14588f13be847308},
-      {0xb1d219647ae6b31c, 0x596eb2d8ae258fc9},
-      {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc},
-      {0x8aec23d680043bee, 0x25de7bb9480d5855},
-      {0xada72ccc20054ae9, 0xaf561aa79a10ae6b},
-      {0xd910f7ff28069da4, 0x1b2ba1518094da05},
-      {0x87aa9aff79042286, 0x90fb44d2f05d0843},
-      {0xa99541bf57452b28, 0x353a1607ac744a54},
-      {0xd3fa922f2d1675f2, 0x42889b8997915ce9},
-      {0x847c9b5d7c2e09b7, 0x69956135febada12},
-      {0xa59bc234db398c25, 0x43fab9837e699096},
-      {0xcf02b2c21207ef2e, 0x94f967e45e03f4bc},
-      {0x8161afb94b44f57d, 0x1d1be0eebac278f6},
-      {0xa1ba1ba79e1632dc, 0x6462d92a69731733},
-      {0xca28a291859bbf93, 0x7d7b8f7503cfdcff},
-      {0xfcb2cb35e702af78, 0x5cda735244c3d43f},
-      {0x9defbf01b061adab, 0x3a0888136afa64a8},
-      {0xc56baec21c7a1916, 0x088aaa1845b8fdd1},
-      {0xf6c69a72a3989f5b, 0x8aad549e57273d46},
-      {0x9a3c2087a63f6399, 0x36ac54e2f678864c},
-      {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de},
-      {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6},
-      {0x969eb7c47859e743, 0x9f644ae5a4b1b326},
-      {0xbc4665b596706114, 0x873d5d9f0dde1fef},
-      {0xeb57ff22fc0c7959, 0xa90cb506d155a7eb},
-      {0x9316ff75dd87cbd8, 0x09a7f12442d588f3},
-      {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30},
-      {0xe5d3ef282a242e81, 0x8f1668c8a86da5fb},
-      {0x8fa475791a569d10, 0xf96e017d694487bd},
-      {0xb38d92d760ec4455, 0x37c981dcc395a9ad},
-      {0xe070f78d3927556a, 0x85bbe253f47b1418},
-      {0x8c469ab843b89562, 0x93956d7478ccec8f},
-      {0xaf58416654a6babb, 0x387ac8d1970027b3},
-      {0xdb2e51bfe9d0696a, 0x06997b05fcc0319f},
-      {0x88fcf317f22241e2, 0x441fece3bdf81f04},
-      {0xab3c2fddeeaad25a, 0xd527e81cad7626c4},
-      {0xd60b3bd56a5586f1, 0x8a71e223d8d3b075},
-      {0x85c7056562757456, 0xf6872d5667844e4a},
-      {0xa738c6bebb12d16c, 0xb428f8ac016561dc},
-      {0xd106f86e69d785c7, 0xe13336d701beba53},
-      {0x82a45b450226b39c, 0xecc0024661173474},
-      {0xa34d721642b06084, 0x27f002d7f95d0191},
-      {0xcc20ce9bd35c78a5, 0x31ec038df7b441f5},
-      {0xff290242c83396ce, 0x7e67047175a15272},
-      {0x9f79a169bd203e41, 0x0f0062c6e984d387},
-      {0xc75809c42c684dd1, 0x52c07b78a3e60869},
-      {0xf92e0c3537826145, 0xa7709a56ccdf8a83},
-      {0x9bbcc7a142b17ccb, 0x88a66076400bb692},
-      {0xc2abf989935ddbfe, 0x6acff893d00ea436},
-      {0xf356f7ebf83552fe, 0x0583f6b8c4124d44},
-      {0x98165af37b2153de, 0xc3727a337a8b704b},
-      {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d},
-      {0xeda2ee1c7064130c, 0x1162def06f79df74},
-      {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9},
-      {0xb9a74a0637ce2ee1, 0x6d953e2bd7173693},
-      {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438},
-      {0x910ab1d4db9914a0, 0x1d9c9892400a22a3},
-      {0xb54d5e4a127f59c8, 0x2503beb6d00cab4c},
-      {0xe2a0b5dc971f303a, 0x2e44ae64840fd61e},
-      {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
-      {0xb10d8e1456105dad, 0x7425a83e872c5f48},
-      {0xdd50f1996b947518, 0xd12f124e28f7771a},
-      {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70},
-      {0xace73cbfdc0bfb7b, 0x636cc64d1001550c},
-      {0xd8210befd30efa5a, 0x3c47f7e05401aa4f},
-      {0x8714a775e3e95c78, 0x65acfaec34810a72},
-      {0xa8d9d1535ce3b396, 0x7f1839a741a14d0e},
-      {0xd31045a8341ca07c, 0x1ede48111209a051},
-      {0x83ea2b892091e44d, 0x934aed0aab460433},
-      {0xa4e4b66b68b65d60, 0xf81da84d56178540},
-      {0xce1de40642e3f4b9, 0x36251260ab9d668f},
-      {0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a},
-      {0xa1075a24e4421730, 0xb24cf65b8612f820},
-      {0xc94930ae1d529cfc, 0xdee033f26797b628},
-      {0xfb9b7cd9a4a7443c, 0x169840ef017da3b2},
-      {0x9d412e0806e88aa5, 0x8e1f289560ee864f},
-      {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3},
-      {0xf5b5d7ec8acb58a2, 0xae10af696774b1dc},
-      {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a},
-      {0xbff610b0cc6edd3f, 0x17fd090a58d32af4},
-      {0xeff394dcff8a948e, 0xddfc4b4cef07f5b1},
-      {0x95f83d0a1fb69cd9, 0x4abdaf101564f98f},
-      {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2},
-      {0xea53df5fd18d5513, 0x84c86189216dc5ee},
-      {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5},
-      {0xb7118682dbb66a77, 0x3fbc8c33221dc2a2},
-      {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
-      {0x8f05b1163ba6832d, 0x29cb4d87f2a7400f},
-      {0xb2c71d5bca9023f8, 0x743e20e9ef511013},
-      {0xdf78e4b2bd342cf6, 0x914da9246b255417},
-      {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f},
-      {0xae9672aba3d0c320, 0xa184ac2473b529b2},
-      {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f},
-      {0x8865899617fb1871, 0x7e2fa67c7a658893},
-      {0xaa7eebfb9df9de8d, 0xddbb901b98feeab8},
-      {0xd51ea6fa85785631, 0x552a74227f3ea566},
-      {0x8533285c936b35de, 0xd53a88958f872760},
-      {0xa67ff273b8460356, 0x8a892abaf368f138},
-      {0xd01fef10a657842c, 0x2d2b7569b0432d86},
-      {0x8213f56a67f6b29b, 0x9c3b29620e29fc74},
-      {0xa298f2c501f45f42, 0x8349f3ba91b47b90},
-      {0xcb3f2f7642717713, 0x241c70a936219a74},
-      {0xfe0efb53d30dd4d7, 0xed238cd383aa0111},
-      {0x9ec95d1463e8a506, 0xf4363804324a40ab},
-      {0xc67bb4597ce2ce48, 0xb143c6053edcd0d6},
-      {0xf81aa16fdc1b81da, 0xdd94b7868e94050b},
-      {0x9b10a4e5e9913128, 0xca7cf2b4191c8327},
-      {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1},
-      {0xf24a01a73cf2dccf, 0xbc633b39673c8ced},
-      {0x976e41088617ca01, 0xd5be0503e085d814},
-      {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19},
-      {0xec9c459d51852ba2, 0xddf8e7d60ed1219f},
-      {0x93e1ab8252f33b45, 0xcabb90e5c942b504},
-      {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
-      {0xe7109bfba19c0c9d, 0x0cc512670a783ad5},
-      {0x906a617d450187e2, 0x27fb2b80668b24c6},
-      {0xb484f9dc9641e9da, 0xb1f9f660802dedf7},
-      {0xe1a63853bbd26451, 0x5e7873f8a0396974},
-      {0x8d07e33455637eb2, 0xdb0b487b6423e1e9},
-      {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63},
-      {0xdc5c5301c56b75f7, 0x7641a140cc7810fc},
-      {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e},
-      {0xac2820d9623bf429, 0x546345fa9fbdcd45},
-      {0xd732290fbacaf133, 0xa97c177947ad4096},
-      {0x867f59a9d4bed6c0, 0x49ed8eabcccc485e},
-      {0xa81f301449ee8c70, 0x5c68f256bfff5a75},
-      {0xd226fc195c6a2f8c, 0x73832eec6fff3112},
-      {0x83585d8fd9c25db7, 0xc831fd53c5ff7eac},
-      {0xa42e74f3d032f525, 0xba3e7ca8b77f5e56},
-      {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec},
-      {0x80444b5e7aa7cf85, 0x7980d163cf5b81b4},
-      {0xa0555e361951c366, 0xd7e105bcc3326220},
-      {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8},
-      {0xfa856334878fc150, 0xb14f98f6f0feb952},
-      {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4},
-      {0xc3b8358109e84f07, 0x0a862f80ec4700c9},
-      {0xf4a642e14c6262c8, 0xcd27bb612758c0fb},
-      {0x98e7e9cccfbd7dbd, 0x8038d51cb897789d},
-      {0xbf21e44003acdd2c, 0xe0470a63e6bd56c4},
-      {0xeeea5d5004981478, 0x1858ccfce06cac75},
-      {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
-      {0xbaa718e68396cffd, 0xd30560258f54e6bb},
-      {0xe950df20247c83fd, 0x47c6b82ef32a206a},
-      {0x91d28b7416cdd27e, 0x4cdc331d57fa5442},
-      {0xb6472e511c81471d, 0xe0133fe4adf8e953},
-      {0xe3d8f9e563a198e5, 0x58180fddd97723a7},
-      {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649},
-      {0xb201833b35d63f73, 0x2cd2cc6551e513db},
-      {0xde81e40a034bcf4f, 0xf8077f7ea65e58d2},
-      {0x8b112e86420f6191, 0xfb04afaf27faf783},
-      {0xadd57a27d29339f6, 0x79c5db9af1f9b564},
-      {0xd94ad8b1c7380874, 0x18375281ae7822bd},
-      {0x87cec76f1c830548, 0x8f2293910d0b15b6},
-      {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23},
-      {0xd433179d9c8cb841, 0x5fa60692a46151ec},
-      {0x849feec281d7f328, 0xdbc7c41ba6bcd334},
-      {0xa5c7ea73224deff3, 0x12b9b522906c0801},
-      {0xcf39e50feae16bef, 0xd768226b34870a01},
-      {0x81842f29f2cce375, 0xe6a1158300d46641},
-      {0xa1e53af46f801c53, 0x60495ae3c1097fd1},
-      {0xca5e89b18b602368, 0x385bb19cb14bdfc5},
-      {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6},
-      {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2},
-      {0xc5a05277621be293, 0xc7098b7305241886},
-      {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8},
-      {0x9a65406d44a5c903, 0x737f74f1dc043329},
-      {0xc0fe908895cf3b44, 0x505f522e53053ff3},
-      {0xf13e34aabb430a15, 0x647726b9e7c68ff0},
-      {0x96c6e0eab509e64d, 0x5eca783430dc19f6},
-      {0xbc789925624c5fe0, 0xb67d16413d132073},
-      {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890},
-      {0x933e37a534cbaae7, 0x8e91b962f7b6f15a},
-      {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1},
-      {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d},
-      {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2},
-      {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e},
-      {0xe0accfa875af45a7, 0x93eb1b80a33b8606},
-      {0x8c6c01c9498d8b88, 0xbc72f130660533c4},
-      {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
-      {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2},
-#else
-      {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
-      {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
-      {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
-      {0x86a8d39ef77164bc, 0xae5dff9c02033198},
-      {0xd98ddaee19068c76, 0x3badd624dd9b0958},
-      {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
-      {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
-      {0xe55990879ddcaabd, 0xcc420a6a101d0516},
-      {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
-      {0x95a8637627989aad, 0xdde7001379a44aa9},
-      {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
-      {0xc350000000000000, 0x0000000000000000},
-      {0x9dc5ada82b70b59d, 0xf020000000000000},
-      {0xfee50b7025c36a08, 0x02f236d04753d5b5},
-      {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
-      {0xa6539930bf6bff45, 0x84db8346b786151d},
-      {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
-      {0xd910f7ff28069da4, 0x1b2ba1518094da05},
-      {0xaf58416654a6babb, 0x387ac8d1970027b3},
-      {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
-      {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
-      {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
-      {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
-      {0xf13e34aabb430a15, 0x647726b9e7c68ff0}
-#endif
-    };
-
-#if FMTQUILL_USE_FULL_CACHE_DRAGONBOX
-    return pow10_significands[k - float_info<double>::min_k];
-#else
-    static constexpr const uint64_t powers_of_5_64[] = {
-        0x0000000000000001, 0x0000000000000005, 0x0000000000000019,
-        0x000000000000007d, 0x0000000000000271, 0x0000000000000c35,
-        0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1,
-        0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd,
-        0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9,
-        0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5,
-        0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631,
-        0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed,
-        0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9};
-
-    static const int compression_ratio = 27;
-
-    // Compute base index.
-    int cache_index = (k - float_info<double>::min_k) / compression_ratio;
-    int kb = cache_index * compression_ratio + float_info<double>::min_k;
-    int offset = k - kb;
-
-    // Get base cache.
-    uint128_fallback base_cache = pow10_significands[cache_index];
-    if (offset == 0) return base_cache;
-
-    // Compute the required amount of bit-shift.
-    int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset;
-    FMTQUILL_ASSERT(alpha > 0 && alpha < 64, "shifting error detected");
-
-    // Try to recover the real cache.
-    uint64_t pow5 = powers_of_5_64[offset];
-    uint128_fallback recovered_cache = umul128(base_cache.high(), pow5);
-    uint128_fallback middle_low = umul128(base_cache.low(), pow5);
-
-    recovered_cache += middle_low.high();
-
-    uint64_t high_to_middle = recovered_cache.high() << (64 - alpha);
-    uint64_t middle_to_low = recovered_cache.low() << (64 - alpha);
-
-    recovered_cache =
-        uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle,
-                         ((middle_low.low() >> alpha) | middle_to_low)};
-    FMTQUILL_ASSERT(recovered_cache.low() + 1 != 0, "");
-    return {recovered_cache.high(), recovered_cache.low() + 1};
-#endif
-  }
-
-  struct compute_mul_result {
-    carrier_uint result;
-    bool is_integer;
-  };
-  struct compute_mul_parity_result {
-    bool parity;
-    bool is_integer;
-  };
-
-  static auto compute_mul(carrier_uint u,
-                          const cache_entry_type& cache) noexcept
-      -> compute_mul_result {
-    auto r = umul192_upper128(u, cache);
-    return {r.high(), r.low() == 0};
-  }
-
-  static auto compute_delta(cache_entry_type const& cache, int beta) noexcept
-      -> uint32_t {
-    return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta));
-  }
-
-  static auto compute_mul_parity(carrier_uint two_f,
-                                 const cache_entry_type& cache,
-                                 int beta) noexcept
-      -> compute_mul_parity_result {
-    FMTQUILL_ASSERT(beta >= 1, "");
-    FMTQUILL_ASSERT(beta < 64, "");
-
-    auto r = umul192_lower128(two_f, cache);
-    return {((r.high() >> (64 - beta)) & 1) != 0,
-            ((r.high() << beta) | (r.low() >> (64 - beta))) == 0};
-  }
-
-  static auto compute_left_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
-    return (cache.high() -
-            (cache.high() >> (num_significand_bits<double>() + 2))) >>
-           (64 - num_significand_bits<double>() - 1 - beta);
-  }
-
-  static auto compute_right_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
-    return (cache.high() +
-            (cache.high() >> (num_significand_bits<double>() + 1))) >>
-           (64 - num_significand_bits<double>() - 1 - beta);
-  }
-
-  static auto compute_round_up_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
-    return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) +
-            1) /
-           2;
-  }
-};
-
-FMTQUILL_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback {
-  return cache_accessor<double>::get_cached_power(k);
-}
-
-// Various integer checks
-template <typename T>
-auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool {
-  const int case_shorter_interval_left_endpoint_lower_threshold = 2;
-  const int case_shorter_interval_left_endpoint_upper_threshold = 3;
-  return exponent >= case_shorter_interval_left_endpoint_lower_threshold &&
-         exponent <= case_shorter_interval_left_endpoint_upper_threshold;
-}
-
-// Remove trailing zeros from n and return the number of zeros removed (float)
-FMTQUILL_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept {
-  FMTQUILL_ASSERT(n != 0, "");
-  // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1.
-  constexpr uint32_t mod_inv_5 = 0xcccccccd;
-  constexpr uint32_t mod_inv_25 = 0xc28f5c29;  // = mod_inv_5 * mod_inv_5
-
-  while (true) {
-    auto q = rotr(n * mod_inv_25, 2);
-    if (q > max_value<uint32_t>() / 100) break;
-    n = q;
-    s += 2;
-  }
-  auto q = rotr(n * mod_inv_5, 1);
-  if (q <= max_value<uint32_t>() / 10) {
-    n = q;
-    s |= 1;
-  }
-  return s;
-}
-
-// Removes trailing zeros and returns the number of zeros removed (double)
-FMTQUILL_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
-  FMTQUILL_ASSERT(n != 0, "");
-
-  // This magic number is ceil(2^90 / 10^8).
-  constexpr uint64_t magic_number = 12379400392853802749ull;
-  auto nm = umul128(n, magic_number);
-
-  // Is n is divisible by 10^8?
-  if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) {
-    // If yes, work with the quotient...
-    auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64));
-    // ... and use the 32 bit variant of the function
-    int s = remove_trailing_zeros(n32, 8);
-    n = n32;
-    return s;
-  }
-
-  // If n is not divisible by 10^8, work with n itself.
-  constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd;
-  constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29;  // mod_inv_5 * mod_inv_5
-
-  int s = 0;
-  while (true) {
-    auto q = rotr(n * mod_inv_25, 2);
-    if (q > max_value<uint64_t>() / 100) break;
-    n = q;
-    s += 2;
-  }
-  auto q = rotr(n * mod_inv_5, 1);
-  if (q <= max_value<uint64_t>() / 10) {
-    n = q;
-    s |= 1;
-  }
-
-  return s;
-}
-
-// The main algorithm for shorter interval case
-template <typename T>
-FMTQUILL_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
-  decimal_fp<T> ret_value;
-  // Compute k and beta
-  const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent);
-  const int beta = exponent + floor_log2_pow10(-minus_k);
-
-  // Compute xi and zi
-  using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
-  const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
-
-  auto xi = cache_accessor<T>::compute_left_endpoint_for_shorter_interval_case(
-      cache, beta);
-  auto zi = cache_accessor<T>::compute_right_endpoint_for_shorter_interval_case(
-      cache, beta);
-
-  // If the left endpoint is not an integer, increase it
-  if (!is_left_endpoint_integer_shorter_interval<T>(exponent)) ++xi;
-
-  // Try bigger divisor
-  ret_value.significand = zi / 10;
-
-  // If succeed, remove trailing zeros if necessary and return
-  if (ret_value.significand * 10 >= xi) {
-    ret_value.exponent = minus_k + 1;
-    ret_value.exponent += remove_trailing_zeros(ret_value.significand);
-    return ret_value;
-  }
-
-  // Otherwise, compute the round-up of y
-  ret_value.significand =
-      cache_accessor<T>::compute_round_up_for_shorter_interval_case(cache,
-                                                                    beta);
-  ret_value.exponent = minus_k;
-
-  // When tie occurs, choose one of them according to the rule
-  if (exponent >= float_info<T>::shorter_interval_tie_lower_threshold &&
-      exponent <= float_info<T>::shorter_interval_tie_upper_threshold) {
-    ret_value.significand = ret_value.significand % 2 == 0
-                                ? ret_value.significand
-                                : ret_value.significand - 1;
-  } else if (ret_value.significand < xi) {
-    ++ret_value.significand;
-  }
-  return ret_value;
-}
-
-template <typename T> auto to_decimal(T x) noexcept -> decimal_fp<T> {
-  // Step 1: integer promotion & Schubfach multiplier calculation.
-
-  using carrier_uint = typename float_info<T>::carrier_uint;
-  using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
-  auto br = bit_cast<carrier_uint>(x);
-
-  // Extract significand bits and exponent bits.
-  const carrier_uint significand_mask =
-      (static_cast<carrier_uint>(1) << num_significand_bits<T>()) - 1;
-  carrier_uint significand = (br & significand_mask);
-  int exponent =
-      static_cast<int>((br & exponent_mask<T>()) >> num_significand_bits<T>());
-
-  if (exponent != 0) {  // Check if normal.
-    exponent -= exponent_bias<T>() + num_significand_bits<T>();
-
-    // Shorter interval case; proceed like Schubfach.
-    // In fact, when exponent == 1 and significand == 0, the interval is
-    // regular. However, it can be shown that the end-results are anyway same.
-    if (significand == 0) return shorter_interval_case<T>(exponent);
-
-    significand |= (static_cast<carrier_uint>(1) << num_significand_bits<T>());
-  } else {
-    // Subnormal case; the interval is always regular.
-    if (significand == 0) return {0, 0};
-    exponent =
-        std::numeric_limits<T>::min_exponent - num_significand_bits<T>() - 1;
-  }
-
-  const bool include_left_endpoint = (significand % 2 == 0);
-  const bool include_right_endpoint = include_left_endpoint;
-
-  // Compute k and beta.
-  const int minus_k = floor_log10_pow2(exponent) - float_info<T>::kappa;
-  const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
-  const int beta = exponent + floor_log2_pow10(-minus_k);
-
-  // Compute zi and deltai.
-  // 10^kappa <= deltai < 10^(kappa + 1)
-  const uint32_t deltai = cache_accessor<T>::compute_delta(cache, beta);
-  const carrier_uint two_fc = significand << 1;
-
-  // For the case of binary32, the result of integer check is not correct for
-  // 29711844 * 2^-82
-  // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18
-  // and 29711844 * 2^-81
-  // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17,
-  // and they are the unique counterexamples. However, since 29711844 is even,
-  // this does not cause any problem for the endpoints calculations; it can only
-  // cause a problem when we need to perform integer check for the center.
-  // Fortunately, with these inputs, that branch is never executed, so we are
-  // fine.
-  const typename cache_accessor<T>::compute_mul_result z_mul =
-      cache_accessor<T>::compute_mul((two_fc | 1) << beta, cache);
-
-  // Step 2: Try larger divisor; remove trailing zeros if necessary.
-
-  // Using an upper bound on zi, we might be able to optimize the division
-  // better than the compiler; we are computing zi / big_divisor here.
-  decimal_fp<T> ret_value;
-  ret_value.significand = divide_by_10_to_kappa_plus_1(z_mul.result);
-  uint32_t r = static_cast<uint32_t>(z_mul.result - float_info<T>::big_divisor *
-                                                        ret_value.significand);
-
-  if (r < deltai) {
-    // Exclude the right endpoint if necessary.
-    if (r == 0 && (z_mul.is_integer & !include_right_endpoint)) {
-      --ret_value.significand;
-      r = float_info<T>::big_divisor;
-      goto small_divisor_case_label;
-    }
-  } else if (r > deltai) {
-    goto small_divisor_case_label;
-  } else {
-    // r == deltai; compare fractional parts.
-    const typename cache_accessor<T>::compute_mul_parity_result x_mul =
-        cache_accessor<T>::compute_mul_parity(two_fc - 1, cache, beta);
-
-    if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint)))
-      goto small_divisor_case_label;
-  }
-  ret_value.exponent = minus_k + float_info<T>::kappa + 1;
-
-  // We may need to remove trailing zeros.
-  ret_value.exponent += remove_trailing_zeros(ret_value.significand);
-  return ret_value;
-
-  // Step 3: Find the significand with the smaller divisor.
-
-small_divisor_case_label:
-  ret_value.significand *= 10;
-  ret_value.exponent = minus_k + float_info<T>::kappa;
-
-  uint32_t dist = r - (deltai / 2) + (float_info<T>::small_divisor / 2);
-  const bool approx_y_parity =
-      ((dist ^ (float_info<T>::small_divisor / 2)) & 1) != 0;
-
-  // Is dist divisible by 10^kappa?
-  const bool divisible_by_small_divisor =
-      check_divisibility_and_divide_by_pow10<float_info<T>::kappa>(dist);
-
-  // Add dist / 10^kappa to the significand.
-  ret_value.significand += dist;
-
-  if (!divisible_by_small_divisor) return ret_value;
-
-  // Check z^(f) >= epsilon^(f).
-  // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1,
-  // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f).
-  // Since there are only 2 possibilities, we only need to care about the
-  // parity. Also, zi and r should have the same parity since the divisor
-  // is an even number.
-  const auto y_mul = cache_accessor<T>::compute_mul_parity(two_fc, cache, beta);
-
-  // If z^(f) >= epsilon^(f), we might have a tie when z^(f) == epsilon^(f),
-  // or equivalently, when y is an integer.
-  if (y_mul.parity != approx_y_parity)
-    --ret_value.significand;
-  else if (y_mul.is_integer & (ret_value.significand % 2 != 0))
-    --ret_value.significand;
-  return ret_value;
-}
-}  // namespace dragonbox
-}  // namespace detail
-
-template <> struct formatter<detail::bigint> {
-  FMTQUILL_CONSTEXPR auto parse(format_parse_context& ctx)
-      -> format_parse_context::iterator {
-    return ctx.begin();
-  }
-
-  auto format(const detail::bigint& n, format_context& ctx) const
-      -> format_context::iterator {
-    auto out = ctx.out();
-    bool first = true;
-    for (auto i = n.bigits_.size(); i > 0; --i) {
-      auto value = n.bigits_[i - 1u];
-      if (first) {
-        out = fmtquill::format_to(out, FMTQUILL_STRING("{:x}"), value);
-        first = false;
-        continue;
-      }
-      out = fmtquill::format_to(out, FMTQUILL_STRING("{:08x}"), value);
-    }
-    if (n.exp_ > 0)
-      out = fmtquill::format_to(out, FMTQUILL_STRING("p{}"),
-                           n.exp_ * detail::bigint::bigit_bits);
-    return out;
-  }
-};
-
-FMTQUILL_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) {
-  for_each_codepoint(s, [this](uint32_t cp, string_view) {
-    if (cp == invalid_code_point) FMTQUILL_THROW(std::runtime_error("invalid utf8"));
-    if (cp <= 0xFFFF) {
-      buffer_.push_back(static_cast<wchar_t>(cp));
-    } else {
-      cp -= 0x10000;
-      buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10)));
-      buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF)));
-    }
-    return true;
-  });
-  buffer_.push_back(0);
-}
-
-FMTQUILL_FUNC void format_system_error(detail::buffer<char>& out, int error_code,
-                                  const char* message) noexcept {
-  FMTQUILL_TRY {
-    auto ec = std::error_code(error_code, std::generic_category());
-    write(std::back_inserter(out), std::system_error(ec, message).what());
-    return;
-  }
-  FMTQUILL_CATCH(...) {}
-  format_error_code(out, error_code, message);
-}
-
-FMTQUILL_FUNC void report_system_error(int error_code,
-                                  const char* message) noexcept {
-  report_error(format_system_error, error_code, message);
-}
-
-FMTQUILL_FUNC auto vformat(string_view fmt, format_args args) -> std::string {
-  // Don't optimize the "{}" case to keep the binary size small and because it
-  // can be better optimized in fmtquill::format anyway.
-  auto buffer = memory_buffer();
-  detail::vformat_to(buffer, fmt, args);
-  return to_string(buffer);
-}
-
-namespace detail {
-#if !defined(_WIN32) || defined(FMTQUILL_WINDOWS_NO_WCHAR)
-FMTQUILL_FUNC auto write_console(int, string_view) -> bool { return false; }
-FMTQUILL_FUNC auto write_console(std::FILE*, string_view) -> bool { return false; }
-#else
-using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
-extern "C" __declspec(dllimport) int __stdcall WriteConsoleW(  //
-    void*, const void*, dword, dword*, void*);
-
-FMTQUILL_FUNC bool write_console(int fd, string_view text) {
-  auto u16 = utf8_to_utf16(text);
-  return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
-                       static_cast<dword>(u16.size()), nullptr, nullptr) != 0;
-}
-
-FMTQUILL_FUNC auto write_console(std::FILE* f, string_view text) -> bool {
-  return write_console(_fileno(f), text);
-}
-#endif
-
-#ifdef _WIN32
-// Print assuming legacy (non-Unicode) encoding.
-FMTQUILL_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
-  auto buffer = memory_buffer();
-  detail::vformat_to(buffer, fmt, args);
-  fwrite_fully(buffer.data(), buffer.size(), f);
-}
-#endif
-
-FMTQUILL_FUNC void print(std::FILE* f, string_view text) {
-#ifdef _WIN32
-  int fd = _fileno(f);
-  if (_isatty(fd)) {
-    std::fflush(f);
-    if (write_console(fd, text)) return;
-  }
-#endif
-  fwrite_fully(text.data(), text.size(), f);
-}
-}  // namespace detail
-
-FMTQUILL_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) {
-  auto buffer = memory_buffer();
-  detail::vformat_to(buffer, fmt, args);
-  detail::print(f, {buffer.data(), buffer.size()});
-}
-
-FMTQUILL_FUNC void vprint(string_view fmt, format_args args) {
-  vprint(stdout, fmt, args);
-}
-
-namespace detail {
-
-struct singleton {
-  unsigned char upper;
-  unsigned char lower_count;
-};
-
-inline auto is_printable(uint16_t x, const singleton* singletons,
-                         size_t singletons_size,
-                         const unsigned char* singleton_lowers,
-                         const unsigned char* normal, size_t normal_size)
-    -> bool {
-  auto upper = x >> 8;
-  auto lower_start = 0;
-  for (size_t i = 0; i < singletons_size; ++i) {
-    auto s = singletons[i];
-    auto lower_end = lower_start + s.lower_count;
-    if (upper < s.upper) break;
-    if (upper == s.upper) {
-      for (auto j = lower_start; j < lower_end; ++j) {
-        if (singleton_lowers[j] == (x & 0xff)) return false;
-      }
-    }
-    lower_start = lower_end;
-  }
-
-  auto xsigned = static_cast<int>(x);
-  auto current = true;
-  for (size_t i = 0; i < normal_size; ++i) {
-    auto v = static_cast<int>(normal[i]);
-    auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v;
-    xsigned -= len;
-    if (xsigned < 0) break;
-    current = !current;
-  }
-  return current;
-}
-
-// This code is generated by support/printable.py.
-FMTQUILL_FUNC auto is_printable(uint32_t cp) -> bool {
-  static constexpr singleton singletons0[] = {
-      {0x00, 1},  {0x03, 5},  {0x05, 6},  {0x06, 3},  {0x07, 6},  {0x08, 8},
-      {0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13},
-      {0x0f, 4},  {0x10, 3},  {0x12, 18}, {0x13, 9},  {0x16, 1},  {0x17, 5},
-      {0x18, 2},  {0x19, 3},  {0x1a, 7},  {0x1c, 2},  {0x1d, 1},  {0x1f, 22},
-      {0x20, 3},  {0x2b, 3},  {0x2c, 2},  {0x2d, 11}, {0x2e, 1},  {0x30, 3},
-      {0x31, 2},  {0x32, 1},  {0xa7, 2},  {0xa9, 2},  {0xaa, 4},  {0xab, 8},
-      {0xfa, 2},  {0xfb, 5},  {0xfd, 4},  {0xfe, 3},  {0xff, 9},
-  };
-  static constexpr unsigned char singletons0_lower[] = {
-      0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57, 0x58, 0x8b, 0x8c, 0x90,
-      0x1c, 0x1d, 0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f,
-      0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91, 0x92, 0xa9, 0xb1,
-      0xba, 0xbb, 0xc5, 0xc6, 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04,
-      0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a, 0x5d,
-      0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf,
-      0xe4, 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,
-      0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d,
-      0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65, 0x8d,
-      0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x0d,
-      0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5,
-      0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe, 0xbf, 0xc5, 0xc7,
-      0xce, 0xcf, 0xda, 0xdb, 0x48, 0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49,
-      0x4e, 0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1, 0xb6, 0xb7,
-      0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7,
-      0xfe, 0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x0f, 0x1f, 0x6e,
-      0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16,
-      0x17, 0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e, 0x7e,
-      0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f,
-      0x74, 0x75, 0x96, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf,
-      0xc7, 0xcf, 0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f, 0x1f, 0xc0,
-      0xc1, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27,
-      0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91,
-      0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7,
-      0xfe, 0xff,
-  };
-  static constexpr singleton singletons1[] = {
-      {0x00, 6},  {0x01, 1}, {0x03, 1},  {0x04, 2}, {0x08, 8},  {0x09, 2},
-      {0x0a, 5},  {0x0b, 2}, {0x0e, 4},  {0x10, 1}, {0x11, 2},  {0x12, 5},
-      {0x13, 17}, {0x14, 1}, {0x15, 2},  {0x17, 2}, {0x19, 13}, {0x1c, 5},
-      {0x1d, 8},  {0x24, 1}, {0x6a, 3},  {0x6b, 2}, {0xbc, 2},  {0xd1, 2},
-      {0xd4, 12}, {0xd5, 9}, {0xd6, 2},  {0xd7, 2}, {0xda, 1},  {0xe0, 5},
-      {0xe1, 2},  {0xe8, 2}, {0xee, 32}, {0xf0, 4}, {0xf8, 2},  {0xf9, 2},
-      {0xfa, 2},  {0xfb, 1},
-  };
-  static constexpr unsigned char singletons1_lower[] = {
-      0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e, 0x9e, 0x9f, 0x06, 0x07,
-      0x09, 0x36, 0x3d, 0x3e, 0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36,
-      0x37, 0x56, 0x57, 0x7f, 0xaa, 0xae, 0xaf, 0xbd, 0x35, 0xe0, 0x12, 0x87,
-      0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,
-      0x45, 0x46, 0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5c, 0xb6, 0xb7, 0x1b,
-      0x1c, 0x07, 0x08, 0x0a, 0x0b, 0x14, 0x17, 0x36, 0x39, 0x3a, 0xa8, 0xa9,
-      0xd8, 0xd9, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66,
-      0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27,
-      0x28, 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc,
-      0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7,
-      0xcc, 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xc5, 0xc6,
-      0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a, 0x4c,
-      0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66,
-      0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0, 0xd0,
-      0xae, 0xaf, 0x79, 0xcc, 0x6e, 0x6f, 0x93,
-  };
-  static constexpr unsigned char normal0[] = {
-      0x00, 0x20, 0x5f, 0x22, 0x82, 0xdf, 0x04, 0x82, 0x44, 0x08, 0x1b, 0x04,
-      0x06, 0x11, 0x81, 0xac, 0x0e, 0x80, 0xab, 0x35, 0x28, 0x0b, 0x80, 0xe0,
-      0x03, 0x19, 0x08, 0x01, 0x04, 0x2f, 0x04, 0x34, 0x04, 0x07, 0x03, 0x01,
-      0x07, 0x06, 0x07, 0x11, 0x0a, 0x50, 0x0f, 0x12, 0x07, 0x55, 0x07, 0x03,
-      0x04, 0x1c, 0x0a, 0x09, 0x03, 0x08, 0x03, 0x07, 0x03, 0x02, 0x03, 0x03,
-      0x03, 0x0c, 0x04, 0x05, 0x03, 0x0b, 0x06, 0x01, 0x0e, 0x15, 0x05, 0x3a,
-      0x03, 0x11, 0x07, 0x06, 0x05, 0x10, 0x07, 0x57, 0x07, 0x02, 0x07, 0x15,
-      0x0d, 0x50, 0x04, 0x43, 0x03, 0x2d, 0x03, 0x01, 0x04, 0x11, 0x06, 0x0f,
-      0x0c, 0x3a, 0x04, 0x1d, 0x25, 0x5f, 0x20, 0x6d, 0x04, 0x6a, 0x25, 0x80,
-      0xc8, 0x05, 0x82, 0xb0, 0x03, 0x1a, 0x06, 0x82, 0xfd, 0x03, 0x59, 0x07,
-      0x15, 0x0b, 0x17, 0x09, 0x14, 0x0c, 0x14, 0x0c, 0x6a, 0x06, 0x0a, 0x06,
-      0x1a, 0x06, 0x59, 0x07, 0x2b, 0x05, 0x46, 0x0a, 0x2c, 0x04, 0x0c, 0x04,
-      0x01, 0x03, 0x31, 0x0b, 0x2c, 0x04, 0x1a, 0x06, 0x0b, 0x03, 0x80, 0xac,
-      0x06, 0x0a, 0x06, 0x21, 0x3f, 0x4c, 0x04, 0x2d, 0x03, 0x74, 0x08, 0x3c,
-      0x03, 0x0f, 0x03, 0x3c, 0x07, 0x38, 0x08, 0x2b, 0x05, 0x82, 0xff, 0x11,
-      0x18, 0x08, 0x2f, 0x11, 0x2d, 0x03, 0x20, 0x10, 0x21, 0x0f, 0x80, 0x8c,
-      0x04, 0x82, 0x97, 0x19, 0x0b, 0x15, 0x88, 0x94, 0x05, 0x2f, 0x05, 0x3b,
-      0x07, 0x02, 0x0e, 0x18, 0x09, 0x80, 0xb3, 0x2d, 0x74, 0x0c, 0x80, 0xd6,
-      0x1a, 0x0c, 0x05, 0x80, 0xff, 0x05, 0x80, 0xdf, 0x0c, 0xee, 0x0d, 0x03,
-      0x84, 0x8d, 0x03, 0x37, 0x09, 0x81, 0x5c, 0x14, 0x80, 0xb8, 0x08, 0x80,
-      0xcb, 0x2a, 0x38, 0x03, 0x0a, 0x06, 0x38, 0x08, 0x46, 0x08, 0x0c, 0x06,
-      0x74, 0x0b, 0x1e, 0x03, 0x5a, 0x04, 0x59, 0x09, 0x80, 0x83, 0x18, 0x1c,
-      0x0a, 0x16, 0x09, 0x4c, 0x04, 0x80, 0x8a, 0x06, 0xab, 0xa4, 0x0c, 0x17,
-      0x04, 0x31, 0xa1, 0x04, 0x81, 0xda, 0x26, 0x07, 0x0c, 0x05, 0x05, 0x80,
-      0xa5, 0x11, 0x81, 0x6d, 0x10, 0x78, 0x28, 0x2a, 0x06, 0x4c, 0x04, 0x80,
-      0x8d, 0x04, 0x80, 0xbe, 0x03, 0x1b, 0x03, 0x0f, 0x0d,
-  };
-  static constexpr unsigned char normal1[] = {
-      0x5e, 0x22, 0x7b, 0x05, 0x03, 0x04, 0x2d, 0x03, 0x66, 0x03, 0x01, 0x2f,
-      0x2e, 0x80, 0x82, 0x1d, 0x03, 0x31, 0x0f, 0x1c, 0x04, 0x24, 0x09, 0x1e,
-      0x05, 0x2b, 0x05, 0x44, 0x04, 0x0e, 0x2a, 0x80, 0xaa, 0x06, 0x24, 0x04,
-      0x24, 0x04, 0x28, 0x08, 0x34, 0x0b, 0x01, 0x80, 0x90, 0x81, 0x37, 0x09,
-      0x16, 0x0a, 0x08, 0x80, 0x98, 0x39, 0x03, 0x63, 0x08, 0x09, 0x30, 0x16,
-      0x05, 0x21, 0x03, 0x1b, 0x05, 0x01, 0x40, 0x38, 0x04, 0x4b, 0x05, 0x2f,
-      0x04, 0x0a, 0x07, 0x09, 0x07, 0x40, 0x20, 0x27, 0x04, 0x0c, 0x09, 0x36,
-      0x03, 0x3a, 0x05, 0x1a, 0x07, 0x04, 0x0c, 0x07, 0x50, 0x49, 0x37, 0x33,
-      0x0d, 0x33, 0x07, 0x2e, 0x08, 0x0a, 0x81, 0x26, 0x52, 0x4e, 0x28, 0x08,
-      0x2a, 0x56, 0x1c, 0x14, 0x17, 0x09, 0x4e, 0x04, 0x1e, 0x0f, 0x43, 0x0e,
-      0x19, 0x07, 0x0a, 0x06, 0x48, 0x08, 0x27, 0x09, 0x75, 0x0b, 0x3f, 0x41,
-      0x2a, 0x06, 0x3b, 0x05, 0x0a, 0x06, 0x51, 0x06, 0x01, 0x05, 0x10, 0x03,
-      0x05, 0x80, 0x8b, 0x62, 0x1e, 0x48, 0x08, 0x0a, 0x80, 0xa6, 0x5e, 0x22,
-      0x45, 0x0b, 0x0a, 0x06, 0x0d, 0x13, 0x39, 0x07, 0x0a, 0x36, 0x2c, 0x04,
-      0x10, 0x80, 0xc0, 0x3c, 0x64, 0x53, 0x0c, 0x48, 0x09, 0x0a, 0x46, 0x45,
-      0x1b, 0x48, 0x08, 0x53, 0x1d, 0x39, 0x81, 0x07, 0x46, 0x0a, 0x1d, 0x03,
-      0x47, 0x49, 0x37, 0x03, 0x0e, 0x08, 0x0a, 0x06, 0x39, 0x07, 0x0a, 0x81,
-      0x36, 0x19, 0x80, 0xb7, 0x01, 0x0f, 0x32, 0x0d, 0x83, 0x9b, 0x66, 0x75,
-      0x0b, 0x80, 0xc4, 0x8a, 0xbc, 0x84, 0x2f, 0x8f, 0xd1, 0x82, 0x47, 0xa1,
-      0xb9, 0x82, 0x39, 0x07, 0x2a, 0x04, 0x02, 0x60, 0x26, 0x0a, 0x46, 0x0a,
-      0x28, 0x05, 0x13, 0x82, 0xb0, 0x5b, 0x65, 0x4b, 0x04, 0x39, 0x07, 0x11,
-      0x40, 0x05, 0x0b, 0x02, 0x0e, 0x97, 0xf8, 0x08, 0x84, 0xd6, 0x2a, 0x09,
-      0xa2, 0xf7, 0x81, 0x1f, 0x31, 0x03, 0x11, 0x04, 0x08, 0x81, 0x8c, 0x89,
-      0x04, 0x6b, 0x05, 0x0d, 0x03, 0x09, 0x07, 0x10, 0x93, 0x60, 0x80, 0xf6,
-      0x0a, 0x73, 0x08, 0x6e, 0x17, 0x46, 0x80, 0x9a, 0x14, 0x0c, 0x57, 0x09,
-      0x19, 0x80, 0x87, 0x81, 0x47, 0x03, 0x85, 0x42, 0x0f, 0x15, 0x85, 0x50,
-      0x2b, 0x80, 0xd5, 0x2d, 0x03, 0x1a, 0x04, 0x02, 0x81, 0x70, 0x3a, 0x05,
-      0x01, 0x85, 0x00, 0x80, 0xd7, 0x29, 0x4c, 0x04, 0x0a, 0x04, 0x02, 0x83,
-      0x11, 0x44, 0x4c, 0x3d, 0x80, 0xc2, 0x3c, 0x06, 0x01, 0x04, 0x55, 0x05,
-      0x1b, 0x34, 0x02, 0x81, 0x0e, 0x2c, 0x04, 0x64, 0x0c, 0x56, 0x0a, 0x80,
-      0xae, 0x38, 0x1d, 0x0d, 0x2c, 0x04, 0x09, 0x07, 0x02, 0x0e, 0x06, 0x80,
-      0x9a, 0x83, 0xd8, 0x08, 0x0d, 0x03, 0x0d, 0x03, 0x74, 0x0c, 0x59, 0x07,
-      0x0c, 0x14, 0x0c, 0x04, 0x38, 0x08, 0x0a, 0x06, 0x28, 0x08, 0x22, 0x4e,
-      0x81, 0x54, 0x0c, 0x15, 0x03, 0x03, 0x05, 0x07, 0x09, 0x19, 0x07, 0x07,
-      0x09, 0x03, 0x0d, 0x07, 0x29, 0x80, 0xcb, 0x25, 0x0a, 0x84, 0x06,
-  };
-  auto lower = static_cast<uint16_t>(cp);
-  if (cp < 0x10000) {
-    return is_printable(lower, singletons0,
-                        sizeof(singletons0) / sizeof(*singletons0),
-                        singletons0_lower, normal0, sizeof(normal0));
-  }
-  if (cp < 0x20000) {
-    return is_printable(lower, singletons1,
-                        sizeof(singletons1) / sizeof(*singletons1),
-                        singletons1_lower, normal1, sizeof(normal1));
-  }
-  if (0x2a6de <= cp && cp < 0x2a700) return false;
-  if (0x2b735 <= cp && cp < 0x2b740) return false;
-  if (0x2b81e <= cp && cp < 0x2b820) return false;
-  if (0x2cea2 <= cp && cp < 0x2ceb0) return false;
-  if (0x2ebe1 <= cp && cp < 0x2f800) return false;
-  if (0x2fa1e <= cp && cp < 0x30000) return false;
-  if (0x3134b <= cp && cp < 0xe0100) return false;
-  if (0xe01f0 <= cp && cp < 0x110000) return false;
-  return cp < 0x110000;
-}
-
-}  // namespace detail
-
-FMTQUILL_END_NAMESPACE
-
-#endif  // FMTQUILL_FORMAT_INL_H_
diff --git a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/format.h b/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/format.h
deleted file mode 100644
index 9371862..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/format.h
+++ /dev/null
@@ -1,4539 +0,0 @@
-/*
-  Formatting library for C++
-
-  Copyright (c) 2012 - present, Victor Zverovich
-
-  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.
-
-  --- Optional exception to the license ---
-
-  As an exception, if, as a result of your compiling your source code, portions
-  of this Software are embedded into a machine-executable object form of such
-  source code, you may redistribute such embedded portions in such object form
-  without including the above copyright and permission notices.
- */
-
-#ifndef FMTQUILL_FORMAT_H_
-#define FMTQUILL_FORMAT_H_
-
-#if !defined(FMTQUILL_HEADER_ONLY)
-  #define FMTQUILL_HEADER_ONLY
-#endif
-
-#include <cmath>             // std::signbit
-#include <cstdint>           // uint32_t
-#include <cstring>           // std::memcpy
-#include <initializer_list>  // std::initializer_list
-#include <limits>            // std::numeric_limits
-#include <memory>            // std::uninitialized_copy
-#include <stdexcept>         // std::runtime_error
-#include <system_error>      // std::system_error
-
-#ifdef __cpp_lib_bit_cast
-#  include <bit>  // std::bit_cast
-#endif
-
-#include "core.h"
-
-#if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L
-#  define FMTQUILL_INLINE_VARIABLE inline
-#else
-#  define FMTQUILL_INLINE_VARIABLE
-#endif
-
-#if FMTQUILL_HAS_CPP17_ATTRIBUTE(fallthrough)
-#  define FMTQUILL_FALLTHROUGH [[fallthrough]]
-#elif defined(__clang__)
-#  define FMTQUILL_FALLTHROUGH [[clang::fallthrough]]
-#elif FMTQUILL_GCC_VERSION >= 700 && \
-    (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520)
-#  define FMTQUILL_FALLTHROUGH [[gnu::fallthrough]]
-#else
-#  define FMTQUILL_FALLTHROUGH
-#endif
-
-#ifndef FMTQUILL_DEPRECATED
-#  if FMTQUILL_HAS_CPP14_ATTRIBUTE(deprecated) || FMTQUILL_MSC_VERSION >= 1900
-#    define FMTQUILL_DEPRECATED [[deprecated]]
-#  else
-#    if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__)
-#      define FMTQUILL_DEPRECATED __attribute__((deprecated))
-#    elif FMTQUILL_MSC_VERSION
-#      define FMTQUILL_DEPRECATED __declspec(deprecated)
-#    else
-#      define FMTQUILL_DEPRECATED /* deprecated */
-#    endif
-#  endif
-#endif
-
-#ifndef FMTQUILL_NO_UNIQUE_ADDRESS
-#  if FMTQUILL_CPLUSPLUS >= 202002L
-#    if FMTQUILL_HAS_CPP_ATTRIBUTE(no_unique_address)
-#      define FMTQUILL_NO_UNIQUE_ADDRESS [[no_unique_address]]
-// VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485)
-#    elif (FMTQUILL_MSC_VERSION >= 1929) && !FMTQUILL_CLANG_VERSION
-#      define FMTQUILL_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
-#    endif
-#  endif
-#endif
-#ifndef FMTQUILL_NO_UNIQUE_ADDRESS
-#  define FMTQUILL_NO_UNIQUE_ADDRESS
-#endif
-
-// Visibility when compiled as a shared library/object.
-#if defined(FMTQUILL_LIB_EXPORT) || defined(FMTQUILL_SHARED)
-#  define FMTQUILL_SO_VISIBILITY(value) FMTQUILL_VISIBILITY(value)
-#else
-#  define FMTQUILL_SO_VISIBILITY(value)
-#endif
-
-#ifdef __has_builtin
-#  define FMTQUILL_HAS_BUILTIN(x) __has_builtin(x)
-#else
-#  define FMTQUILL_HAS_BUILTIN(x) 0
-#endif
-
-#if FMTQUILL_GCC_VERSION || FMTQUILL_CLANG_VERSION
-#  define FMTQUILL_NOINLINE __attribute__((noinline))
-#else
-#  define FMTQUILL_NOINLINE
-#endif
-
-#ifndef FMTQUILL_THROW
-#  if FMTQUILL_EXCEPTIONS
-#    if FMTQUILL_MSC_VERSION || defined(__NVCC__)
-FMTQUILL_BEGIN_NAMESPACE
-namespace detail {
-template <typename Exception> inline void do_throw(const Exception& x) {
-  // Silence unreachable code warnings in MSVC and NVCC because these
-  // are nearly impossible to fix in a generic code.
-  volatile bool b = true;
-  if (b) throw x;
-}
-}  // namespace detail
-FMTQUILL_END_NAMESPACE
-#      define FMTQUILL_THROW(x) detail::do_throw(x)
-#    else
-#      define FMTQUILL_THROW(x) throw x
-#    endif
-#  else
-#    define FMTQUILL_THROW(x) \
-      ::fmtquill::detail::assert_fail(__FILE__, __LINE__, (x).what())
-#  endif
-#endif
-
-#if FMTQUILL_EXCEPTIONS
-#  define FMTQUILL_TRY try
-#  define FMTQUILL_CATCH(x) catch (x)
-#else
-#  define FMTQUILL_TRY if (true)
-#  define FMTQUILL_CATCH(x) if (false)
-#endif
-
-#ifndef FMTQUILL_MAYBE_UNUSED
-#  if FMTQUILL_HAS_CPP17_ATTRIBUTE(maybe_unused)
-#    define FMTQUILL_MAYBE_UNUSED [[maybe_unused]]
-#  else
-#    define FMTQUILL_MAYBE_UNUSED
-#  endif
-#endif
-
-#ifndef FMTQUILL_USE_USER_DEFINED_LITERALS
-// EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs.
-//
-// GCC before 4.9 requires a space in `operator"" _a` which is invalid in later
-// compiler versions.
-#  if (FMTQUILL_HAS_FEATURE(cxx_user_literals) || FMTQUILL_GCC_VERSION >= 409 || \
-       FMTQUILL_MSC_VERSION >= 1900) &&                                     \
-      (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480)
-#    define FMTQUILL_USE_USER_DEFINED_LITERALS 1
-#  else
-#    define FMTQUILL_USE_USER_DEFINED_LITERALS 0
-#  endif
-#endif
-
-// Defining FMTQUILL_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of
-// integer formatter template instantiations to just one by only using the
-// largest integer type. This results in a reduction in binary size but will
-// cause a decrease in integer formatting performance.
-#if !defined(FMTQUILL_REDUCE_INT_INSTANTIATIONS)
-#  define FMTQUILL_REDUCE_INT_INSTANTIATIONS 0
-#endif
-
-// __builtin_clz is broken in clang with Microsoft CodeGen:
-// https://github.com/fmtlib/fmt/issues/519.
-#if !FMTQUILL_MSC_VERSION
-#  if FMTQUILL_HAS_BUILTIN(__builtin_clz) || FMTQUILL_GCC_VERSION || FMTQUILL_ICC_VERSION
-#    define FMTQUILL_BUILTIN_CLZ(n) __builtin_clz(n)
-#  endif
-#  if FMTQUILL_HAS_BUILTIN(__builtin_clzll) || FMTQUILL_GCC_VERSION || FMTQUILL_ICC_VERSION
-#    define FMTQUILL_BUILTIN_CLZLL(n) __builtin_clzll(n)
-#  endif
-#endif
-
-// __builtin_ctz is broken in Intel Compiler Classic on Windows:
-// https://github.com/fmtlib/fmt/issues/2510.
-#ifndef __ICL
-#  if FMTQUILL_HAS_BUILTIN(__builtin_ctz) || FMTQUILL_GCC_VERSION || FMTQUILL_ICC_VERSION || \
-      defined(__NVCOMPILER)
-#    define FMTQUILL_BUILTIN_CTZ(n) __builtin_ctz(n)
-#  endif
-#  if FMTQUILL_HAS_BUILTIN(__builtin_ctzll) || FMTQUILL_GCC_VERSION || \
-      FMTQUILL_ICC_VERSION || defined(__NVCOMPILER)
-#    define FMTQUILL_BUILTIN_CTZLL(n) __builtin_ctzll(n)
-#  endif
-#endif
-
-#if FMTQUILL_MSC_VERSION
-#  include <intrin.h>  // _BitScanReverse[64], _BitScanForward[64], _umul128
-#endif
-
-// Some compilers masquerade as both MSVC and GCC-likes or otherwise support
-// __builtin_clz and __builtin_clzll, so only define FMTQUILL_BUILTIN_CLZ using the
-// MSVC intrinsics if the clz and clzll builtins are not available.
-#if FMTQUILL_MSC_VERSION && !defined(FMTQUILL_BUILTIN_CLZLL) && \
-    !defined(FMTQUILL_BUILTIN_CTZLL)
-FMTQUILL_BEGIN_NAMESPACE
-namespace detail {
-// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
-#  if !defined(__clang__)
-#    pragma intrinsic(_BitScanForward)
-#    pragma intrinsic(_BitScanReverse)
-#    if defined(_WIN64)
-#      pragma intrinsic(_BitScanForward64)
-#      pragma intrinsic(_BitScanReverse64)
-#    endif
-#  endif
-
-inline auto clz(uint32_t x) -> int {
-  unsigned long r = 0;
-  _BitScanReverse(&r, x);
-  FMTQUILL_ASSERT(x != 0, "");
-  // Static analysis complains about using uninitialized data
-  // "r", but the only way that can happen is if "x" is 0,
-  // which the callers guarantee to not happen.
-  FMTQUILL_MSC_WARNING(suppress : 6102)
-  return 31 ^ static_cast<int>(r);
-}
-#  define FMTQUILL_BUILTIN_CLZ(n) detail::clz(n)
-
-inline auto clzll(uint64_t x) -> int {
-  unsigned long r = 0;
-#  ifdef _WIN64
-  _BitScanReverse64(&r, x);
-#  else
-  // Scan the high 32 bits.
-  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
-    return 63 ^ static_cast<int>(r + 32);
-  // Scan the low 32 bits.
-  _BitScanReverse(&r, static_cast<uint32_t>(x));
-#  endif
-  FMTQUILL_ASSERT(x != 0, "");
-  FMTQUILL_MSC_WARNING(suppress : 6102)  // Suppress a bogus static analysis warning.
-  return 63 ^ static_cast<int>(r);
-}
-#  define FMTQUILL_BUILTIN_CLZLL(n) detail::clzll(n)
-
-inline auto ctz(uint32_t x) -> int {
-  unsigned long r = 0;
-  _BitScanForward(&r, x);
-  FMTQUILL_ASSERT(x != 0, "");
-  FMTQUILL_MSC_WARNING(suppress : 6102)  // Suppress a bogus static analysis warning.
-  return static_cast<int>(r);
-}
-#  define FMTQUILL_BUILTIN_CTZ(n) detail::ctz(n)
-
-inline auto ctzll(uint64_t x) -> int {
-  unsigned long r = 0;
-  FMTQUILL_ASSERT(x != 0, "");
-  FMTQUILL_MSC_WARNING(suppress : 6102)  // Suppress a bogus static analysis warning.
-#  ifdef _WIN64
-  _BitScanForward64(&r, x);
-#  else
-  // Scan the low 32 bits.
-  if (_BitScanForward(&r, static_cast<uint32_t>(x))) return static_cast<int>(r);
-  // Scan the high 32 bits.
-  _BitScanForward(&r, static_cast<uint32_t>(x >> 32));
-  r += 32;
-#  endif
-  return static_cast<int>(r);
-}
-#  define FMTQUILL_BUILTIN_CTZLL(n) detail::ctzll(n)
-}  // namespace detail
-FMTQUILL_END_NAMESPACE
-#endif
-
-FMTQUILL_BEGIN_NAMESPACE
-namespace detail {
-
-FMTQUILL_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
-  ignore_unused(condition);
-#ifdef FMTQUILL_FUZZ
-  if (condition) throw std::runtime_error("fuzzing limit reached");
-#endif
-}
-
-template <typename CharT, CharT... C> struct string_literal {
-  static constexpr CharT value[sizeof...(C)] = {C...};
-  constexpr operator basic_string_view<CharT>() const {
-    return {value, sizeof...(C)};
-  }
-};
-
-#if FMTQUILL_CPLUSPLUS < 201703L
-template <typename CharT, CharT... C>
-constexpr CharT string_literal<CharT, C...>::value[sizeof...(C)];
-#endif
-
-// Implementation of std::bit_cast for pre-C++20.
-template <typename To, typename From, FMTQUILL_ENABLE_IF(sizeof(To) == sizeof(From))>
-FMTQUILL_CONSTEXPR20 auto bit_cast(const From& from) -> To {
-#ifdef __cpp_lib_bit_cast
-  if (is_constant_evaluated()) return std::bit_cast<To>(from);
-#endif
-  auto to = To();
-  // The cast suppresses a bogus -Wclass-memaccess on GCC.
-  std::memcpy(static_cast<void*>(&to), &from, sizeof(to));
-  return to;
-}
-
-inline auto is_big_endian() -> bool {
-#ifdef _WIN32
-  return false;
-#elif defined(__BIG_ENDIAN__)
-  return true;
-#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__)
-  return __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__;
-#else
-  struct bytes {
-    char data[sizeof(int)];
-  };
-  return bit_cast<bytes>(1).data[0] == 0;
-#endif
-}
-
-class uint128_fallback {
- private:
-  uint64_t lo_, hi_;
-
- public:
-  constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {}
-  constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {}
-
-  constexpr auto high() const noexcept -> uint64_t { return hi_; }
-  constexpr auto low() const noexcept -> uint64_t { return lo_; }
-
-  template <typename T, FMTQUILL_ENABLE_IF(std::is_integral<T>::value)>
-  constexpr explicit operator T() const {
-    return static_cast<T>(lo_);
-  }
-
-  friend constexpr auto operator==(const uint128_fallback& lhs,
-                                   const uint128_fallback& rhs) -> bool {
-    return lhs.hi_ == rhs.hi_ && lhs.lo_ == rhs.lo_;
-  }
-  friend constexpr auto operator!=(const uint128_fallback& lhs,
-                                   const uint128_fallback& rhs) -> bool {
-    return !(lhs == rhs);
-  }
-  friend constexpr auto operator>(const uint128_fallback& lhs,
-                                  const uint128_fallback& rhs) -> bool {
-    return lhs.hi_ != rhs.hi_ ? lhs.hi_ > rhs.hi_ : lhs.lo_ > rhs.lo_;
-  }
-  friend constexpr auto operator|(const uint128_fallback& lhs,
-                                  const uint128_fallback& rhs)
-      -> uint128_fallback {
-    return {lhs.hi_ | rhs.hi_, lhs.lo_ | rhs.lo_};
-  }
-  friend constexpr auto operator&(const uint128_fallback& lhs,
-                                  const uint128_fallback& rhs)
-      -> uint128_fallback {
-    return {lhs.hi_ & rhs.hi_, lhs.lo_ & rhs.lo_};
-  }
-  friend constexpr auto operator~(const uint128_fallback& n)
-      -> uint128_fallback {
-    return {~n.hi_, ~n.lo_};
-  }
-  friend auto operator+(const uint128_fallback& lhs,
-                        const uint128_fallback& rhs) -> uint128_fallback {
-    auto result = uint128_fallback(lhs);
-    result += rhs;
-    return result;
-  }
-  friend auto operator*(const uint128_fallback& lhs, uint32_t rhs)
-      -> uint128_fallback {
-    FMTQUILL_ASSERT(lhs.hi_ == 0, "");
-    uint64_t hi = (lhs.lo_ >> 32) * rhs;
-    uint64_t lo = (lhs.lo_ & ~uint32_t()) * rhs;
-    uint64_t new_lo = (hi << 32) + lo;
-    return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo};
-  }
-  friend auto operator-(const uint128_fallback& lhs, uint64_t rhs)
-      -> uint128_fallback {
-    return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs};
-  }
-  FMTQUILL_CONSTEXPR auto operator>>(int shift) const -> uint128_fallback {
-    if (shift == 64) return {0, hi_};
-    if (shift > 64) return uint128_fallback(0, hi_) >> (shift - 64);
-    return {hi_ >> shift, (hi_ << (64 - shift)) | (lo_ >> shift)};
-  }
-  FMTQUILL_CONSTEXPR auto operator<<(int shift) const -> uint128_fallback {
-    if (shift == 64) return {lo_, 0};
-    if (shift > 64) return uint128_fallback(lo_, 0) << (shift - 64);
-    return {hi_ << shift | (lo_ >> (64 - shift)), (lo_ << shift)};
-  }
-  FMTQUILL_CONSTEXPR auto operator>>=(int shift) -> uint128_fallback& {
-    return *this = *this >> shift;
-  }
-  FMTQUILL_CONSTEXPR void operator+=(uint128_fallback n) {
-    uint64_t new_lo = lo_ + n.lo_;
-    uint64_t new_hi = hi_ + n.hi_ + (new_lo < lo_ ? 1 : 0);
-    FMTQUILL_ASSERT(new_hi >= hi_, "");
-    lo_ = new_lo;
-    hi_ = new_hi;
-  }
-  FMTQUILL_CONSTEXPR void operator&=(uint128_fallback n) {
-    lo_ &= n.lo_;
-    hi_ &= n.hi_;
-  }
-
-  FMTQUILL_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& {
-    if (is_constant_evaluated()) {
-      lo_ += n;
-      hi_ += (lo_ < n ? 1 : 0);
-      return *this;
-    }
-#if FMTQUILL_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__)
-    unsigned long long carry;
-    lo_ = __builtin_addcll(lo_, n, 0, &carry);
-    hi_ += carry;
-#elif FMTQUILL_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__)
-    unsigned long long result;
-    auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result);
-    lo_ = result;
-    hi_ += carry;
-#elif defined(_MSC_VER) && defined(_M_X64)
-    auto carry = _addcarry_u64(0, lo_, n, &lo_);
-    _addcarry_u64(carry, hi_, 0, &hi_);
-#else
-    lo_ += n;
-    hi_ += (lo_ < n ? 1 : 0);
-#endif
-    return *this;
-  }
-};
-
-using uint128_t = conditional_t<FMTQUILL_USE_INT128, uint128_opt, uint128_fallback>;
-
-#ifdef UINTPTR_MAX
-using uintptr_t = ::uintptr_t;
-#else
-using uintptr_t = uint128_t;
-#endif
-
-// Returns the largest possible value for type T. Same as
-// std::numeric_limits<T>::max() but shorter and not affected by the max macro.
-template <typename T> constexpr auto max_value() -> T {
-  return (std::numeric_limits<T>::max)();
-}
-template <typename T> constexpr auto num_bits() -> int {
-  return std::numeric_limits<T>::digits;
-}
-// std::numeric_limits<T>::digits may return 0 for 128-bit ints.
-template <> constexpr auto num_bits<int128_opt>() -> int { return 128; }
-template <> constexpr auto num_bits<uint128_t>() -> int { return 128; }
-
-// A heterogeneous bit_cast used for converting 96-bit long double to uint128_t
-// and 128-bit pointers to uint128_fallback.
-template <typename To, typename From, FMTQUILL_ENABLE_IF(sizeof(To) > sizeof(From))>
-inline auto bit_cast(const From& from) -> To {
-  constexpr auto size = static_cast<int>(sizeof(From) / sizeof(unsigned));
-  struct data_t {
-    unsigned value[static_cast<unsigned>(size)];
-  } data = bit_cast<data_t>(from);
-  auto result = To();
-  if (const_check(is_big_endian())) {
-    for (int i = 0; i < size; ++i)
-      result = (result << num_bits<unsigned>()) | data.value[i];
-  } else {
-    for (int i = size - 1; i >= 0; --i)
-      result = (result << num_bits<unsigned>()) | data.value[i];
-  }
-  return result;
-}
-
-template <typename UInt>
-FMTQUILL_CONSTEXPR20 inline auto countl_zero_fallback(UInt n) -> int {
-  int lz = 0;
-  constexpr UInt msb_mask = static_cast<UInt>(1) << (num_bits<UInt>() - 1);
-  for (; (n & msb_mask) == 0; n <<= 1) lz++;
-  return lz;
-}
-
-FMTQUILL_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int {
-#ifdef FMTQUILL_BUILTIN_CLZ
-  if (!is_constant_evaluated()) return FMTQUILL_BUILTIN_CLZ(n);
-#endif
-  return countl_zero_fallback(n);
-}
-
-FMTQUILL_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int {
-#ifdef FMTQUILL_BUILTIN_CLZLL
-  if (!is_constant_evaluated()) return FMTQUILL_BUILTIN_CLZLL(n);
-#endif
-  return countl_zero_fallback(n);
-}
-
-FMTQUILL_INLINE void assume(bool condition) {
-  (void)condition;
-#if FMTQUILL_HAS_BUILTIN(__builtin_assume) && !FMTQUILL_ICC_VERSION
-  __builtin_assume(condition);
-#elif FMTQUILL_GCC_VERSION
-  if (!condition) __builtin_unreachable();
-#endif
-}
-
-// An approximation of iterator_t for pre-C++20 systems.
-template <typename T>
-using iterator_t = decltype(std::begin(std::declval<T&>()));
-template <typename T> using sentinel_t = decltype(std::end(std::declval<T&>()));
-
-// A workaround for std::string not having mutable data() until C++17.
-template <typename Char>
-inline auto get_data(std::basic_string<Char>& s) -> Char* {
-  return &s[0];
-}
-template <typename Container>
-inline auto get_data(Container& c) -> typename Container::value_type* {
-  return c.data();
-}
-
-// Attempts to reserve space for n extra characters in the output range.
-// Returns a pointer to the reserved range or a reference to it.
-template <typename Container, FMTQUILL_ENABLE_IF(is_contiguous<Container>::value)>
-#if FMTQUILL_CLANG_VERSION >= 307 && !FMTQUILL_ICC_VERSION
-__attribute__((no_sanitize("undefined")))
-#endif
-inline auto
-reserve(std::back_insert_iterator<Container> it, size_t n) ->
-    typename Container::value_type* {
-  Container& c = get_container(it);
-  size_t size = c.size();
-  c.resize(size + n);
-  return get_data(c) + size;
-}
-
-template <typename T>
-inline auto reserve(buffer_appender<T> it, size_t n) -> buffer_appender<T> {
-  buffer<T>& buf = get_container(it);
-  buf.try_reserve(buf.size() + n);
-  return it;
-}
-
-template <typename Iterator>
-constexpr auto reserve(Iterator& it, size_t) -> Iterator& {
-  return it;
-}
-
-template <typename OutputIt>
-using reserve_iterator =
-    remove_reference_t<decltype(reserve(std::declval<OutputIt&>(), 0))>;
-
-template <typename T, typename OutputIt>
-constexpr auto to_pointer(OutputIt, size_t) -> T* {
-  return nullptr;
-}
-template <typename T> auto to_pointer(buffer_appender<T> it, size_t n) -> T* {
-  buffer<T>& buf = get_container(it);
-  auto size = buf.size();
-  if (buf.capacity() < size + n) return nullptr;
-  buf.try_resize(size + n);
-  return buf.data() + size;
-}
-
-template <typename Container, FMTQUILL_ENABLE_IF(is_contiguous<Container>::value)>
-inline auto base_iterator(std::back_insert_iterator<Container> it,
-                          typename Container::value_type*)
-    -> std::back_insert_iterator<Container> {
-  return it;
-}
-
-template <typename Iterator>
-constexpr auto base_iterator(Iterator, Iterator it) -> Iterator {
-  return it;
-}
-
-// <algorithm> is spectacularly slow to compile in C++20 so use a simple fill_n
-// instead (#1998).
-template <typename OutputIt, typename Size, typename T>
-FMTQUILL_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value)
-    -> OutputIt {
-  for (Size i = 0; i < count; ++i) *out++ = value;
-  return out;
-}
-template <typename T, typename Size>
-FMTQUILL_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* {
-  if (is_constant_evaluated()) {
-    return fill_n<T*, Size, T>(out, count, value);
-  }
-  std::memset(out, value, to_unsigned(count));
-  return out + count;
-}
-
-#ifdef __cpp_char8_t
-using char8_type = char8_t;
-#else
-enum char8_type : unsigned char {};
-#endif
-
-template <typename OutChar, typename InputIt, typename OutputIt>
-FMTQUILL_CONSTEXPR FMTQUILL_NOINLINE auto copy_str_noinline(InputIt begin, InputIt end,
-                                                  OutputIt out) -> OutputIt {
-  return copy_str<OutChar>(begin, end, out);
-}
-
-// A public domain branchless UTF-8 decoder by Christopher Wellons:
-// https://github.com/skeeto/branchless-utf8
-/* Decode the next character, c, from s, reporting errors in e.
- *
- * Since this is a branchless decoder, four bytes will be read from the
- * buffer regardless of the actual length of the next character. This
- * means the buffer _must_ have at least three bytes of zero padding
- * following the end of the data stream.
- *
- * Errors are reported in e, which will be non-zero if the parsed
- * character was somehow invalid: invalid byte sequence, non-canonical
- * encoding, or a surrogate half.
- *
- * The function returns a pointer to the next character. When an error
- * occurs, this pointer will be a guess that depends on the particular
- * error, but it will always advance at least one byte.
- */
-FMTQUILL_CONSTEXPR inline auto utf8_decode(const char* s, uint32_t* c, int* e)
-    -> const char* {
-  constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};
-  constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};
-  constexpr const int shiftc[] = {0, 18, 12, 6, 0};
-  constexpr const int shifte[] = {0, 6, 4, 2, 0};
-
-  int len = "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0\0\0\2\2\2\2\3\3\4"
-      [static_cast<unsigned char>(*s) >> 3];
-  // Compute the pointer to the next character early so that the next
-  // iteration can start working on the next character. Neither Clang
-  // nor GCC figure out this reordering on their own.
-  const char* next = s + len + !len;
-
-  using uchar = unsigned char;
-
-  // Assume a four-byte character and load four bytes. Unused bits are
-  // shifted out.
-  *c = uint32_t(uchar(s[0]) & masks[len]) << 18;
-  *c |= uint32_t(uchar(s[1]) & 0x3f) << 12;
-  *c |= uint32_t(uchar(s[2]) & 0x3f) << 6;
-  *c |= uint32_t(uchar(s[3]) & 0x3f) << 0;
-  *c >>= shiftc[len];
-
-  // Accumulate the various error conditions.
-  *e = (*c < mins[len]) << 6;       // non-canonical encoding
-  *e |= ((*c >> 11) == 0x1b) << 7;  // surrogate half?
-  *e |= (*c > 0x10FFFF) << 8;       // out of range?
-  *e |= (uchar(s[1]) & 0xc0) >> 2;
-  *e |= (uchar(s[2]) & 0xc0) >> 4;
-  *e |= uchar(s[3]) >> 6;
-  *e ^= 0x2a;  // top two bits of each tail byte correct?
-  *e >>= shifte[len];
-
-  return next;
-}
-
-constexpr FMTQUILL_INLINE_VARIABLE uint32_t invalid_code_point = ~uint32_t();
-
-// Invokes f(cp, sv) for every code point cp in s with sv being the string view
-// corresponding to the code point. cp is invalid_code_point on error.
-template <typename F>
-FMTQUILL_CONSTEXPR void for_each_codepoint(string_view s, F f) {
-  auto decode = [f](const char* buf_ptr, const char* ptr) {
-    auto cp = uint32_t();
-    auto error = 0;
-    auto end = utf8_decode(buf_ptr, &cp, &error);
-    bool result = f(error ? invalid_code_point : cp,
-                    string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr)));
-    return result ? (error ? buf_ptr + 1 : end) : nullptr;
-  };
-  auto p = s.data();
-  const size_t block_size = 4;  // utf8_decode always reads blocks of 4 chars.
-  if (s.size() >= block_size) {
-    for (auto end = p + s.size() - block_size + 1; p < end;) {
-      p = decode(p, p);
-      if (!p) return;
-    }
-  }
-  if (auto num_chars_left = s.data() + s.size() - p) {
-    char buf[2 * block_size - 1] = {};
-    copy_str<char>(p, p + num_chars_left, buf);
-    const char* buf_ptr = buf;
-    do {
-      auto end = decode(buf_ptr, p);
-      if (!end) return;
-      p += end - buf_ptr;
-      buf_ptr = end;
-    } while (buf_ptr - buf < num_chars_left);
-  }
-}
-
-template <typename Char>
-inline auto compute_width(basic_string_view<Char> s) -> size_t {
-  return s.size();
-}
-
-// Computes approximate display width of a UTF-8 string.
-FMTQUILL_CONSTEXPR inline auto compute_width(string_view s) -> size_t {
-  size_t num_code_points = 0;
-  // It is not a lambda for compatibility with C++14.
-  struct count_code_points {
-    size_t* count;
-    FMTQUILL_CONSTEXPR auto operator()(uint32_t cp, string_view) const -> bool {
-      *count += detail::to_unsigned(
-          1 +
-          (cp >= 0x1100 &&
-           (cp <= 0x115f ||  // Hangul Jamo init. consonants
-            cp == 0x2329 ||  // LEFT-POINTING ANGLE BRACKET
-            cp == 0x232a ||  // RIGHT-POINTING ANGLE BRACKET
-            // CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE:
-            (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) ||
-            (cp >= 0xac00 && cp <= 0xd7a3) ||    // Hangul Syllables
-            (cp >= 0xf900 && cp <= 0xfaff) ||    // CJK Compatibility Ideographs
-            (cp >= 0xfe10 && cp <= 0xfe19) ||    // Vertical Forms
-            (cp >= 0xfe30 && cp <= 0xfe6f) ||    // CJK Compatibility Forms
-            (cp >= 0xff00 && cp <= 0xff60) ||    // Fullwidth Forms
-            (cp >= 0xffe0 && cp <= 0xffe6) ||    // Fullwidth Forms
-            (cp >= 0x20000 && cp <= 0x2fffd) ||  // CJK
-            (cp >= 0x30000 && cp <= 0x3fffd) ||
-            // Miscellaneous Symbols and Pictographs + Emoticons:
-            (cp >= 0x1f300 && cp <= 0x1f64f) ||
-            // Supplemental Symbols and Pictographs:
-            (cp >= 0x1f900 && cp <= 0x1f9ff))));
-      return true;
-    }
-  };
-  // We could avoid branches by using utf8_decode directly.
-  for_each_codepoint(s, count_code_points{&num_code_points});
-  return num_code_points;
-}
-
-inline auto compute_width(basic_string_view<char8_type> s) -> size_t {
-  return compute_width(
-      string_view(reinterpret_cast<const char*>(s.data()), s.size()));
-}
-
-template <typename Char>
-inline auto code_point_index(basic_string_view<Char> s, size_t n) -> size_t {
-  size_t size = s.size();
-  return n < size ? n : size;
-}
-
-// Calculates the index of the nth code point in a UTF-8 string.
-inline auto code_point_index(string_view s, size_t n) -> size_t {
-  size_t result = s.size();
-  const char* begin = s.begin();
-  for_each_codepoint(s, [begin, &n, &result](uint32_t, string_view sv) {
-    if (n != 0) {
-      --n;
-      return true;
-    }
-    result = to_unsigned(sv.begin() - begin);
-    return false;
-  });
-  return result;
-}
-
-inline auto code_point_index(basic_string_view<char8_type> s, size_t n)
-    -> size_t {
-  return code_point_index(
-      string_view(reinterpret_cast<const char*>(s.data()), s.size()), n);
-}
-
-template <typename T> struct is_integral : std::is_integral<T> {};
-template <> struct is_integral<int128_opt> : std::true_type {};
-template <> struct is_integral<uint128_t> : std::true_type {};
-
-template <typename T>
-using is_signed =
-    std::integral_constant<bool, std::numeric_limits<T>::is_signed ||
-                                     std::is_same<T, int128_opt>::value>;
-
-template <typename T>
-using is_integer =
-    bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
-                  !std::is_same<T, char>::value &&
-                  !std::is_same<T, wchar_t>::value>;
-
-#ifndef FMTQUILL_USE_FLOAT
-#  define FMTQUILL_USE_FLOAT 1
-#endif
-#ifndef FMTQUILL_USE_DOUBLE
-#  define FMTQUILL_USE_DOUBLE 1
-#endif
-#ifndef FMTQUILL_USE_LONG_DOUBLE
-#  define FMTQUILL_USE_LONG_DOUBLE 1
-#endif
-
-#ifndef FMTQUILL_USE_FLOAT128
-#  ifdef __clang__
-// Clang emulates GCC, so it has to appear early.
-#    if FMTQUILL_HAS_INCLUDE(<quadmath.h>)
-#      define FMTQUILL_USE_FLOAT128 1
-#    endif
-#  elif defined(__GNUC__)
-// GNU C++:
-#    if defined(_GLIBCXX_USE_FLOAT128) && !defined(__STRICT_ANSI__)
-#      define FMTQUILL_USE_FLOAT128 1
-#    endif
-#  endif
-#  ifndef FMTQUILL_USE_FLOAT128
-#    define FMTQUILL_USE_FLOAT128 0
-#  endif
-#endif
-
-#if FMTQUILL_USE_FLOAT128
-using float128 = __float128;
-#else
-using float128 = void;
-#endif
-template <typename T> using is_float128 = std::is_same<T, float128>;
-
-template <typename T>
-using is_floating_point =
-    bool_constant<std::is_floating_point<T>::value || is_float128<T>::value>;
-
-template <typename T, bool = std::is_floating_point<T>::value>
-struct is_fast_float : bool_constant<std::numeric_limits<T>::is_iec559 &&
-                                     sizeof(T) <= sizeof(double)> {};
-template <typename T> struct is_fast_float<T, false> : std::false_type {};
-
-template <typename T>
-using is_double_double = bool_constant<std::numeric_limits<T>::digits == 106>;
-
-#ifndef FMTQUILL_USE_FULL_CACHE_DRAGONBOX
-#  define FMTQUILL_USE_FULL_CACHE_DRAGONBOX 0
-#endif
-
-template <typename T>
-template <typename U>
-void buffer<T>::append(const U* begin, const U* end) {
-  while (begin != end) {
-    auto count = to_unsigned(end - begin);
-    try_reserve(size_ + count);
-    auto free_cap = capacity_ - size_;
-    if (free_cap < count) count = free_cap;
-    std::uninitialized_copy_n(begin, count, ptr_ + size_);
-    size_ += count;
-    begin += count;
-  }
-}
-
-template <typename T, typename Enable = void>
-struct is_locale : std::false_type {};
-template <typename T>
-struct is_locale<T, void_t<decltype(T::classic())>> : std::true_type {};
-}  // namespace detail
-
-FMTQUILL_BEGIN_EXPORT
-
-// The number of characters to store in the basic_memory_buffer object itself
-// to avoid dynamic memory allocation.
-enum { inline_buffer_size = 500 };
-
-/**
-  \rst
-  A dynamically growing memory buffer for trivially copyable/constructible types
-  with the first ``SIZE`` elements stored in the object itself.
-
-  You can use the ``memory_buffer`` type alias for ``char`` instead.
-
-  **Example**::
-
-     auto out = fmtquill::memory_buffer();
-     fmtquill::format_to(std::back_inserter(out), "The answer is {}.", 42);
-
-  This will append the following output to the ``out`` object:
-
-  .. code-block:: none
-
-     The answer is 42.
-
-  The output can be converted to an ``std::string`` with ``to_string(out)``.
-  \endrst
- */
-template <typename T, size_t SIZE = inline_buffer_size,
-          typename Allocator = std::allocator<T>>
-class basic_memory_buffer final : public detail::buffer<T> {
- private:
-  T store_[SIZE];
-
-  // Don't inherit from Allocator to avoid generating type_info for it.
-  FMTQUILL_NO_UNIQUE_ADDRESS Allocator alloc_;
-
-  // Deallocate memory allocated by the buffer.
-  FMTQUILL_CONSTEXPR20 void deallocate() {
-    T* data = this->data();
-    if (data != store_) alloc_.deallocate(data, this->capacity());
-  }
-
- protected:
-  FMTQUILL_CONSTEXPR20 void grow(size_t size) override {
-    detail::abort_fuzzing_if(size > 5000);
-    const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
-    size_t old_capacity = this->capacity();
-    size_t new_capacity = old_capacity + old_capacity / 2;
-    if (size > new_capacity)
-      new_capacity = size;
-    else if (new_capacity > max_size)
-      new_capacity = size > max_size ? size : max_size;
-    T* old_data = this->data();
-    T* new_data =
-        std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);
-    // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481).
-    detail::assume(this->size() <= new_capacity);
-    // The following code doesn't throw, so the raw pointer above doesn't leak.
-    std::uninitialized_copy_n(old_data, this->size(), new_data);
-    this->set(new_data, new_capacity);
-    // deallocate must not throw according to the standard, but even if it does,
-    // the buffer already uses the new storage and will deallocate it in
-    // destructor.
-    if (old_data != store_) alloc_.deallocate(old_data, old_capacity);
-  }
-
- public:
-  using value_type = T;
-  using const_reference = const T&;
-
-  FMTQUILL_CONSTEXPR20 explicit basic_memory_buffer(
-      const Allocator& alloc = Allocator())
-      : alloc_(alloc) {
-    this->set(store_, SIZE);
-    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
-  }
-  FMTQUILL_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }
-
- private:
-  // Move data from other to this buffer.
-  FMTQUILL_CONSTEXPR20 void move(basic_memory_buffer& other) {
-    alloc_ = std::move(other.alloc_);
-    T* data = other.data();
-    size_t size = other.size(), capacity = other.capacity();
-    if (data == other.store_) {
-      this->set(store_, capacity);
-      detail::copy_str<T>(other.store_, other.store_ + size, store_);
-    } else {
-      this->set(data, capacity);
-      // Set pointer to the inline array so that delete is not called
-      // when deallocating.
-      other.set(other.store_, 0);
-      other.clear();
-    }
-    this->resize(size);
-  }
-
- public:
-  /**
-    \rst
-    Constructs a :class:`fmtquill::basic_memory_buffer` object moving the content
-    of the other object to it.
-    \endrst
-   */
-  FMTQUILL_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept {
-    move(other);
-  }
-
-  /**
-    \rst
-    Moves the content of the other ``basic_memory_buffer`` object to this one.
-    \endrst
-   */
-  auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& {
-    FMTQUILL_ASSERT(this != &other, "");
-    deallocate();
-    move(other);
-    return *this;
-  }
-
-  // Returns a copy of the allocator associated with this buffer.
-  auto get_allocator() const -> Allocator { return alloc_; }
-
-  /**
-    Resizes the buffer to contain *count* elements. If T is a POD type new
-    elements may not be initialized.
-   */
-  FMTQUILL_CONSTEXPR20 void resize(size_t count) { this->try_resize(count); }
-
-  /** Increases the buffer capacity to *new_capacity*. */
-  void reserve(size_t new_capacity) { this->try_reserve(new_capacity); }
-
-  using detail::buffer<T>::append;
-  template <typename ContiguousRange>
-  void append(const ContiguousRange& range) {
-    append(range.data(), range.data() + range.size());
-  }
-};
-
-using memory_buffer = basic_memory_buffer<char>;
-
-template <typename T, size_t SIZE, typename Allocator>
-struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>> : std::true_type {
-};
-
-FMTQUILL_END_EXPORT
-namespace detail {
-FMTQUILL_API auto write_console(int fd, string_view text) -> bool;
-FMTQUILL_API auto write_console(std::FILE* f, string_view text) -> bool;
-FMTQUILL_API void print(std::FILE*, string_view);
-}  // namespace detail
-
-FMTQUILL_BEGIN_EXPORT
-
-// Suppress a misleading warning in older versions of clang.
-#if FMTQUILL_CLANG_VERSION
-#  pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
-
-/** An error reported from a formatting function. */
-class FMTQUILL_SO_VISIBILITY("default") format_error : public std::runtime_error {
- public:
-  using std::runtime_error::runtime_error;
-};
-
-namespace detail_exported {
-#if FMTQUILL_USE_NONTYPE_TEMPLATE_ARGS
-template <typename Char, size_t N> struct fixed_string {
-  constexpr fixed_string(const Char (&str)[N]) {
-    detail::copy_str<Char, const Char*, Char*>(static_cast<const Char*>(str),
-                                               str + N, data);
-  }
-  Char data[N] = {};
-};
-#endif
-
-// Converts a compile-time string to basic_string_view.
-template <typename Char, size_t N>
-constexpr auto compile_string_to_view(const Char (&s)[N])
-    -> basic_string_view<Char> {
-  // Remove trailing NUL character if needed. Won't be present if this is used
-  // with a raw character array (i.e. not defined as a string).
-  return {s, N - (std::char_traits<Char>::to_int_type(s[N - 1]) == 0 ? 1 : 0)};
-}
-template <typename Char>
-constexpr auto compile_string_to_view(detail::std_string_view<Char> s)
-    -> basic_string_view<Char> {
-  return {s.data(), s.size()};
-}
-}  // namespace detail_exported
-
-class loc_value {
- private:
-  basic_format_arg<format_context> value_;
-
- public:
-  template <typename T, FMTQUILL_ENABLE_IF(!detail::is_float128<T>::value)>
-  loc_value(T value) : value_(detail::make_arg<format_context>(value)) {}
-
-  template <typename T, FMTQUILL_ENABLE_IF(detail::is_float128<T>::value)>
-  loc_value(T) {}
-
-  template <typename Visitor> auto visit(Visitor&& vis) -> decltype(vis(0)) {
-    return visit_format_arg(vis, value_);
-  }
-};
-
-// A locale facet that formats values in UTF-8.
-// It is parameterized on the locale to avoid the heavy <locale> include.
-template <typename Locale> class format_facet : public Locale::facet {
- private:
-  std::string separator_;
-  std::string grouping_;
-  std::string decimal_point_;
-
- protected:
-  virtual auto do_put(appender out, loc_value val,
-                      const format_specs<>& specs) const -> bool;
-
- public:
-  static FMTQUILL_API typename Locale::id id;
-
-  explicit format_facet(Locale& loc);
-  explicit format_facet(string_view sep = "",
-                        std::initializer_list<unsigned char> g = {3},
-                        std::string decimal_point = ".")
-      : separator_(sep.data(), sep.size()),
-        grouping_(g.begin(), g.end()),
-        decimal_point_(decimal_point) {}
-
-  auto put(appender out, loc_value val, const format_specs<>& specs) const
-      -> bool {
-    return do_put(out, val, specs);
-  }
-};
-
-namespace detail {
-
-// Returns true if value is negative, false otherwise.
-// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
-template <typename T, FMTQUILL_ENABLE_IF(is_signed<T>::value)>
-constexpr auto is_negative(T value) -> bool {
-  return value < 0;
-}
-template <typename T, FMTQUILL_ENABLE_IF(!is_signed<T>::value)>
-constexpr auto is_negative(T) -> bool {
-  return false;
-}
-
-template <typename T>
-FMTQUILL_CONSTEXPR auto is_supported_floating_point(T) -> bool {
-  if (std::is_same<T, float>()) return FMTQUILL_USE_FLOAT;
-  if (std::is_same<T, double>()) return FMTQUILL_USE_DOUBLE;
-  if (std::is_same<T, long double>()) return FMTQUILL_USE_LONG_DOUBLE;
-  return true;
-}
-
-// Smallest of uint32_t, uint64_t, uint128_t that is large enough to
-// represent all values of an integral type T.
-template <typename T>
-using uint32_or_64_or_128_t =
-    conditional_t<num_bits<T>() <= 32 && !FMTQUILL_REDUCE_INT_INSTANTIATIONS,
-                  uint32_t,
-                  conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>>;
-template <typename T>
-using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>;
-
-#define FMTQUILL_POWERS_OF_10(factor)                                  \
-  factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
-      (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
-      (factor) * 100000000, (factor) * 1000000000
-
-// Converts value in the range [0, 100) to a string.
-constexpr auto digits2(size_t value) -> const char* {
-  // GCC generates slightly better code when value is pointer-size.
-  return &"0001020304050607080910111213141516171819"
-         "2021222324252627282930313233343536373839"
-         "4041424344454647484950515253545556575859"
-         "6061626364656667686970717273747576777879"
-         "8081828384858687888990919293949596979899"[value * 2];
-}
-
-// Sign is a template parameter to workaround a bug in gcc 4.8.
-template <typename Char, typename Sign> constexpr auto sign(Sign s) -> Char {
-#if !FMTQUILL_GCC_VERSION || FMTQUILL_GCC_VERSION >= 604
-  static_assert(std::is_same<Sign, sign_t>::value, "");
-#endif
-  return static_cast<Char>("\0-+ "[s]);
-}
-
-template <typename T> FMTQUILL_CONSTEXPR auto count_digits_fallback(T n) -> int {
-  int count = 1;
-  for (;;) {
-    // Integer division is slow so do it for a group of four digits instead
-    // of for every digit. The idea comes from the talk by Alexandrescu
-    // "Three Optimization Tips for C++". See speed-test for a comparison.
-    if (n < 10) return count;
-    if (n < 100) return count + 1;
-    if (n < 1000) return count + 2;
-    if (n < 10000) return count + 3;
-    n /= 10000u;
-    count += 4;
-  }
-}
-#if FMTQUILL_USE_INT128
-FMTQUILL_CONSTEXPR inline auto count_digits(uint128_opt n) -> int {
-  return count_digits_fallback(n);
-}
-#endif
-
-#ifdef FMTQUILL_BUILTIN_CLZLL
-// It is a separate function rather than a part of count_digits to workaround
-// the lack of static constexpr in constexpr functions.
-inline auto do_count_digits(uint64_t n) -> int {
-  // This has comparable performance to the version by Kendall Willets
-  // (https://github.com/fmtlib/format-benchmark/blob/master/digits10)
-  // but uses smaller tables.
-  // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).
-  static constexpr uint8_t bsr2log10[] = {
-      1,  1,  1,  2,  2,  2,  3,  3,  3,  4,  4,  4,  4,  5,  5,  5,
-      6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9,  10, 10, 10,
-      10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
-      15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};
-  auto t = bsr2log10[FMTQUILL_BUILTIN_CLZLL(n | 1) ^ 63];
-  static constexpr const uint64_t zero_or_powers_of_10[] = {
-      0, 0, FMTQUILL_POWERS_OF_10(1U), FMTQUILL_POWERS_OF_10(1000000000ULL),
-      10000000000000000000ULL};
-  return t - (n < zero_or_powers_of_10[t]);
-}
-#endif
-
-// Returns the number of decimal digits in n. Leading zeros are not counted
-// except for n == 0 in which case count_digits returns 1.
-FMTQUILL_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int {
-#ifdef FMTQUILL_BUILTIN_CLZLL
-  if (!is_constant_evaluated()) {
-    return do_count_digits(n);
-  }
-#endif
-  return count_digits_fallback(n);
-}
-
-// Counts the number of digits in n. BITS = log2(radix).
-template <int BITS, typename UInt>
-FMTQUILL_CONSTEXPR auto count_digits(UInt n) -> int {
-#ifdef FMTQUILL_BUILTIN_CLZ
-  if (!is_constant_evaluated() && num_bits<UInt>() == 32)
-    return (FMTQUILL_BUILTIN_CLZ(static_cast<uint32_t>(n) | 1) ^ 31) / BITS + 1;
-#endif
-  // Lambda avoids unreachable code warnings from NVHPC.
-  return [](UInt m) {
-    int num_digits = 0;
-    do {
-      ++num_digits;
-    } while ((m >>= BITS) != 0);
-    return num_digits;
-  }(n);
-}
-
-#ifdef FMTQUILL_BUILTIN_CLZ
-// It is a separate function rather than a part of count_digits to workaround
-// the lack of static constexpr in constexpr functions.
-FMTQUILL_INLINE auto do_count_digits(uint32_t n) -> int {
-// An optimization by Kendall Willets from https://bit.ly/3uOIQrB.
-// This increments the upper 32 bits (log10(T) - 1) when >= T is added.
-#  define FMTQUILL_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
-  static constexpr uint64_t table[] = {
-      FMTQUILL_INC(0),          FMTQUILL_INC(0),          FMTQUILL_INC(0),           // 8
-      FMTQUILL_INC(10),         FMTQUILL_INC(10),         FMTQUILL_INC(10),          // 64
-      FMTQUILL_INC(100),        FMTQUILL_INC(100),        FMTQUILL_INC(100),         // 512
-      FMTQUILL_INC(1000),       FMTQUILL_INC(1000),       FMTQUILL_INC(1000),        // 4096
-      FMTQUILL_INC(10000),      FMTQUILL_INC(10000),      FMTQUILL_INC(10000),       // 32k
-      FMTQUILL_INC(100000),     FMTQUILL_INC(100000),     FMTQUILL_INC(100000),      // 256k
-      FMTQUILL_INC(1000000),    FMTQUILL_INC(1000000),    FMTQUILL_INC(1000000),     // 2048k
-      FMTQUILL_INC(10000000),   FMTQUILL_INC(10000000),   FMTQUILL_INC(10000000),    // 16M
-      FMTQUILL_INC(100000000),  FMTQUILL_INC(100000000),  FMTQUILL_INC(100000000),   // 128M
-      FMTQUILL_INC(1000000000), FMTQUILL_INC(1000000000), FMTQUILL_INC(1000000000),  // 1024M
-      FMTQUILL_INC(1000000000), FMTQUILL_INC(1000000000)                        // 4B
-  };
-  auto inc = table[FMTQUILL_BUILTIN_CLZ(n | 1) ^ 31];
-  return static_cast<int>((n + inc) >> 32);
-}
-#endif
-
-// Optional version of count_digits for better performance on 32-bit platforms.
-FMTQUILL_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int {
-#ifdef FMTQUILL_BUILTIN_CLZ
-  if (!is_constant_evaluated()) {
-    return do_count_digits(n);
-  }
-#endif
-  return count_digits_fallback(n);
-}
-
-template <typename Int> constexpr auto digits10() noexcept -> int {
-  return std::numeric_limits<Int>::digits10;
-}
-template <> constexpr auto digits10<int128_opt>() noexcept -> int { return 38; }
-template <> constexpr auto digits10<uint128_t>() noexcept -> int { return 38; }
-
-template <typename Char> struct thousands_sep_result {
-  std::string grouping;
-  Char thousands_sep;
-};
-
-template <typename Char>
-FMTQUILL_API auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char>;
-template <typename Char>
-inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<Char> {
-  auto result = thousands_sep_impl<char>(loc);
-  return {result.grouping, Char(result.thousands_sep)};
-}
-template <>
-inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<wchar_t> {
-  return thousands_sep_impl<wchar_t>(loc);
-}
-
-template <typename Char>
-FMTQUILL_API auto decimal_point_impl(locale_ref loc) -> Char;
-template <typename Char> inline auto decimal_point(locale_ref loc) -> Char {
-  return Char(decimal_point_impl<char>(loc));
-}
-template <> inline auto decimal_point(locale_ref loc) -> wchar_t {
-  return decimal_point_impl<wchar_t>(loc);
-}
-
-// Compares two characters for equality.
-template <typename Char> auto equal2(const Char* lhs, const char* rhs) -> bool {
-  return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]);
-}
-inline auto equal2(const char* lhs, const char* rhs) -> bool {
-  return memcmp(lhs, rhs, 2) == 0;
-}
-
-// Copies two characters from src to dst.
-template <typename Char>
-FMTQUILL_CONSTEXPR20 FMTQUILL_INLINE void copy2(Char* dst, const char* src) {
-  if (!is_constant_evaluated() && sizeof(Char) == sizeof(char)) {
-    memcpy(dst, src, 2);
-    return;
-  }
-  *dst++ = static_cast<Char>(*src++);
-  *dst = static_cast<Char>(*src);
-}
-
-template <typename Iterator> struct format_decimal_result {
-  Iterator begin;
-  Iterator end;
-};
-
-// Formats a decimal unsigned integer value writing into out pointing to a
-// buffer of specified size. The caller must ensure that the buffer is large
-// enough.
-template <typename Char, typename UInt>
-FMTQUILL_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size)
-    -> format_decimal_result<Char*> {
-  FMTQUILL_ASSERT(size >= count_digits(value), "invalid digit count");
-  out += size;
-  Char* end = out;
-  while (value >= 100) {
-    // Integer division is slow so do it for a group of two digits instead
-    // of for every digit. The idea comes from the talk by Alexandrescu
-    // "Three Optimization Tips for C++". See speed-test for a comparison.
-    out -= 2;
-    copy2(out, digits2(static_cast<size_t>(value % 100)));
-    value /= 100;
-  }
-  if (value < 10) {
-    *--out = static_cast<Char>('0' + value);
-    return {out, end};
-  }
-  out -= 2;
-  copy2(out, digits2(static_cast<size_t>(value)));
-  return {out, end};
-}
-
-template <typename Char, typename UInt, typename Iterator,
-          FMTQUILL_ENABLE_IF(!std::is_pointer<remove_cvref_t<Iterator>>::value)>
-FMTQUILL_CONSTEXPR inline auto format_decimal(Iterator out, UInt value, int size)
-    -> format_decimal_result<Iterator> {
-  // Buffer is large enough to hold all digits (digits10 + 1).
-  Char buffer[digits10<UInt>() + 1] = {};
-  auto end = format_decimal(buffer, value, size).end;
-  return {out, detail::copy_str_noinline<Char>(buffer, end, out)};
-}
-
-template <unsigned BASE_BITS, typename Char, typename UInt>
-FMTQUILL_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits,
-                               bool upper = false) -> Char* {
-  buffer += num_digits;
-  Char* end = buffer;
-  do {
-    const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
-    unsigned digit = static_cast<unsigned>(value & ((1 << BASE_BITS) - 1));
-    *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
-                                                : digits[digit]);
-  } while ((value >>= BASE_BITS) != 0);
-  return end;
-}
-
-template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
-FMTQUILL_CONSTEXPR inline auto format_uint(It out, UInt value, int num_digits,
-                                      bool upper = false) -> It {
-  if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
-    format_uint<BASE_BITS>(ptr, value, num_digits, upper);
-    return out;
-  }
-  // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
-  char buffer[num_bits<UInt>() / BASE_BITS + 1] = {};
-  format_uint<BASE_BITS>(buffer, value, num_digits, upper);
-  return detail::copy_str_noinline<Char>(buffer, buffer + num_digits, out);
-}
-
-// A converter from UTF-8 to UTF-16.
-class utf8_to_utf16 {
- private:
-  basic_memory_buffer<wchar_t> buffer_;
-
- public:
-  FMTQUILL_API explicit utf8_to_utf16(string_view s);
-  operator basic_string_view<wchar_t>() const { return {&buffer_[0], size()}; }
-  auto size() const -> size_t { return buffer_.size() - 1; }
-  auto c_str() const -> const wchar_t* { return &buffer_[0]; }
-  auto str() const -> std::wstring { return {&buffer_[0], size()}; }
-};
-
-enum class to_utf8_error_policy { abort, replace };
-
-// A converter from UTF-16/UTF-32 (host endian) to UTF-8.
-template <typename WChar, typename Buffer = memory_buffer> class to_utf8 {
- private:
-  Buffer buffer_;
-
- public:
-  to_utf8() {}
-  explicit to_utf8(basic_string_view<WChar> s,
-                   to_utf8_error_policy policy = to_utf8_error_policy::abort) {
-    static_assert(sizeof(WChar) == 2 || sizeof(WChar) == 4,
-                  "Expect utf16 or utf32");
-    if (!convert(s, policy))
-      FMTQUILL_THROW(std::runtime_error(sizeof(WChar) == 2 ? "invalid utf16"
-                                                      : "invalid utf32"));
-  }
-  operator string_view() const { return string_view(&buffer_[0], size()); }
-  auto size() const -> size_t { return buffer_.size() - 1; }
-  auto c_str() const -> const char* { return &buffer_[0]; }
-  auto str() const -> std::string { return std::string(&buffer_[0], size()); }
-
-  // Performs conversion returning a bool instead of throwing exception on
-  // conversion error. This method may still throw in case of memory allocation
-  // error.
-  auto convert(basic_string_view<WChar> s,
-               to_utf8_error_policy policy = to_utf8_error_policy::abort)
-      -> bool {
-    if (!convert(buffer_, s, policy)) return false;
-    buffer_.push_back(0);
-    return true;
-  }
-  static auto convert(Buffer& buf, basic_string_view<WChar> s,
-                      to_utf8_error_policy policy = to_utf8_error_policy::abort)
-      -> bool {
-    for (auto p = s.begin(); p != s.end(); ++p) {
-      uint32_t c = static_cast<uint32_t>(*p);
-      if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) {
-        // Handle a surrogate pair.
-        ++p;
-        if (p == s.end() || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) {
-          if (policy == to_utf8_error_policy::abort) return false;
-          buf.append(string_view("\xEF\xBF\xBD"));
-          --p;
-        } else {
-          c = (c << 10) + static_cast<uint32_t>(*p) - 0x35fdc00;
-        }
-      } else if (c < 0x80) {
-        buf.push_back(static_cast<char>(c));
-      } else if (c < 0x800) {
-        buf.push_back(static_cast<char>(0xc0 | (c >> 6)));
-        buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
-      } else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff)) {
-        buf.push_back(static_cast<char>(0xe0 | (c >> 12)));
-        buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));
-        buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
-      } else if (c >= 0x10000 && c <= 0x10ffff) {
-        buf.push_back(static_cast<char>(0xf0 | (c >> 18)));
-        buf.push_back(static_cast<char>(0x80 | ((c & 0x3ffff) >> 12)));
-        buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));
-        buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
-      } else {
-        return false;
-      }
-    }
-    return true;
-  }
-};
-
-// Computes 128-bit result of multiplication of two 64-bit unsigned integers.
-inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback {
-#if FMTQUILL_USE_INT128
-  auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
-  return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
-#elif defined(_MSC_VER) && defined(_M_X64)
-  auto hi = uint64_t();
-  auto lo = _umul128(x, y, &hi);
-  return {hi, lo};
-#else
-  const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
-
-  uint64_t a = x >> 32;
-  uint64_t b = x & mask;
-  uint64_t c = y >> 32;
-  uint64_t d = y & mask;
-
-  uint64_t ac = a * c;
-  uint64_t bc = b * c;
-  uint64_t ad = a * d;
-  uint64_t bd = b * d;
-
-  uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
-
-  return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
-          (intermediate << 32) + (bd & mask)};
-#endif
-}
-
-namespace dragonbox {
-// Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from
-// https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1.
-inline auto floor_log10_pow2(int e) noexcept -> int {
-  FMTQUILL_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
-  static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
-  return (e * 315653) >> 20;
-}
-
-inline auto floor_log2_pow10(int e) noexcept -> int {
-  FMTQUILL_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
-  return (e * 1741647) >> 19;
-}
-
-// Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
-inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t {
-#if FMTQUILL_USE_INT128
-  auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
-  return static_cast<uint64_t>(p >> 64);
-#elif defined(_MSC_VER) && defined(_M_X64)
-  return __umulh(x, y);
-#else
-  return umul128(x, y).high();
-#endif
-}
-
-// Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a
-// 128-bit unsigned integer.
-inline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept
-    -> uint128_fallback {
-  uint128_fallback r = umul128(x, y.high());
-  r += umul128_upper64(x, y.low());
-  return r;
-}
-
-FMTQUILL_API auto get_cached_power(int k) noexcept -> uint128_fallback;
-
-// Type-specific information that Dragonbox uses.
-template <typename T, typename Enable = void> struct float_info;
-
-template <> struct float_info<float> {
-  using carrier_uint = uint32_t;
-  static const int exponent_bits = 8;
-  static const int kappa = 1;
-  static const int big_divisor = 100;
-  static const int small_divisor = 10;
-  static const int min_k = -31;
-  static const int max_k = 46;
-  static const int shorter_interval_tie_lower_threshold = -35;
-  static const int shorter_interval_tie_upper_threshold = -35;
-};
-
-template <> struct float_info<double> {
-  using carrier_uint = uint64_t;
-  static const int exponent_bits = 11;
-  static const int kappa = 2;
-  static const int big_divisor = 1000;
-  static const int small_divisor = 100;
-  static const int min_k = -292;
-  static const int max_k = 341;
-  static const int shorter_interval_tie_lower_threshold = -77;
-  static const int shorter_interval_tie_upper_threshold = -77;
-};
-
-// An 80- or 128-bit floating point number.
-template <typename T>
-struct float_info<T, enable_if_t<std::numeric_limits<T>::digits == 64 ||
-                                 std::numeric_limits<T>::digits == 113 ||
-                                 is_float128<T>::value>> {
-  using carrier_uint = detail::uint128_t;
-  static const int exponent_bits = 15;
-};
-
-// A double-double floating point number.
-template <typename T>
-struct float_info<T, enable_if_t<is_double_double<T>::value>> {
-  using carrier_uint = detail::uint128_t;
-};
-
-template <typename T> struct decimal_fp {
-  using significand_type = typename float_info<T>::carrier_uint;
-  significand_type significand;
-  int exponent;
-};
-
-template <typename T> FMTQUILL_API auto to_decimal(T x) noexcept -> decimal_fp<T>;
-}  // namespace dragonbox
-
-// Returns true iff Float has the implicit bit which is not stored.
-template <typename Float> constexpr auto has_implicit_bit() -> bool {
-  // An 80-bit FP number has a 64-bit significand an no implicit bit.
-  return std::numeric_limits<Float>::digits != 64;
-}
-
-// Returns the number of significand bits stored in Float. The implicit bit is
-// not counted since it is not stored.
-template <typename Float> constexpr auto num_significand_bits() -> int {
-  // std::numeric_limits may not support __float128.
-  return is_float128<Float>() ? 112
-                              : (std::numeric_limits<Float>::digits -
-                                 (has_implicit_bit<Float>() ? 1 : 0));
-}
-
-template <typename Float>
-constexpr auto exponent_mask() ->
-    typename dragonbox::float_info<Float>::carrier_uint {
-  using float_uint = typename dragonbox::float_info<Float>::carrier_uint;
-  return ((float_uint(1) << dragonbox::float_info<Float>::exponent_bits) - 1)
-         << num_significand_bits<Float>();
-}
-template <typename Float> constexpr auto exponent_bias() -> int {
-  // std::numeric_limits may not support __float128.
-  return is_float128<Float>() ? 16383
-                              : std::numeric_limits<Float>::max_exponent - 1;
-}
-
-// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
-template <typename Char, typename It>
-FMTQUILL_CONSTEXPR auto write_exponent(int exp, It it) -> It {
-  FMTQUILL_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
-  if (exp < 0) {
-    *it++ = static_cast<Char>('-');
-    exp = -exp;
-  } else {
-    *it++ = static_cast<Char>('+');
-  }
-  if (exp >= 100) {
-    const char* top = digits2(to_unsigned(exp / 100));
-    if (exp >= 1000) *it++ = static_cast<Char>(top[0]);
-    *it++ = static_cast<Char>(top[1]);
-    exp %= 100;
-  }
-  const char* d = digits2(to_unsigned(exp));
-  *it++ = static_cast<Char>(d[0]);
-  *it++ = static_cast<Char>(d[1]);
-  return it;
-}
-
-// A floating-point number f * pow(2, e) where F is an unsigned type.
-template <typename F> struct basic_fp {
-  F f;
-  int e;
-
-  static constexpr const int num_significand_bits =
-      static_cast<int>(sizeof(F) * num_bits<unsigned char>());
-
-  constexpr basic_fp() : f(0), e(0) {}
-  constexpr basic_fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
-
-  // Constructs fp from an IEEE754 floating-point number.
-  template <typename Float> FMTQUILL_CONSTEXPR basic_fp(Float n) { assign(n); }
-
-  // Assigns n to this and return true iff predecessor is closer than successor.
-  template <typename Float, FMTQUILL_ENABLE_IF(!is_double_double<Float>::value)>
-  FMTQUILL_CONSTEXPR auto assign(Float n) -> bool {
-    static_assert(std::numeric_limits<Float>::digits <= 113, "unsupported FP");
-    // Assume Float is in the format [sign][exponent][significand].
-    using carrier_uint = typename dragonbox::float_info<Float>::carrier_uint;
-    const auto num_float_significand_bits =
-        detail::num_significand_bits<Float>();
-    const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
-    const auto significand_mask = implicit_bit - 1;
-    auto u = bit_cast<carrier_uint>(n);
-    f = static_cast<F>(u & significand_mask);
-    auto biased_e = static_cast<int>((u & exponent_mask<Float>()) >>
-                                     num_float_significand_bits);
-    // The predecessor is closer if n is a normalized power of 2 (f == 0)
-    // other than the smallest normalized number (biased_e > 1).
-    auto is_predecessor_closer = f == 0 && biased_e > 1;
-    if (biased_e == 0)
-      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
-    else if (has_implicit_bit<Float>())
-      f += static_cast<F>(implicit_bit);
-    e = biased_e - exponent_bias<Float>() - num_float_significand_bits;
-    if (!has_implicit_bit<Float>()) ++e;
-    return is_predecessor_closer;
-  }
-
-  template <typename Float, FMTQUILL_ENABLE_IF(is_double_double<Float>::value)>
-  FMTQUILL_CONSTEXPR auto assign(Float n) -> bool {
-    static_assert(std::numeric_limits<double>::is_iec559, "unsupported FP");
-    return assign(static_cast<double>(n));
-  }
-};
-
-using fp = basic_fp<unsigned long long>;
-
-// Normalizes the value converted from double and multiplied by (1 << SHIFT).
-template <int SHIFT = 0, typename F>
-FMTQUILL_CONSTEXPR auto normalize(basic_fp<F> value) -> basic_fp<F> {
-  // Handle subnormals.
-  const auto implicit_bit = F(1) << num_significand_bits<double>();
-  const auto shifted_implicit_bit = implicit_bit << SHIFT;
-  while ((value.f & shifted_implicit_bit) == 0) {
-    value.f <<= 1;
-    --value.e;
-  }
-  // Subtract 1 to account for hidden bit.
-  const auto offset = basic_fp<F>::num_significand_bits -
-                      num_significand_bits<double>() - SHIFT - 1;
-  value.f <<= offset;
-  value.e -= offset;
-  return value;
-}
-
-// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
-FMTQUILL_CONSTEXPR inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t {
-#if FMTQUILL_USE_INT128
-  auto product = static_cast<__uint128_t>(lhs) * rhs;
-  auto f = static_cast<uint64_t>(product >> 64);
-  return (static_cast<uint64_t>(product) & (1ULL << 63)) != 0 ? f + 1 : f;
-#else
-  // Multiply 32-bit parts of significands.
-  uint64_t mask = (1ULL << 32) - 1;
-  uint64_t a = lhs >> 32, b = lhs & mask;
-  uint64_t c = rhs >> 32, d = rhs & mask;
-  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
-  // Compute mid 64-bit of result and round.
-  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
-  return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);
-#endif
-}
-
-FMTQUILL_CONSTEXPR inline auto operator*(fp x, fp y) -> fp {
-  return {multiply(x.f, y.f), x.e + y.e + 64};
-}
-
-template <typename T, bool doublish = num_bits<T>() == num_bits<double>()>
-using convert_float_result =
-    conditional_t<std::is_same<T, float>::value || doublish, double, T>;
-
-template <typename T>
-constexpr auto convert_float(T value) -> convert_float_result<T> {
-  return static_cast<convert_float_result<T>>(value);
-}
-
-template <typename OutputIt, typename Char>
-FMTQUILL_NOINLINE FMTQUILL_CONSTEXPR auto fill(OutputIt it, size_t n,
-                                     const fill_t<Char>& fill) -> OutputIt {
-  auto fill_size = fill.size();
-  if (fill_size == 1) return detail::fill_n(it, n, fill[0]);
-  auto data = fill.data();
-  for (size_t i = 0; i < n; ++i)
-    it = copy_str<Char>(data, data + fill_size, it);
-  return it;
-}
-
-// Writes the output of f, padded according to format specifications in specs.
-// size: output size in code units.
-// width: output display width in (terminal) column positions.
-template <align::type align = align::left, typename OutputIt, typename Char,
-          typename F>
-FMTQUILL_CONSTEXPR auto write_padded(OutputIt out, const format_specs<Char>& specs,
-                                size_t size, size_t width, F&& f) -> OutputIt {
-  static_assert(align == align::left || align == align::right, "");
-  unsigned spec_width = to_unsigned(specs.width);
-  size_t padding = spec_width > width ? spec_width - width : 0;
-  // Shifts are encoded as string literals because static constexpr is not
-  // supported in constexpr functions.
-  auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
-  size_t left_padding = padding >> shifts[specs.align];
-  size_t right_padding = padding - left_padding;
-  auto it = reserve(out, size + padding * specs.fill.size());
-  if (left_padding != 0) it = fill(it, left_padding, specs.fill);
-  it = f(it);
-  if (right_padding != 0) it = fill(it, right_padding, specs.fill);
-  return base_iterator(out, it);
-}
-
-template <align::type align = align::left, typename OutputIt, typename Char,
-          typename F>
-constexpr auto write_padded(OutputIt out, const format_specs<Char>& specs,
-                            size_t size, F&& f) -> OutputIt {
-  return write_padded<align>(out, specs, size, size, f);
-}
-
-template <align::type align = align::left, typename Char, typename OutputIt>
-FMTQUILL_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes,
-                               const format_specs<Char>& specs) -> OutputIt {
-  return write_padded<align>(
-      out, specs, bytes.size(), [bytes](reserve_iterator<OutputIt> it) {
-        const char* data = bytes.data();
-        return copy_str<Char>(data, data + bytes.size(), it);
-      });
-}
-
-template <typename Char, typename OutputIt, typename UIntPtr>
-auto write_ptr(OutputIt out, UIntPtr value, const format_specs<Char>* specs)
-    -> OutputIt {
-  int num_digits = count_digits<4>(value);
-  auto size = to_unsigned(num_digits) + size_t(2);
-  auto write = [=](reserve_iterator<OutputIt> it) {
-    *it++ = static_cast<Char>('0');
-    *it++ = static_cast<Char>('x');
-    return format_uint<4, Char>(it, value, num_digits);
-  };
-  return specs ? write_padded<align::right>(out, *specs, size, write)
-               : base_iterator(out, write(reserve(out, size)));
-}
-
-// Returns true iff the code point cp is printable.
-FMTQUILL_API auto is_printable(uint32_t cp) -> bool;
-
-inline auto needs_escape(uint32_t cp) -> bool {
-  return cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\' ||
-         !is_printable(cp);
-}
-
-template <typename Char> struct find_escape_result {
-  const Char* begin;
-  const Char* end;
-  uint32_t cp;
-};
-
-template <typename Char>
-using make_unsigned_char =
-    typename conditional_t<std::is_integral<Char>::value,
-                           std::make_unsigned<Char>,
-                           type_identity<uint32_t>>::type;
-
-template <typename Char>
-auto find_escape(const Char* begin, const Char* end)
-    -> find_escape_result<Char> {
-  for (; begin != end; ++begin) {
-    uint32_t cp = static_cast<make_unsigned_char<Char>>(*begin);
-    if (const_check(sizeof(Char) == 1) && cp >= 0x80) continue;
-    if (needs_escape(cp)) return {begin, begin + 1, cp};
-  }
-  return {begin, nullptr, 0};
-}
-
-inline auto find_escape(const char* begin, const char* end)
-    -> find_escape_result<char> {
-  if (!is_utf8()) return find_escape<char>(begin, end);
-  auto result = find_escape_result<char>{end, nullptr, 0};
-  for_each_codepoint(string_view(begin, to_unsigned(end - begin)),
-                     [&](uint32_t cp, string_view sv) {
-                       if (needs_escape(cp)) {
-                         result = {sv.begin(), sv.end(), cp};
-                         return false;
-                       }
-                       return true;
-                     });
-  return result;
-}
-
-#define FMTQUILL_STRING_IMPL(s, base, explicit)                                    \
-  [] {                                                                        \
-    /* Use the hidden visibility as a workaround for a GCC bug (#1973). */    \
-    /* Use a macro-like name to avoid shadowing warnings. */                  \
-    struct FMTQUILL_VISIBILITY("hidden") FMTQUILL_COMPILE_STRING : base {               \
-      using char_type FMTQUILL_MAYBE_UNUSED = fmtquill::remove_cvref_t<decltype(s[0])>; \
-      FMTQUILL_MAYBE_UNUSED FMTQUILL_CONSTEXPR explicit                                 \
-      operator fmtquill::basic_string_view<char_type>() const {                    \
-        return fmtquill::detail_exported::compile_string_to_view<char_type>(s);    \
-      }                                                                       \
-    };                                                                        \
-    return FMTQUILL_COMPILE_STRING();                                              \
-  }()
-
-/**
-  \rst
-  Constructs a compile-time format string from a string literal *s*.
-
-  **Example**::
-
-    // A compile-time error because 'd' is an invalid specifier for strings.
-    std::string s = fmtquill::format(FMTQUILL_STRING("{:d}"), "foo");
-  \endrst
- */
-#define FMTQUILL_STRING(s) FMTQUILL_STRING_IMPL(s, fmtquill::detail::compile_string, )
-
-template <size_t width, typename Char, typename OutputIt>
-auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt {
-  *out++ = static_cast<Char>('\\');
-  *out++ = static_cast<Char>(prefix);
-  Char buf[width];
-  fill_n(buf, width, static_cast<Char>('0'));
-  format_uint<4>(buf, cp, width);
-  return copy_str<Char>(buf, buf + width, out);
-}
-
-template <typename OutputIt, typename Char>
-auto write_escaped_cp(OutputIt out, const find_escape_result<Char>& escape)
-    -> OutputIt {
-  auto c = static_cast<Char>(escape.cp);
-  switch (escape.cp) {
-  case '\n':
-    *out++ = static_cast<Char>('\\');
-    c = static_cast<Char>('n');
-    break;
-  case '\r':
-    *out++ = static_cast<Char>('\\');
-    c = static_cast<Char>('r');
-    break;
-  case '\t':
-    *out++ = static_cast<Char>('\\');
-    c = static_cast<Char>('t');
-    break;
-  case '"':
-    FMTQUILL_FALLTHROUGH;
-  case '\'':
-    FMTQUILL_FALLTHROUGH;
-  case '\\':
-    *out++ = static_cast<Char>('\\');
-    break;
-  default:
-    if (escape.cp < 0x100) {
-      return write_codepoint<2, Char>(out, 'x', escape.cp);
-    }
-    if (escape.cp < 0x10000) {
-      return write_codepoint<4, Char>(out, 'u', escape.cp);
-    }
-    if (escape.cp < 0x110000) {
-      return write_codepoint<8, Char>(out, 'U', escape.cp);
-    }
-    for (Char escape_char : basic_string_view<Char>(
-             escape.begin, to_unsigned(escape.end - escape.begin))) {
-      out = write_codepoint<2, Char>(out, 'x',
-                                     static_cast<uint32_t>(escape_char) & 0xFF);
-    }
-    return out;
-  }
-  *out++ = c;
-  return out;
-}
-
-template <typename Char, typename OutputIt>
-auto write_escaped_string(OutputIt out, basic_string_view<Char> str)
-    -> OutputIt {
-  *out++ = static_cast<Char>('"');
-  auto begin = str.begin(), end = str.end();
-  do {
-    auto escape = find_escape(begin, end);
-    out = copy_str<Char>(begin, escape.begin, out);
-    begin = escape.end;
-    if (!begin) break;
-    out = write_escaped_cp<OutputIt, Char>(out, escape);
-  } while (begin != end);
-  *out++ = static_cast<Char>('"');
-  return out;
-}
-
-template <typename Char, typename OutputIt>
-auto write_escaped_char(OutputIt out, Char v) -> OutputIt {
-  Char v_array[1] = {v};
-  *out++ = static_cast<Char>('\'');
-  if ((needs_escape(static_cast<uint32_t>(v)) && v != static_cast<Char>('"')) ||
-      v == static_cast<Char>('\'')) {
-    out = write_escaped_cp(out,
-                           find_escape_result<Char>{v_array, v_array + 1,
-                                                    static_cast<uint32_t>(v)});
-  } else {
-    *out++ = v;
-  }
-  *out++ = static_cast<Char>('\'');
-  return out;
-}
-
-template <typename Char, typename OutputIt>
-FMTQUILL_CONSTEXPR auto write_char(OutputIt out, Char value,
-                              const format_specs<Char>& specs) -> OutputIt {
-  bool is_debug = specs.type == presentation_type::debug;
-  return write_padded(out, specs, 1, [=](reserve_iterator<OutputIt> it) {
-    if (is_debug) return write_escaped_char(it, value);
-    *it++ = value;
-    return it;
-  });
-}
-template <typename Char, typename OutputIt>
-FMTQUILL_CONSTEXPR auto write(OutputIt out, Char value,
-                         const format_specs<Char>& specs, locale_ref loc = {})
-    -> OutputIt {
-  // char is formatted as unsigned char for consistency across platforms.
-  using unsigned_type =
-      conditional_t<std::is_same<Char, char>::value, unsigned char, unsigned>;
-  return check_char_specs(specs)
-             ? write_char(out, value, specs)
-             : write(out, static_cast<unsigned_type>(value), specs, loc);
-}
-
-// Data for write_int that doesn't depend on output iterator type. It is used to
-// avoid template code bloat.
-template <typename Char> struct write_int_data {
-  size_t size;
-  size_t padding;
-
-  FMTQUILL_CONSTEXPR write_int_data(int num_digits, unsigned prefix,
-                               const format_specs<Char>& specs)
-      : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) {
-    if (specs.align == align::numeric) {
-      auto width = to_unsigned(specs.width);
-      if (width > size) {
-        padding = width - size;
-        size = width;
-      }
-    } else if (specs.precision > num_digits) {
-      size = (prefix >> 24) + to_unsigned(specs.precision);
-      padding = to_unsigned(specs.precision - num_digits);
-    }
-  }
-};
-
-// Writes an integer in the format
-//   <left-padding><prefix><numeric-padding><digits><right-padding>
-// where <digits> are written by write_digits(it).
-// prefix contains chars in three lower bytes and the size in the fourth byte.
-template <typename OutputIt, typename Char, typename W>
-FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto write_int(OutputIt out, int num_digits,
-                                        unsigned prefix,
-                                        const format_specs<Char>& specs,
-                                        W write_digits) -> OutputIt {
-  // Slightly faster check for specs.width == 0 && specs.precision == -1.
-  if ((specs.width | (specs.precision + 1)) == 0) {
-    auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24));
-    if (prefix != 0) {
-      for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
-        *it++ = static_cast<Char>(p & 0xff);
-    }
-    return base_iterator(out, write_digits(it));
-  }
-  auto data = write_int_data<Char>(num_digits, prefix, specs);
-  return write_padded<align::right>(
-      out, specs, data.size, [=](reserve_iterator<OutputIt> it) {
-        for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
-          *it++ = static_cast<Char>(p & 0xff);
-        it = detail::fill_n(it, data.padding, static_cast<Char>('0'));
-        return write_digits(it);
-      });
-}
-
-template <typename Char> class digit_grouping {
- private:
-  std::string grouping_;
-  std::basic_string<Char> thousands_sep_;
-
-  struct next_state {
-    std::string::const_iterator group;
-    int pos;
-  };
-  auto initial_state() const -> next_state { return {grouping_.begin(), 0}; }
-
-  // Returns the next digit group separator position.
-  auto next(next_state& state) const -> int {
-    if (thousands_sep_.empty()) return max_value<int>();
-    if (state.group == grouping_.end()) return state.pos += grouping_.back();
-    if (*state.group <= 0 || *state.group == max_value<char>())
-      return max_value<int>();
-    state.pos += *state.group++;
-    return state.pos;
-  }
-
- public:
-  explicit digit_grouping(locale_ref loc, bool localized = true) {
-    if (!localized) return;
-    auto sep = thousands_sep<Char>(loc);
-    grouping_ = sep.grouping;
-    if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep);
-  }
-  digit_grouping(std::string grouping, std::basic_string<Char> sep)
-      : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {}
-
-  auto has_separator() const -> bool { return !thousands_sep_.empty(); }
-
-  auto count_separators(int num_digits) const -> int {
-    int count = 0;
-    auto state = initial_state();
-    while (num_digits > next(state)) ++count;
-    return count;
-  }
-
-  // Applies grouping to digits and write the output to out.
-  template <typename Out, typename C>
-  auto apply(Out out, basic_string_view<C> digits) const -> Out {
-    auto num_digits = static_cast<int>(digits.size());
-    auto separators = basic_memory_buffer<int>();
-    separators.push_back(0);
-    auto state = initial_state();
-    while (int i = next(state)) {
-      if (i >= num_digits) break;
-      separators.push_back(i);
-    }
-    for (int i = 0, sep_index = static_cast<int>(separators.size() - 1);
-         i < num_digits; ++i) {
-      if (num_digits - i == separators[sep_index]) {
-        out =
-            copy_str<Char>(thousands_sep_.data(),
-                           thousands_sep_.data() + thousands_sep_.size(), out);
-        --sep_index;
-      }
-      *out++ = static_cast<Char>(digits[to_unsigned(i)]);
-    }
-    return out;
-  }
-};
-
-FMTQUILL_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) {
-  prefix |= prefix != 0 ? value << 8 : value;
-  prefix += (1u + (value > 0xff ? 1 : 0)) << 24;
-}
-
-// Writes a decimal integer with digit grouping.
-template <typename OutputIt, typename UInt, typename Char>
-auto write_int(OutputIt out, UInt value, unsigned prefix,
-               const format_specs<Char>& specs,
-               const digit_grouping<Char>& grouping) -> OutputIt {
-  static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
-  int num_digits = 0;
-  auto buffer = memory_buffer();
-  switch (specs.type) {
-  case presentation_type::none:
-  case presentation_type::dec: {
-    num_digits = count_digits(value);
-    format_decimal<char>(appender(buffer), value, num_digits);
-    break;
-  }
-  case presentation_type::hex_lower:
-  case presentation_type::hex_upper: {
-    bool upper = specs.type == presentation_type::hex_upper;
-    if (specs.alt)
-      prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0');
-    num_digits = count_digits<4>(value);
-    format_uint<4, char>(appender(buffer), value, num_digits, upper);
-    break;
-  }
-  case presentation_type::bin_lower:
-  case presentation_type::bin_upper: {
-    bool upper = specs.type == presentation_type::bin_upper;
-    if (specs.alt)
-      prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0');
-    num_digits = count_digits<1>(value);
-    format_uint<1, char>(appender(buffer), value, num_digits);
-    break;
-  }
-  case presentation_type::oct: {
-    num_digits = count_digits<3>(value);
-    // Octal prefix '0' is counted as a digit, so only add it if precision
-    // is not greater than the number of digits.
-    if (specs.alt && specs.precision <= num_digits && value != 0)
-      prefix_append(prefix, '0');
-    format_uint<3, char>(appender(buffer), value, num_digits);
-    break;
-  }
-  case presentation_type::chr:
-    return write_char(out, static_cast<Char>(value), specs);
-  default:
-    throw_format_error("invalid format specifier");
-  }
-
-  unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) +
-                  to_unsigned(grouping.count_separators(num_digits));
-  return write_padded<align::right>(
-      out, specs, size, size, [&](reserve_iterator<OutputIt> it) {
-        for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
-          *it++ = static_cast<Char>(p & 0xff);
-        return grouping.apply(it, string_view(buffer.data(), buffer.size()));
-      });
-}
-
-// Writes a localized value.
-FMTQUILL_API auto write_loc(appender out, loc_value value,
-                       const format_specs<>& specs, locale_ref loc) -> bool;
-template <typename OutputIt, typename Char>
-inline auto write_loc(OutputIt, loc_value, const format_specs<Char>&,
-                      locale_ref) -> bool {
-  return false;
-}
-
-template <typename UInt> struct write_int_arg {
-  UInt abs_value;
-  unsigned prefix;
-};
-
-template <typename T>
-FMTQUILL_CONSTEXPR auto make_write_int_arg(T value, sign_t sign)
-    -> write_int_arg<uint32_or_64_or_128_t<T>> {
-  auto prefix = 0u;
-  auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
-  if (is_negative(value)) {
-    prefix = 0x01000000 | '-';
-    abs_value = 0 - abs_value;
-  } else {
-    constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+',
-                                            0x1000000u | ' '};
-    prefix = prefixes[sign];
-  }
-  return {abs_value, prefix};
-}
-
-template <typename Char = char> struct loc_writer {
-  buffer_appender<Char> out;
-  const format_specs<Char>& specs;
-  std::basic_string<Char> sep;
-  std::string grouping;
-  std::basic_string<Char> decimal_point;
-
-  template <typename T, FMTQUILL_ENABLE_IF(is_integer<T>::value)>
-  auto operator()(T value) -> bool {
-    auto arg = make_write_int_arg(value, specs.sign);
-    write_int(out, static_cast<uint64_or_128_t<T>>(arg.abs_value), arg.prefix,
-              specs, digit_grouping<Char>(grouping, sep));
-    return true;
-  }
-
-  template <typename T, FMTQUILL_ENABLE_IF(!is_integer<T>::value)>
-  auto operator()(T) -> bool {
-    return false;
-  }
-};
-
-template <typename Char, typename OutputIt, typename T>
-FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto write_int(OutputIt out, write_int_arg<T> arg,
-                                        const format_specs<Char>& specs,
-                                        locale_ref) -> OutputIt {
-  static_assert(std::is_same<T, uint32_or_64_or_128_t<T>>::value, "");
-  auto abs_value = arg.abs_value;
-  auto prefix = arg.prefix;
-  switch (specs.type) {
-  case presentation_type::none:
-  case presentation_type::dec: {
-    auto num_digits = count_digits(abs_value);
-    return write_int(
-        out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
-          return format_decimal<Char>(it, abs_value, num_digits).end;
-        });
-  }
-  case presentation_type::hex_lower:
-  case presentation_type::hex_upper: {
-    bool upper = specs.type == presentation_type::hex_upper;
-    if (specs.alt)
-      prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0');
-    int num_digits = count_digits<4>(abs_value);
-    return write_int(
-        out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
-          return format_uint<4, Char>(it, abs_value, num_digits, upper);
-        });
-  }
-  case presentation_type::bin_lower:
-  case presentation_type::bin_upper: {
-    bool upper = specs.type == presentation_type::bin_upper;
-    if (specs.alt)
-      prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0');
-    int num_digits = count_digits<1>(abs_value);
-    return write_int(out, num_digits, prefix, specs,
-                     [=](reserve_iterator<OutputIt> it) {
-                       return format_uint<1, Char>(it, abs_value, num_digits);
-                     });
-  }
-  case presentation_type::oct: {
-    int num_digits = count_digits<3>(abs_value);
-    // Octal prefix '0' is counted as a digit, so only add it if precision
-    // is not greater than the number of digits.
-    if (specs.alt && specs.precision <= num_digits && abs_value != 0)
-      prefix_append(prefix, '0');
-    return write_int(out, num_digits, prefix, specs,
-                     [=](reserve_iterator<OutputIt> it) {
-                       return format_uint<3, Char>(it, abs_value, num_digits);
-                     });
-  }
-  case presentation_type::chr:
-    return write_char(out, static_cast<Char>(abs_value), specs);
-  default:
-    throw_format_error("invalid format specifier");
-  }
-  return out;
-}
-template <typename Char, typename OutputIt, typename T>
-FMTQUILL_CONSTEXPR FMTQUILL_NOINLINE auto write_int_noinline(
-    OutputIt out, write_int_arg<T> arg, const format_specs<Char>& specs,
-    locale_ref loc) -> OutputIt {
-  return write_int(out, arg, specs, loc);
-}
-template <typename Char, typename OutputIt, typename T,
-          FMTQUILL_ENABLE_IF(is_integral<T>::value &&
-                        !std::is_same<T, bool>::value &&
-                        std::is_same<OutputIt, buffer_appender<Char>>::value)>
-FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto write(OutputIt out, T value,
-                                    const format_specs<Char>& specs,
-                                    locale_ref loc) -> OutputIt {
-  if (specs.localized && write_loc(out, value, specs, loc)) return out;
-  return write_int_noinline(out, make_write_int_arg(value, specs.sign), specs,
-                            loc);
-}
-// An inlined version of write used in format string compilation.
-template <typename Char, typename OutputIt, typename T,
-          FMTQUILL_ENABLE_IF(is_integral<T>::value &&
-                        !std::is_same<T, bool>::value &&
-                        !std::is_same<OutputIt, buffer_appender<Char>>::value)>
-FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto write(OutputIt out, T value,
-                                    const format_specs<Char>& specs,
-                                    locale_ref loc) -> OutputIt {
-  if (specs.localized && write_loc(out, value, specs, loc)) return out;
-  return write_int(out, make_write_int_arg(value, specs.sign), specs, loc);
-}
-
-// An output iterator that counts the number of objects written to it and
-// discards them.
-class counting_iterator {
- private:
-  size_t count_;
-
- public:
-  using iterator_category = std::output_iterator_tag;
-  using difference_type = std::ptrdiff_t;
-  using pointer = void;
-  using reference = void;
-  FMTQUILL_UNCHECKED_ITERATOR(counting_iterator);
-
-  struct value_type {
-    template <typename T> FMTQUILL_CONSTEXPR void operator=(const T&) {}
-  };
-
-  FMTQUILL_CONSTEXPR counting_iterator() : count_(0) {}
-
-  FMTQUILL_CONSTEXPR auto count() const -> size_t { return count_; }
-
-  FMTQUILL_CONSTEXPR auto operator++() -> counting_iterator& {
-    ++count_;
-    return *this;
-  }
-  FMTQUILL_CONSTEXPR auto operator++(int) -> counting_iterator {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
-
-  FMTQUILL_CONSTEXPR friend auto operator+(counting_iterator it, difference_type n)
-      -> counting_iterator {
-    it.count_ += static_cast<size_t>(n);
-    return it;
-  }
-
-  FMTQUILL_CONSTEXPR auto operator*() const -> value_type { return {}; }
-};
-
-template <typename Char, typename OutputIt>
-FMTQUILL_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> s,
-                         const format_specs<Char>& specs) -> OutputIt {
-  auto data = s.data();
-  auto size = s.size();
-  if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
-    size = code_point_index(s, to_unsigned(specs.precision));
-  bool is_debug = specs.type == presentation_type::debug;
-  size_t width = 0;
-  if (specs.width != 0) {
-    if (is_debug)
-      width = write_escaped_string(counting_iterator{}, s).count();
-    else
-      width = compute_width(basic_string_view<Char>(data, size));
-  }
-  return write_padded(out, specs, size, width,
-                      [=](reserve_iterator<OutputIt> it) {
-                        if (is_debug) return write_escaped_string(it, s);
-                        return copy_str<Char>(data, data + size, it);
-                      });
-}
-template <typename Char, typename OutputIt>
-FMTQUILL_CONSTEXPR auto write(OutputIt out,
-                         basic_string_view<type_identity_t<Char>> s,
-                         const format_specs<Char>& specs, locale_ref)
-    -> OutputIt {
-  return write(out, s, specs);
-}
-template <typename Char, typename OutputIt>
-FMTQUILL_CONSTEXPR auto write(OutputIt out, const Char* s,
-                         const format_specs<Char>& specs, locale_ref)
-    -> OutputIt {
-  if (specs.type == presentation_type::pointer)
-    return write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs);
-  if (!s) throw_format_error("string pointer is null");
-  return write(out, basic_string_view<Char>(s), specs, {});
-}
-
-template <typename Char, typename OutputIt, typename T,
-          FMTQUILL_ENABLE_IF(is_integral<T>::value &&
-                        !std::is_same<T, bool>::value &&
-                        !std::is_same<T, Char>::value)>
-FMTQUILL_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
-  auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
-  bool negative = is_negative(value);
-  // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
-  if (negative) abs_value = ~abs_value + 1;
-  int num_digits = count_digits(abs_value);
-  auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits);
-  auto it = reserve(out, size);
-  if (auto ptr = to_pointer<Char>(it, size)) {
-    if (negative) *ptr++ = static_cast<Char>('-');
-    format_decimal<Char>(ptr, abs_value, num_digits);
-    return out;
-  }
-  if (negative) *it++ = static_cast<Char>('-');
-  it = format_decimal<Char>(it, abs_value, num_digits).end;
-  return base_iterator(out, it);
-}
-
-// DEPRECATED!
-template <typename Char>
-FMTQUILL_CONSTEXPR auto parse_align(const Char* begin, const Char* end,
-                               format_specs<Char>& specs) -> const Char* {
-  FMTQUILL_ASSERT(begin != end, "");
-  auto align = align::none;
-  auto p = begin + code_point_length(begin);
-  if (end - p <= 0) p = begin;
-  for (;;) {
-    switch (to_ascii(*p)) {
-    case '<':
-      align = align::left;
-      break;
-    case '>':
-      align = align::right;
-      break;
-    case '^':
-      align = align::center;
-      break;
-    }
-    if (align != align::none) {
-      if (p != begin) {
-        auto c = *begin;
-        if (c == '}') return begin;
-        if (c == '{') {
-          throw_format_error("invalid fill character '{'");
-          return begin;
-        }
-        specs.fill = {begin, to_unsigned(p - begin)};
-        begin = p + 1;
-      } else {
-        ++begin;
-      }
-      break;
-    } else if (p == begin) {
-      break;
-    }
-    p = begin;
-  }
-  specs.align = align;
-  return begin;
-}
-
-// A floating-point presentation format.
-enum class float_format : unsigned char {
-  general,  // General: exponent notation or fixed point based on magnitude.
-  exp,      // Exponent notation with the default precision of 6, e.g. 1.2e-3.
-  fixed,    // Fixed point with the default precision of 6, e.g. 0.0012.
-  hex
-};
-
-struct float_specs {
-  int precision;
-  float_format format : 8;
-  sign_t sign : 8;
-  bool upper : 1;
-  bool locale : 1;
-  bool binary32 : 1;
-  bool showpoint : 1;
-};
-
-template <typename Char>
-FMTQUILL_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs)
-    -> float_specs {
-  auto result = float_specs();
-  result.showpoint = specs.alt;
-  result.locale = specs.localized;
-  switch (specs.type) {
-  case presentation_type::none:
-    result.format = float_format::general;
-    break;
-  case presentation_type::general_upper:
-    result.upper = true;
-    FMTQUILL_FALLTHROUGH;
-  case presentation_type::general_lower:
-    result.format = float_format::general;
-    break;
-  case presentation_type::exp_upper:
-    result.upper = true;
-    FMTQUILL_FALLTHROUGH;
-  case presentation_type::exp_lower:
-    result.format = float_format::exp;
-    result.showpoint |= specs.precision != 0;
-    break;
-  case presentation_type::fixed_upper:
-    result.upper = true;
-    FMTQUILL_FALLTHROUGH;
-  case presentation_type::fixed_lower:
-    result.format = float_format::fixed;
-    result.showpoint |= specs.precision != 0;
-    break;
-  case presentation_type::hexfloat_upper:
-    result.upper = true;
-    FMTQUILL_FALLTHROUGH;
-  case presentation_type::hexfloat_lower:
-    result.format = float_format::hex;
-    break;
-  default:
-    throw_format_error("invalid format specifier");
-    break;
-  }
-  return result;
-}
-
-template <typename Char, typename OutputIt>
-FMTQUILL_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan,
-                                     format_specs<Char> specs,
-                                     const float_specs& fspecs) -> OutputIt {
-  auto str =
-      isnan ? (fspecs.upper ? "NAN" : "nan") : (fspecs.upper ? "INF" : "inf");
-  constexpr size_t str_size = 3;
-  auto sign = fspecs.sign;
-  auto size = str_size + (sign ? 1 : 0);
-  // Replace '0'-padding with space for non-finite values.
-  const bool is_zero_fill =
-      specs.fill.size() == 1 && *specs.fill.data() == static_cast<Char>('0');
-  if (is_zero_fill) specs.fill[0] = static_cast<Char>(' ');
-  return write_padded(out, specs, size, [=](reserve_iterator<OutputIt> it) {
-    if (sign) *it++ = detail::sign<Char>(sign);
-    return copy_str<Char>(str, str + str_size, it);
-  });
-}
-
-// A decimal floating-point number significand * pow(10, exp).
-struct big_decimal_fp {
-  const char* significand;
-  int significand_size;
-  int exponent;
-};
-
-constexpr auto get_significand_size(const big_decimal_fp& f) -> int {
-  return f.significand_size;
-}
-template <typename T>
-inline auto get_significand_size(const dragonbox::decimal_fp<T>& f) -> int {
-  return count_digits(f.significand);
-}
-
-template <typename Char, typename OutputIt>
-constexpr auto write_significand(OutputIt out, const char* significand,
-                                 int significand_size) -> OutputIt {
-  return copy_str<Char>(significand, significand + significand_size, out);
-}
-template <typename Char, typename OutputIt, typename UInt>
-inline auto write_significand(OutputIt out, UInt significand,
-                              int significand_size) -> OutputIt {
-  return format_decimal<Char>(out, significand, significand_size).end;
-}
-template <typename Char, typename OutputIt, typename T, typename Grouping>
-FMTQUILL_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
-                                       int significand_size, int exponent,
-                                       const Grouping& grouping) -> OutputIt {
-  if (!grouping.has_separator()) {
-    out = write_significand<Char>(out, significand, significand_size);
-    return detail::fill_n(out, exponent, static_cast<Char>('0'));
-  }
-  auto buffer = memory_buffer();
-  write_significand<char>(appender(buffer), significand, significand_size);
-  detail::fill_n(appender(buffer), exponent, '0');
-  return grouping.apply(out, string_view(buffer.data(), buffer.size()));
-}
-
-template <typename Char, typename UInt,
-          FMTQUILL_ENABLE_IF(std::is_integral<UInt>::value)>
-inline auto write_significand(Char* out, UInt significand, int significand_size,
-                              int integral_size, Char decimal_point) -> Char* {
-  if (!decimal_point)
-    return format_decimal(out, significand, significand_size).end;
-  out += significand_size + 1;
-  Char* end = out;
-  int floating_size = significand_size - integral_size;
-  for (int i = floating_size / 2; i > 0; --i) {
-    out -= 2;
-    copy2(out, digits2(static_cast<std::size_t>(significand % 100)));
-    significand /= 100;
-  }
-  if (floating_size % 2 != 0) {
-    *--out = static_cast<Char>('0' + significand % 10);
-    significand /= 10;
-  }
-  *--out = decimal_point;
-  format_decimal(out - integral_size, significand, integral_size);
-  return end;
-}
-
-template <typename OutputIt, typename UInt, typename Char,
-          FMTQUILL_ENABLE_IF(!std::is_pointer<remove_cvref_t<OutputIt>>::value)>
-inline auto write_significand(OutputIt out, UInt significand,
-                              int significand_size, int integral_size,
-                              Char decimal_point) -> OutputIt {
-  // Buffer is large enough to hold digits (digits10 + 1) and a decimal point.
-  Char buffer[digits10<UInt>() + 2];
-  auto end = write_significand(buffer, significand, significand_size,
-                               integral_size, decimal_point);
-  return detail::copy_str_noinline<Char>(buffer, end, out);
-}
-
-template <typename OutputIt, typename Char>
-FMTQUILL_CONSTEXPR auto write_significand(OutputIt out, const char* significand,
-                                     int significand_size, int integral_size,
-                                     Char decimal_point) -> OutputIt {
-  out = detail::copy_str_noinline<Char>(significand,
-                                        significand + integral_size, out);
-  if (!decimal_point) return out;
-  *out++ = decimal_point;
-  return detail::copy_str_noinline<Char>(significand + integral_size,
-                                         significand + significand_size, out);
-}
-
-template <typename OutputIt, typename Char, typename T, typename Grouping>
-FMTQUILL_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
-                                       int significand_size, int integral_size,
-                                       Char decimal_point,
-                                       const Grouping& grouping) -> OutputIt {
-  if (!grouping.has_separator()) {
-    return write_significand(out, significand, significand_size, integral_size,
-                             decimal_point);
-  }
-  auto buffer = basic_memory_buffer<Char>();
-  write_significand(buffer_appender<Char>(buffer), significand,
-                    significand_size, integral_size, decimal_point);
-  grouping.apply(
-      out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
-  return detail::copy_str_noinline<Char>(buffer.data() + integral_size,
-                                         buffer.end(), out);
-}
-
-template <typename OutputIt, typename DecimalFP, typename Char,
-          typename Grouping = digit_grouping<Char>>
-FMTQUILL_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
-                                    const format_specs<Char>& specs,
-                                    float_specs fspecs, locale_ref loc)
-    -> OutputIt {
-  auto significand = f.significand;
-  int significand_size = get_significand_size(f);
-  const Char zero = static_cast<Char>('0');
-  auto sign = fspecs.sign;
-  size_t size = to_unsigned(significand_size) + (sign ? 1 : 0);
-  using iterator = reserve_iterator<OutputIt>;
-
-  Char decimal_point =
-      fspecs.locale ? detail::decimal_point<Char>(loc) : static_cast<Char>('.');
-
-  int output_exp = f.exponent + significand_size - 1;
-  auto use_exp_format = [=]() {
-    if (fspecs.format == float_format::exp) return true;
-    if (fspecs.format != float_format::general) return false;
-    // Use the fixed notation if the exponent is in [exp_lower, exp_upper),
-    // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
-    const int exp_lower = -4, exp_upper = 16;
-    return output_exp < exp_lower ||
-           output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper);
-  };
-  if (use_exp_format()) {
-    int num_zeros = 0;
-    if (fspecs.showpoint) {
-      num_zeros = fspecs.precision - significand_size;
-      if (num_zeros < 0) num_zeros = 0;
-      size += to_unsigned(num_zeros);
-    } else if (significand_size == 1) {
-      decimal_point = Char();
-    }
-    auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
-    int exp_digits = 2;
-    if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;
-
-    size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
-    char exp_char = fspecs.upper ? 'E' : 'e';
-    auto write = [=](iterator it) {
-      if (sign) *it++ = detail::sign<Char>(sign);
-      // Insert a decimal point after the first digit and add an exponent.
-      it = write_significand(it, significand, significand_size, 1,
-                             decimal_point);
-      if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero);
-      *it++ = static_cast<Char>(exp_char);
-      return write_exponent<Char>(output_exp, it);
-    };
-    return specs.width > 0 ? write_padded<align::right>(out, specs, size, write)
-                           : base_iterator(out, write(reserve(out, size)));
-  }
-
-  int exp = f.exponent + significand_size;
-  if (f.exponent >= 0) {
-    // 1234e5 -> 123400000[.0+]
-    size += to_unsigned(f.exponent);
-    int num_zeros = fspecs.precision - exp;
-    abort_fuzzing_if(num_zeros > 5000);
-    if (fspecs.showpoint) {
-      ++size;
-      if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 0;
-      if (num_zeros > 0) size += to_unsigned(num_zeros);
-    }
-    auto grouping = Grouping(loc, fspecs.locale);
-    size += to_unsigned(grouping.count_separators(exp));
-    return write_padded<align::right>(out, specs, size, [&](iterator it) {
-      if (sign) *it++ = detail::sign<Char>(sign);
-      it = write_significand<Char>(it, significand, significand_size,
-                                   f.exponent, grouping);
-      if (!fspecs.showpoint) return it;
-      *it++ = decimal_point;
-      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
-    });
-  } else if (exp > 0) {
-    // 1234e-2 -> 12.34[0+]
-    int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0;
-    size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0);
-    auto grouping = Grouping(loc, fspecs.locale);
-    size += to_unsigned(grouping.count_separators(exp));
-    return write_padded<align::right>(out, specs, size, [&](iterator it) {
-      if (sign) *it++ = detail::sign<Char>(sign);
-      it = write_significand(it, significand, significand_size, exp,
-                             decimal_point, grouping);
-      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
-    });
-  }
-  // 1234e-6 -> 0.001234
-  int num_zeros = -exp;
-  if (significand_size == 0 && fspecs.precision >= 0 &&
-      fspecs.precision < num_zeros) {
-    num_zeros = fspecs.precision;
-  }
-  bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint;
-  size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros);
-  return write_padded<align::right>(out, specs, size, [&](iterator it) {
-    if (sign) *it++ = detail::sign<Char>(sign);
-    *it++ = zero;
-    if (!pointy) return it;
-    *it++ = decimal_point;
-    it = detail::fill_n(it, num_zeros, zero);
-    return write_significand<Char>(it, significand, significand_size);
-  });
-}
-
-template <typename Char> class fallback_digit_grouping {
- public:
-  constexpr fallback_digit_grouping(locale_ref, bool) {}
-
-  constexpr auto has_separator() const -> bool { return false; }
-
-  constexpr auto count_separators(int) const -> int { return 0; }
-
-  template <typename Out, typename C>
-  constexpr auto apply(Out out, basic_string_view<C>) const -> Out {
-    return out;
-  }
-};
-
-template <typename OutputIt, typename DecimalFP, typename Char>
-FMTQUILL_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f,
-                                 const format_specs<Char>& specs,
-                                 float_specs fspecs, locale_ref loc)
-    -> OutputIt {
-  if (is_constant_evaluated()) {
-    return do_write_float<OutputIt, DecimalFP, Char,
-                          fallback_digit_grouping<Char>>(out, f, specs, fspecs,
-                                                         loc);
-  } else {
-    return do_write_float(out, f, specs, fspecs, loc);
-  }
-}
-
-template <typename T> constexpr auto isnan(T value) -> bool {
-  return !(value >= value);  // std::isnan doesn't support __float128.
-}
-
-template <typename T, typename Enable = void>
-struct has_isfinite : std::false_type {};
-
-template <typename T>
-struct has_isfinite<T, enable_if_t<sizeof(std::isfinite(T())) != 0>>
-    : std::true_type {};
-
-template <typename T, FMTQUILL_ENABLE_IF(std::is_floating_point<T>::value&&
-                                        has_isfinite<T>::value)>
-FMTQUILL_CONSTEXPR20 auto isfinite(T value) -> bool {
-  constexpr T inf = T(std::numeric_limits<double>::infinity());
-  if (is_constant_evaluated())
-    return !detail::isnan(value) && value < inf && value > -inf;
-  return std::isfinite(value);
-}
-template <typename T, FMTQUILL_ENABLE_IF(!has_isfinite<T>::value)>
-FMTQUILL_CONSTEXPR auto isfinite(T value) -> bool {
-  T inf = T(std::numeric_limits<double>::infinity());
-  // std::isfinite doesn't support __float128.
-  return !detail::isnan(value) && value < inf && value > -inf;
-}
-
-template <typename T, FMTQUILL_ENABLE_IF(is_floating_point<T>::value)>
-FMTQUILL_INLINE FMTQUILL_CONSTEXPR bool signbit(T value) {
-  if (is_constant_evaluated()) {
-#ifdef __cpp_if_constexpr
-    if constexpr (std::numeric_limits<double>::is_iec559) {
-      auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value));
-      return (bits >> (num_bits<uint64_t>() - 1)) != 0;
-    }
-#endif
-  }
-  return std::signbit(static_cast<double>(value));
-}
-
-inline FMTQUILL_CONSTEXPR20 void adjust_precision(int& precision, int exp10) {
-  // Adjust fixed precision by exponent because it is relative to decimal
-  // point.
-  if (exp10 > 0 && precision > max_value<int>() - exp10)
-    FMTQUILL_THROW(format_error("number is too big"));
-  precision += exp10;
-}
-
-class bigint {
- private:
-  // A bigint is stored as an array of bigits (big digits), with bigit at index
-  // 0 being the least significant one.
-  using bigit = uint32_t;
-  using double_bigit = uint64_t;
-  enum { bigits_capacity = 32 };
-  basic_memory_buffer<bigit, bigits_capacity> bigits_;
-  int exp_;
-
-  FMTQUILL_CONSTEXPR20 auto operator[](int index) const -> bigit {
-    return bigits_[to_unsigned(index)];
-  }
-  FMTQUILL_CONSTEXPR20 auto operator[](int index) -> bigit& {
-    return bigits_[to_unsigned(index)];
-  }
-
-  static constexpr const int bigit_bits = num_bits<bigit>();
-
-  friend struct formatter<bigint>;
-
-  FMTQUILL_CONSTEXPR20 void subtract_bigits(int index, bigit other, bigit& borrow) {
-    auto result = static_cast<double_bigit>((*this)[index]) - other - borrow;
-    (*this)[index] = static_cast<bigit>(result);
-    borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
-  }
-
-  FMTQUILL_CONSTEXPR20 void remove_leading_zeros() {
-    int num_bigits = static_cast<int>(bigits_.size()) - 1;
-    while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;
-    bigits_.resize(to_unsigned(num_bigits + 1));
-  }
-
-  // Computes *this -= other assuming aligned bigints and *this >= other.
-  FMTQUILL_CONSTEXPR20 void subtract_aligned(const bigint& other) {
-    FMTQUILL_ASSERT(other.exp_ >= exp_, "unaligned bigints");
-    FMTQUILL_ASSERT(compare(*this, other) >= 0, "");
-    bigit borrow = 0;
-    int i = other.exp_ - exp_;
-    for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
-      subtract_bigits(i, other.bigits_[j], borrow);
-    while (borrow > 0) subtract_bigits(i, 0, borrow);
-    remove_leading_zeros();
-  }
-
-  FMTQUILL_CONSTEXPR20 void multiply(uint32_t value) {
-    const double_bigit wide_value = value;
-    bigit carry = 0;
-    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
-      double_bigit result = bigits_[i] * wide_value + carry;
-      bigits_[i] = static_cast<bigit>(result);
-      carry = static_cast<bigit>(result >> bigit_bits);
-    }
-    if (carry != 0) bigits_.push_back(carry);
-  }
-
-  template <typename UInt, FMTQUILL_ENABLE_IF(std::is_same<UInt, uint64_t>::value ||
-                                         std::is_same<UInt, uint128_t>::value)>
-  FMTQUILL_CONSTEXPR20 void multiply(UInt value) {
-    using half_uint =
-        conditional_t<std::is_same<UInt, uint128_t>::value, uint64_t, uint32_t>;
-    const int shift = num_bits<half_uint>() - bigit_bits;
-    const UInt lower = static_cast<half_uint>(value);
-    const UInt upper = value >> num_bits<half_uint>();
-    UInt carry = 0;
-    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
-      UInt result = lower * bigits_[i] + static_cast<bigit>(carry);
-      carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) +
-              (carry >> bigit_bits);
-      bigits_[i] = static_cast<bigit>(result);
-    }
-    while (carry != 0) {
-      bigits_.push_back(static_cast<bigit>(carry));
-      carry >>= bigit_bits;
-    }
-  }
-
-  template <typename UInt, FMTQUILL_ENABLE_IF(std::is_same<UInt, uint64_t>::value ||
-                                         std::is_same<UInt, uint128_t>::value)>
-  FMTQUILL_CONSTEXPR20 void assign(UInt n) {
-    size_t num_bigits = 0;
-    do {
-      bigits_[num_bigits++] = static_cast<bigit>(n);
-      n >>= bigit_bits;
-    } while (n != 0);
-    bigits_.resize(num_bigits);
-    exp_ = 0;
-  }
-
- public:
-  FMTQUILL_CONSTEXPR20 bigint() : exp_(0) {}
-  explicit bigint(uint64_t n) { assign(n); }
-
-  bigint(const bigint&) = delete;
-  void operator=(const bigint&) = delete;
-
-  FMTQUILL_CONSTEXPR20 void assign(const bigint& other) {
-    auto size = other.bigits_.size();
-    bigits_.resize(size);
-    auto data = other.bigits_.data();
-    copy_str<bigit>(data, data + size, bigits_.data());
-    exp_ = other.exp_;
-  }
-
-  template <typename Int> FMTQUILL_CONSTEXPR20 void operator=(Int n) {
-    FMTQUILL_ASSERT(n > 0, "");
-    assign(uint64_or_128_t<Int>(n));
-  }
-
-  FMTQUILL_CONSTEXPR20 auto num_bigits() const -> int {
-    return static_cast<int>(bigits_.size()) + exp_;
-  }
-
-  FMTQUILL_NOINLINE FMTQUILL_CONSTEXPR20 auto operator<<=(int shift) -> bigint& {
-    FMTQUILL_ASSERT(shift >= 0, "");
-    exp_ += shift / bigit_bits;
-    shift %= bigit_bits;
-    if (shift == 0) return *this;
-    bigit carry = 0;
-    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
-      bigit c = bigits_[i] >> (bigit_bits - shift);
-      bigits_[i] = (bigits_[i] << shift) + carry;
-      carry = c;
-    }
-    if (carry != 0) bigits_.push_back(carry);
-    return *this;
-  }
-
-  template <typename Int>
-  FMTQUILL_CONSTEXPR20 auto operator*=(Int value) -> bigint& {
-    FMTQUILL_ASSERT(value > 0, "");
-    multiply(uint32_or_64_or_128_t<Int>(value));
-    return *this;
-  }
-
-  friend FMTQUILL_CONSTEXPR20 auto compare(const bigint& lhs, const bigint& rhs)
-      -> int {
-    int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
-    if (num_lhs_bigits != num_rhs_bigits)
-      return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
-    int i = static_cast<int>(lhs.bigits_.size()) - 1;
-    int j = static_cast<int>(rhs.bigits_.size()) - 1;
-    int end = i - j;
-    if (end < 0) end = 0;
-    for (; i >= end; --i, --j) {
-      bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j];
-      if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1;
-    }
-    if (i != j) return i > j ? 1 : -1;
-    return 0;
-  }
-
-  // Returns compare(lhs1 + lhs2, rhs).
-  friend FMTQUILL_CONSTEXPR20 auto add_compare(const bigint& lhs1,
-                                          const bigint& lhs2, const bigint& rhs)
-      -> int {
-    auto minimum = [](int a, int b) { return a < b ? a : b; };
-    auto maximum = [](int a, int b) { return a > b ? a : b; };
-    int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits());
-    int num_rhs_bigits = rhs.num_bigits();
-    if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
-    if (max_lhs_bigits > num_rhs_bigits) return 1;
-    auto get_bigit = [](const bigint& n, int i) -> bigit {
-      return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0;
-    };
-    double_bigit borrow = 0;
-    int min_exp = minimum(minimum(lhs1.exp_, lhs2.exp_), rhs.exp_);
-    for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
-      double_bigit sum =
-          static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
-      bigit rhs_bigit = get_bigit(rhs, i);
-      if (sum > rhs_bigit + borrow) return 1;
-      borrow = rhs_bigit + borrow - sum;
-      if (borrow > 1) return -1;
-      borrow <<= bigit_bits;
-    }
-    return borrow != 0 ? -1 : 0;
-  }
-
-  // Assigns pow(10, exp) to this bigint.
-  FMTQUILL_CONSTEXPR20 void assign_pow10(int exp) {
-    FMTQUILL_ASSERT(exp >= 0, "");
-    if (exp == 0) return *this = 1;
-    // Find the top bit.
-    int bitmask = 1;
-    while (exp >= bitmask) bitmask <<= 1;
-    bitmask >>= 1;
-    // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
-    // repeated squaring and multiplication.
-    *this = 5;
-    bitmask >>= 1;
-    while (bitmask != 0) {
-      square();
-      if ((exp & bitmask) != 0) *this *= 5;
-      bitmask >>= 1;
-    }
-    *this <<= exp;  // Multiply by pow(2, exp) by shifting.
-  }
-
-  FMTQUILL_CONSTEXPR20 void square() {
-    int num_bigits = static_cast<int>(bigits_.size());
-    int num_result_bigits = 2 * num_bigits;
-    basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
-    bigits_.resize(to_unsigned(num_result_bigits));
-    auto sum = uint128_t();
-    for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
-      // Compute bigit at position bigit_index of the result by adding
-      // cross-product terms n[i] * n[j] such that i + j == bigit_index.
-      for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
-        // Most terms are multiplied twice which can be optimized in the future.
-        sum += static_cast<double_bigit>(n[i]) * n[j];
-      }
-      (*this)[bigit_index] = static_cast<bigit>(sum);
-      sum >>= num_bits<bigit>();  // Compute the carry.
-    }
-    // Do the same for the top half.
-    for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
-         ++bigit_index) {
-      for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
-        sum += static_cast<double_bigit>(n[i++]) * n[j--];
-      (*this)[bigit_index] = static_cast<bigit>(sum);
-      sum >>= num_bits<bigit>();
-    }
-    remove_leading_zeros();
-    exp_ *= 2;
-  }
-
-  // If this bigint has a bigger exponent than other, adds trailing zero to make
-  // exponents equal. This simplifies some operations such as subtraction.
-  FMTQUILL_CONSTEXPR20 void align(const bigint& other) {
-    int exp_difference = exp_ - other.exp_;
-    if (exp_difference <= 0) return;
-    int num_bigits = static_cast<int>(bigits_.size());
-    bigits_.resize(to_unsigned(num_bigits + exp_difference));
-    for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
-      bigits_[j] = bigits_[i];
-    std::uninitialized_fill_n(bigits_.data(), exp_difference, 0u);
-    exp_ -= exp_difference;
-  }
-
-  // Divides this bignum by divisor, assigning the remainder to this and
-  // returning the quotient.
-  FMTQUILL_CONSTEXPR20 auto divmod_assign(const bigint& divisor) -> int {
-    FMTQUILL_ASSERT(this != &divisor, "");
-    if (compare(*this, divisor) < 0) return 0;
-    FMTQUILL_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
-    align(divisor);
-    int quotient = 0;
-    do {
-      subtract_aligned(divisor);
-      ++quotient;
-    } while (compare(*this, divisor) >= 0);
-    return quotient;
-  }
-};
-
-// format_dragon flags.
-enum dragon {
-  predecessor_closer = 1,
-  fixup = 2,  // Run fixup to correct exp10 which can be off by one.
-  fixed = 4,
-};
-
-// Formats a floating-point number using a variation of the Fixed-Precision
-// Positive Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
-// https://fmt.dev/papers/p372-steele.pdf.
-FMTQUILL_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value,
-                                          unsigned flags, int num_digits,
-                                          buffer<char>& buf, int& exp10) {
-  bigint numerator;    // 2 * R in (FPP)^2.
-  bigint denominator;  // 2 * S in (FPP)^2.
-  // lower and upper are differences between value and corresponding boundaries.
-  bigint lower;             // (M^- in (FPP)^2).
-  bigint upper_store;       // upper's value if different from lower.
-  bigint* upper = nullptr;  // (M^+ in (FPP)^2).
-  // Shift numerator and denominator by an extra bit or two (if lower boundary
-  // is closer) to make lower and upper integers. This eliminates multiplication
-  // by 2 during later computations.
-  bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0;
-  int shift = is_predecessor_closer ? 2 : 1;
-  if (value.e >= 0) {
-    numerator = value.f;
-    numerator <<= value.e + shift;
-    lower = 1;
-    lower <<= value.e;
-    if (is_predecessor_closer) {
-      upper_store = 1;
-      upper_store <<= value.e + 1;
-      upper = &upper_store;
-    }
-    denominator.assign_pow10(exp10);
-    denominator <<= shift;
-  } else if (exp10 < 0) {
-    numerator.assign_pow10(-exp10);
-    lower.assign(numerator);
-    if (is_predecessor_closer) {
-      upper_store.assign(numerator);
-      upper_store <<= 1;
-      upper = &upper_store;
-    }
-    numerator *= value.f;
-    numerator <<= shift;
-    denominator = 1;
-    denominator <<= shift - value.e;
-  } else {
-    numerator = value.f;
-    numerator <<= shift;
-    denominator.assign_pow10(exp10);
-    denominator <<= shift - value.e;
-    lower = 1;
-    if (is_predecessor_closer) {
-      upper_store = 1ULL << 1;
-      upper = &upper_store;
-    }
-  }
-  int even = static_cast<int>((value.f & 1) == 0);
-  if (!upper) upper = &lower;
-  bool shortest = num_digits < 0;
-  if ((flags & dragon::fixup) != 0) {
-    if (add_compare(numerator, *upper, denominator) + even <= 0) {
-      --exp10;
-      numerator *= 10;
-      if (num_digits < 0) {
-        lower *= 10;
-        if (upper != &lower) *upper *= 10;
-      }
-    }
-    if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1);
-  }
-  // Invariant: value == (numerator / denominator) * pow(10, exp10).
-  if (shortest) {
-    // Generate the shortest representation.
-    num_digits = 0;
-    char* data = buf.data();
-    for (;;) {
-      int digit = numerator.divmod_assign(denominator);
-      bool low = compare(numerator, lower) - even < 0;  // numerator <[=] lower.
-      // numerator + upper >[=] pow10:
-      bool high = add_compare(numerator, *upper, denominator) + even > 0;
-      data[num_digits++] = static_cast<char>('0' + digit);
-      if (low || high) {
-        if (!low) {
-          ++data[num_digits - 1];
-        } else if (high) {
-          int result = add_compare(numerator, numerator, denominator);
-          // Round half to even.
-          if (result > 0 || (result == 0 && (digit % 2) != 0))
-            ++data[num_digits - 1];
-        }
-        buf.try_resize(to_unsigned(num_digits));
-        exp10 -= num_digits - 1;
-        return;
-      }
-      numerator *= 10;
-      lower *= 10;
-      if (upper != &lower) *upper *= 10;
-    }
-  }
-  // Generate the given number of digits.
-  exp10 -= num_digits - 1;
-  if (num_digits <= 0) {
-    denominator *= 10;
-    auto digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
-    buf.push_back(digit);
-    return;
-  }
-  buf.try_resize(to_unsigned(num_digits));
-  for (int i = 0; i < num_digits - 1; ++i) {
-    int digit = numerator.divmod_assign(denominator);
-    buf[i] = static_cast<char>('0' + digit);
-    numerator *= 10;
-  }
-  int digit = numerator.divmod_assign(denominator);
-  auto result = add_compare(numerator, numerator, denominator);
-  if (result > 0 || (result == 0 && (digit % 2) != 0)) {
-    if (digit == 9) {
-      const auto overflow = '0' + 10;
-      buf[num_digits - 1] = overflow;
-      // Propagate the carry.
-      for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) {
-        buf[i] = '0';
-        ++buf[i - 1];
-      }
-      if (buf[0] == overflow) {
-        buf[0] = '1';
-        if ((flags & dragon::fixed) != 0)
-          buf.push_back('0');
-        else
-          ++exp10;
-      }
-      return;
-    }
-    ++digit;
-  }
-  buf[num_digits - 1] = static_cast<char>('0' + digit);
-}
-
-// Formats a floating-point number using the hexfloat format.
-template <typename Float, FMTQUILL_ENABLE_IF(!is_double_double<Float>::value)>
-FMTQUILL_CONSTEXPR20 void format_hexfloat(Float value, int precision,
-                                     float_specs specs, buffer<char>& buf) {
-  // float is passed as double to reduce the number of instantiations and to
-  // simplify implementation.
-  static_assert(!std::is_same<Float, float>::value, "");
-
-  using info = dragonbox::float_info<Float>;
-
-  // Assume Float is in the format [sign][exponent][significand].
-  using carrier_uint = typename info::carrier_uint;
-
-  constexpr auto num_float_significand_bits =
-      detail::num_significand_bits<Float>();
-
-  basic_fp<carrier_uint> f(value);
-  f.e += num_float_significand_bits;
-  if (!has_implicit_bit<Float>()) --f.e;
-
-  constexpr auto num_fraction_bits =
-      num_float_significand_bits + (has_implicit_bit<Float>() ? 1 : 0);
-  constexpr auto num_xdigits = (num_fraction_bits + 3) / 4;
-
-  constexpr auto leading_shift = ((num_xdigits - 1) * 4);
-  const auto leading_mask = carrier_uint(0xF) << leading_shift;
-  const auto leading_xdigit =
-      static_cast<uint32_t>((f.f & leading_mask) >> leading_shift);
-  if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1);
-
-  int print_xdigits = num_xdigits - 1;
-  if (precision >= 0 && print_xdigits > precision) {
-    const int shift = ((print_xdigits - precision - 1) * 4);
-    const auto mask = carrier_uint(0xF) << shift;
-    const auto v = static_cast<uint32_t>((f.f & mask) >> shift);
-
-    if (v >= 8) {
-      const auto inc = carrier_uint(1) << (shift + 4);
-      f.f += inc;
-      f.f &= ~(inc - 1);
-    }
-
-    // Check long double overflow
-    if (!has_implicit_bit<Float>()) {
-      const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
-      if ((f.f & implicit_bit) == implicit_bit) {
-        f.f >>= 4;
-        f.e += 4;
-      }
-    }
-
-    print_xdigits = precision;
-  }
-
-  char xdigits[num_bits<carrier_uint>() / 4];
-  detail::fill_n(xdigits, sizeof(xdigits), '0');
-  format_uint<4>(xdigits, f.f, num_xdigits, specs.upper);
-
-  // Remove zero tail
-  while (print_xdigits > 0 && xdigits[print_xdigits] == '0') --print_xdigits;
-
-  buf.push_back('0');
-  buf.push_back(specs.upper ? 'X' : 'x');
-  buf.push_back(xdigits[0]);
-  if (specs.showpoint || print_xdigits > 0 || print_xdigits < precision)
-    buf.push_back('.');
-  buf.append(xdigits + 1, xdigits + 1 + print_xdigits);
-  for (; print_xdigits < precision; ++print_xdigits) buf.push_back('0');
-
-  buf.push_back(specs.upper ? 'P' : 'p');
-
-  uint32_t abs_e;
-  if (f.e < 0) {
-    buf.push_back('-');
-    abs_e = static_cast<uint32_t>(-f.e);
-  } else {
-    buf.push_back('+');
-    abs_e = static_cast<uint32_t>(f.e);
-  }
-  format_decimal<char>(appender(buf), abs_e, detail::count_digits(abs_e));
-}
-
-template <typename Float, FMTQUILL_ENABLE_IF(is_double_double<Float>::value)>
-FMTQUILL_CONSTEXPR20 void format_hexfloat(Float value, int precision,
-                                     float_specs specs, buffer<char>& buf) {
-  format_hexfloat(static_cast<double>(value), precision, specs, buf);
-}
-
-constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t {
-  // For checking rounding thresholds.
-  // The kth entry is chosen to be the smallest integer such that the
-  // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k.
-  // It is equal to ceil(2^31 + 2^32/10^(k + 1)).
-  // These are stored in a string literal because we cannot have static arrays
-  // in constexpr functions and non-static ones are poorly optimized.
-  return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7"
-         U"\x800001ae\x8000002b"[index];
-}
-
-template <typename Float>
-FMTQUILL_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs,
-                                  buffer<char>& buf) -> int {
-  // float is passed as double to reduce the number of instantiations.
-  static_assert(!std::is_same<Float, float>::value, "");
-  FMTQUILL_ASSERT(value >= 0, "value is negative");
-  auto converted_value = convert_float(value);
-
-  const bool fixed = specs.format == float_format::fixed;
-  if (value <= 0) {  // <= instead of == to silence a warning.
-    if (precision <= 0 || !fixed) {
-      buf.push_back('0');
-      return 0;
-    }
-    buf.try_resize(to_unsigned(precision));
-    fill_n(buf.data(), precision, '0');
-    return -precision;
-  }
-
-  int exp = 0;
-  bool use_dragon = true;
-  unsigned dragon_flags = 0;
-  if (!is_fast_float<Float>() || is_constant_evaluated()) {
-    const auto inv_log2_10 = 0.3010299956639812;  // 1 / log2(10)
-    using info = dragonbox::float_info<decltype(converted_value)>;
-    const auto f = basic_fp<typename info::carrier_uint>(converted_value);
-    // Compute exp, an approximate power of 10, such that
-    //   10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1).
-    // This is based on log10(value) == log2(value) / log2(10) and approximation
-    // of log2(value) by e + num_fraction_bits idea from double-conversion.
-    auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10;
-    exp = static_cast<int>(e);
-    if (e > exp) ++exp;  // Compute ceil.
-    dragon_flags = dragon::fixup;
-  } else if (precision < 0) {
-    // Use Dragonbox for the shortest format.
-    if (specs.binary32) {
-      auto dec = dragonbox::to_decimal(static_cast<float>(value));
-      write<char>(buffer_appender<char>(buf), dec.significand);
-      return dec.exponent;
-    }
-    auto dec = dragonbox::to_decimal(static_cast<double>(value));
-    write<char>(buffer_appender<char>(buf), dec.significand);
-    return dec.exponent;
-  } else {
-    // Extract significand bits and exponent bits.
-    using info = dragonbox::float_info<double>;
-    auto br = bit_cast<uint64_t>(static_cast<double>(value));
-
-    const uint64_t significand_mask =
-        (static_cast<uint64_t>(1) << num_significand_bits<double>()) - 1;
-    uint64_t significand = (br & significand_mask);
-    int exponent = static_cast<int>((br & exponent_mask<double>()) >>
-                                    num_significand_bits<double>());
-
-    if (exponent != 0) {  // Check if normal.
-      exponent -= exponent_bias<double>() + num_significand_bits<double>();
-      significand |=
-          (static_cast<uint64_t>(1) << num_significand_bits<double>());
-      significand <<= 1;
-    } else {
-      // Normalize subnormal inputs.
-      FMTQUILL_ASSERT(significand != 0, "zeros should not appear here");
-      int shift = countl_zero(significand);
-      FMTQUILL_ASSERT(shift >= num_bits<uint64_t>() - num_significand_bits<double>(),
-                 "");
-      shift -= (num_bits<uint64_t>() - num_significand_bits<double>() - 2);
-      exponent = (std::numeric_limits<double>::min_exponent -
-                  num_significand_bits<double>()) -
-                 shift;
-      significand <<= shift;
-    }
-
-    // Compute the first several nonzero decimal significand digits.
-    // We call the number we get the first segment.
-    const int k = info::kappa - dragonbox::floor_log10_pow2(exponent);
-    exp = -k;
-    const int beta = exponent + dragonbox::floor_log2_pow10(k);
-    uint64_t first_segment;
-    bool has_more_segments;
-    int digits_in_the_first_segment;
-    {
-      const auto r = dragonbox::umul192_upper128(
-          significand << beta, dragonbox::get_cached_power(k));
-      first_segment = r.high();
-      has_more_segments = r.low() != 0;
-
-      // The first segment can have 18 ~ 19 digits.
-      if (first_segment >= 1000000000000000000ULL) {
-        digits_in_the_first_segment = 19;
-      } else {
-        // When it is of 18-digits, we align it to 19-digits by adding a bogus
-        // zero at the end.
-        digits_in_the_first_segment = 18;
-        first_segment *= 10;
-      }
-    }
-
-    // Compute the actual number of decimal digits to print.
-    if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment);
-
-    // Use Dragon4 only when there might be not enough digits in the first
-    // segment.
-    if (digits_in_the_first_segment > precision) {
-      use_dragon = false;
-
-      if (precision <= 0) {
-        exp += digits_in_the_first_segment;
-
-        if (precision < 0) {
-          // Nothing to do, since all we have are just leading zeros.
-          buf.try_resize(0);
-        } else {
-          // We may need to round-up.
-          buf.try_resize(1);
-          if ((first_segment | static_cast<uint64_t>(has_more_segments)) >
-              5000000000000000000ULL) {
-            buf[0] = '1';
-          } else {
-            buf[0] = '0';
-          }
-        }
-      }  // precision <= 0
-      else {
-        exp += digits_in_the_first_segment - precision;
-
-        // When precision > 0, we divide the first segment into three
-        // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits
-        // in 32-bits which usually allows faster calculation than in
-        // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize
-        // division-by-constant for large 64-bit divisors, we do it here
-        // manually. The magic number 7922816251426433760 below is equal to
-        // ceil(2^(64+32) / 10^10).
-        const uint32_t first_subsegment = static_cast<uint32_t>(
-            dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >>
-            32);
-        const uint64_t second_third_subsegments =
-            first_segment - first_subsegment * 10000000000ULL;
-
-        uint64_t prod;
-        uint32_t digits;
-        bool should_round_up;
-        int number_of_digits_to_print = precision > 9 ? 9 : precision;
-
-        // Print a 9-digits subsegment, either the first or the second.
-        auto print_subsegment = [&](uint32_t subsegment, char* buffer) {
-          int number_of_digits_printed = 0;
-
-          // If we want to print an odd number of digits from the subsegment,
-          if ((number_of_digits_to_print & 1) != 0) {
-            // Convert to 64-bit fixed-point fractional form with 1-digit
-            // integer part. The magic number 720575941 is a good enough
-            // approximation of 2^(32 + 24) / 10^8; see
-            // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
-            // for details.
-            prod = ((subsegment * static_cast<uint64_t>(720575941)) >> 24) + 1;
-            digits = static_cast<uint32_t>(prod >> 32);
-            *buffer = static_cast<char>('0' + digits);
-            number_of_digits_printed++;
-          }
-          // If we want to print an even number of digits from the
-          // first_subsegment,
-          else {
-            // Convert to 64-bit fixed-point fractional form with 2-digits
-            // integer part. The magic number 450359963 is a good enough
-            // approximation of 2^(32 + 20) / 10^7; see
-            // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
-            // for details.
-            prod = ((subsegment * static_cast<uint64_t>(450359963)) >> 20) + 1;
-            digits = static_cast<uint32_t>(prod >> 32);
-            copy2(buffer, digits2(digits));
-            number_of_digits_printed += 2;
-          }
-
-          // Print all digit pairs.
-          while (number_of_digits_printed < number_of_digits_to_print) {
-            prod = static_cast<uint32_t>(prod) * static_cast<uint64_t>(100);
-            digits = static_cast<uint32_t>(prod >> 32);
-            copy2(buffer + number_of_digits_printed, digits2(digits));
-            number_of_digits_printed += 2;
-          }
-        };
-
-        // Print first subsegment.
-        print_subsegment(first_subsegment, buf.data());
-
-        // Perform rounding if the first subsegment is the last subsegment to
-        // print.
-        if (precision <= 9) {
-          // Rounding inside the subsegment.
-          // We round-up if:
-          //  - either the fractional part is strictly larger than 1/2, or
-          //  - the fractional part is exactly 1/2 and the last digit is odd.
-          // We rely on the following observations:
-          //  - If fractional_part >= threshold, then the fractional part is
-          //    strictly larger than 1/2.
-          //  - If the MSB of fractional_part is set, then the fractional part
-          //    must be at least 1/2.
-          //  - When the MSB of fractional_part is set, either
-          //    second_third_subsegments being nonzero or has_more_segments
-          //    being true means there are further digits not printed, so the
-          //    fractional part is strictly larger than 1/2.
-          if (precision < 9) {
-            uint32_t fractional_part = static_cast<uint32_t>(prod);
-            should_round_up =
-                fractional_part >= fractional_part_rounding_thresholds(
-                                       8 - number_of_digits_to_print) ||
-                ((fractional_part >> 31) &
-                 ((digits & 1) | (second_third_subsegments != 0) |
-                  has_more_segments)) != 0;
-          }
-          // Rounding at the subsegment boundary.
-          // In this case, the fractional part is at least 1/2 if and only if
-          // second_third_subsegments >= 5000000000ULL, and is strictly larger
-          // than 1/2 if we further have either second_third_subsegments >
-          // 5000000000ULL or has_more_segments == true.
-          else {
-            should_round_up = second_third_subsegments > 5000000000ULL ||
-                              (second_third_subsegments == 5000000000ULL &&
-                               ((digits & 1) != 0 || has_more_segments));
-          }
-        }
-        // Otherwise, print the second subsegment.
-        else {
-          // Compilers are not aware of how to leverage the maximum value of
-          // second_third_subsegments to find out a better magic number which
-          // allows us to eliminate an additional shift. 1844674407370955162 =
-          // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))).
-          const uint32_t second_subsegment =
-              static_cast<uint32_t>(dragonbox::umul128_upper64(
-                  second_third_subsegments, 1844674407370955162ULL));
-          const uint32_t third_subsegment =
-              static_cast<uint32_t>(second_third_subsegments) -
-              second_subsegment * 10;
-
-          number_of_digits_to_print = precision - 9;
-          print_subsegment(second_subsegment, buf.data() + 9);
-
-          // Rounding inside the subsegment.
-          if (precision < 18) {
-            // The condition third_subsegment != 0 implies that the segment was
-            // of 19 digits, so in this case the third segment should be
-            // consisting of a genuine digit from the input.
-            uint32_t fractional_part = static_cast<uint32_t>(prod);
-            should_round_up =
-                fractional_part >= fractional_part_rounding_thresholds(
-                                       8 - number_of_digits_to_print) ||
-                ((fractional_part >> 31) &
-                 ((digits & 1) | (third_subsegment != 0) |
-                  has_more_segments)) != 0;
-          }
-          // Rounding at the subsegment boundary.
-          else {
-            // In this case, the segment must be of 19 digits, thus
-            // the third subsegment should be consisting of a genuine digit from
-            // the input.
-            should_round_up = third_subsegment > 5 ||
-                              (third_subsegment == 5 &&
-                               ((digits & 1) != 0 || has_more_segments));
-          }
-        }
-
-        // Round-up if necessary.
-        if (should_round_up) {
-          ++buf[precision - 1];
-          for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) {
-            buf[i] = '0';
-            ++buf[i - 1];
-          }
-          if (buf[0] > '9') {
-            buf[0] = '1';
-            if (fixed)
-              buf[precision++] = '0';
-            else
-              ++exp;
-          }
-        }
-        buf.try_resize(to_unsigned(precision));
-      }
-    }  // if (digits_in_the_first_segment > precision)
-    else {
-      // Adjust the exponent for its use in Dragon4.
-      exp += digits_in_the_first_segment - 1;
-    }
-  }
-  if (use_dragon) {
-    auto f = basic_fp<uint128_t>();
-    bool is_predecessor_closer = specs.binary32
-                                     ? f.assign(static_cast<float>(value))
-                                     : f.assign(converted_value);
-    if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer;
-    if (fixed) dragon_flags |= dragon::fixed;
-    // Limit precision to the maximum possible number of significant digits in
-    // an IEEE754 double because we don't need to generate zeros.
-    const int max_double_digits = 767;
-    if (precision > max_double_digits) precision = max_double_digits;
-    format_dragon(f, dragon_flags, precision, buf, exp);
-  }
-  if (!fixed && !specs.showpoint) {
-    // Remove trailing zeros.
-    auto num_digits = buf.size();
-    while (num_digits > 0 && buf[num_digits - 1] == '0') {
-      --num_digits;
-      ++exp;
-    }
-    buf.try_resize(num_digits);
-  }
-  return exp;
-}
-template <typename Char, typename OutputIt, typename T>
-FMTQUILL_CONSTEXPR20 auto write_float(OutputIt out, T value,
-                                 format_specs<Char> specs, locale_ref loc)
-    -> OutputIt {
-  float_specs fspecs = parse_float_type_spec(specs);
-  fspecs.sign = specs.sign;
-  if (detail::signbit(value)) {  // value < 0 is false for NaN so use signbit.
-    fspecs.sign = sign::minus;
-    value = -value;
-  } else if (fspecs.sign == sign::minus) {
-    fspecs.sign = sign::none;
-  }
-
-  if (!detail::isfinite(value))
-    return write_nonfinite(out, detail::isnan(value), specs, fspecs);
-
-  if (specs.align == align::numeric && fspecs.sign) {
-    auto it = reserve(out, 1);
-    *it++ = detail::sign<Char>(fspecs.sign);
-    out = base_iterator(out, it);
-    fspecs.sign = sign::none;
-    if (specs.width != 0) --specs.width;
-  }
-
-  memory_buffer buffer;
-  if (fspecs.format == float_format::hex) {
-    if (fspecs.sign) buffer.push_back(detail::sign<char>(fspecs.sign));
-    format_hexfloat(convert_float(value), specs.precision, fspecs, buffer);
-    return write_bytes<align::right>(out, {buffer.data(), buffer.size()},
-                                     specs);
-  }
-  int precision = specs.precision >= 0 || specs.type == presentation_type::none
-                      ? specs.precision
-                      : 6;
-  if (fspecs.format == float_format::exp) {
-    if (precision == max_value<int>())
-      throw_format_error("number is too big");
-    else
-      ++precision;
-  } else if (fspecs.format != float_format::fixed && precision == 0) {
-    precision = 1;
-  }
-  if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
-  int exp = format_float(convert_float(value), precision, fspecs, buffer);
-  fspecs.precision = precision;
-  auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
-  return write_float(out, f, specs, fspecs, loc);
-}
-
-template <typename Char, typename OutputIt, typename T,
-          FMTQUILL_ENABLE_IF(is_floating_point<T>::value)>
-FMTQUILL_CONSTEXPR20 auto write(OutputIt out, T value, format_specs<Char> specs,
-                           locale_ref loc = {}) -> OutputIt {
-  if (const_check(!is_supported_floating_point(value))) return out;
-  return specs.localized && write_loc(out, value, specs, loc)
-             ? out
-             : write_float(out, value, specs, loc);
-}
-
-template <typename Char, typename OutputIt, typename T,
-          FMTQUILL_ENABLE_IF(is_fast_float<T>::value)>
-FMTQUILL_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
-  if (is_constant_evaluated()) return write(out, value, format_specs<Char>());
-  if (const_check(!is_supported_floating_point(value))) return out;
-
-  auto fspecs = float_specs();
-  if (detail::signbit(value)) {
-    fspecs.sign = sign::minus;
-    value = -value;
-  }
-
-  constexpr auto specs = format_specs<Char>();
-  using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
-  using floaty_uint = typename dragonbox::float_info<floaty>::carrier_uint;
-  floaty_uint mask = exponent_mask<floaty>();
-  if ((bit_cast<floaty_uint>(value) & mask) == mask)
-    return write_nonfinite(out, std::isnan(value), specs, fspecs);
-
-  auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
-  return write_float(out, dec, specs, fspecs, {});
-}
-
-template <typename Char, typename OutputIt, typename T,
-          FMTQUILL_ENABLE_IF(is_floating_point<T>::value &&
-                        !is_fast_float<T>::value)>
-inline auto write(OutputIt out, T value) -> OutputIt {
-  return write(out, value, format_specs<Char>());
-}
-
-template <typename Char, typename OutputIt>
-auto write(OutputIt out, monostate, format_specs<Char> = {}, locale_ref = {})
-    -> OutputIt {
-  FMTQUILL_ASSERT(false, "");
-  return out;
-}
-
-template <typename Char, typename OutputIt>
-FMTQUILL_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> value)
-    -> OutputIt {
-  auto it = reserve(out, value.size());
-  it = copy_str_noinline<Char>(value.begin(), value.end(), it);
-  return base_iterator(out, it);
-}
-
-template <typename Char, typename OutputIt, typename T,
-          FMTQUILL_ENABLE_IF(is_string<T>::value)>
-constexpr auto write(OutputIt out, const T& value) -> OutputIt {
-  return write<Char>(out, to_string_view(value));
-}
-
-// FMTQUILL_ENABLE_IF() condition separated to workaround an MSVC bug.
-template <
-    typename Char, typename OutputIt, typename T,
-    bool check =
-        std::is_enum<T>::value && !std::is_same<T, Char>::value &&
-        mapped_type_constant<T, basic_format_context<OutputIt, Char>>::value !=
-            type::custom_type,
-    FMTQUILL_ENABLE_IF(check)>
-FMTQUILL_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
-  return write<Char>(out, static_cast<underlying_t<T>>(value));
-}
-
-template <typename Char, typename OutputIt, typename T,
-          FMTQUILL_ENABLE_IF(std::is_same<T, bool>::value)>
-FMTQUILL_CONSTEXPR auto write(OutputIt out, T value,
-                         const format_specs<Char>& specs = {}, locale_ref = {})
-    -> OutputIt {
-  return specs.type != presentation_type::none &&
-                 specs.type != presentation_type::string
-             ? write(out, value ? 1 : 0, specs, {})
-             : write_bytes(out, value ? "true" : "false", specs);
-}
-
-template <typename Char, typename OutputIt>
-FMTQUILL_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt {
-  auto it = reserve(out, 1);
-  *it++ = value;
-  return base_iterator(out, it);
-}
-
-template <typename Char, typename OutputIt>
-FMTQUILL_CONSTEXPR_CHAR_TRAITS auto write(OutputIt out, const Char* value)
-    -> OutputIt {
-  if (value) return write(out, basic_string_view<Char>(value));
-  throw_format_error("string pointer is null");
-  return out;
-}
-
-template <typename Char, typename OutputIt, typename T,
-          FMTQUILL_ENABLE_IF(std::is_same<T, void>::value)>
-auto write(OutputIt out, const T* value, const format_specs<Char>& specs = {},
-           locale_ref = {}) -> OutputIt {
-  return write_ptr<Char>(out, bit_cast<uintptr_t>(value), &specs);
-}
-
-// A write overload that handles implicit conversions.
-template <typename Char, typename OutputIt, typename T,
-          typename Context = basic_format_context<OutputIt, Char>>
-FMTQUILL_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t<
-    std::is_class<T>::value && !is_string<T>::value &&
-        !is_floating_point<T>::value && !std::is_same<T, Char>::value &&
-        !std::is_same<T, remove_cvref_t<decltype(arg_mapper<Context>().map(
-                             value))>>::value,
-    OutputIt> {
-  return write<Char>(out, arg_mapper<Context>().map(value));
-}
-
-template <typename Char, typename OutputIt, typename T,
-          typename Context = basic_format_context<OutputIt, Char>>
-FMTQUILL_CONSTEXPR auto write(OutputIt out, const T& value)
-    -> enable_if_t<mapped_type_constant<T, Context>::value == type::custom_type,
-                   OutputIt> {
-  auto formatter = typename Context::template formatter_type<T>();
-  auto parse_ctx = typename Context::parse_context_type({});
-  formatter.parse(parse_ctx);
-  auto ctx = Context(out, {}, {});
-  return formatter.format(value, ctx);
-}
-
-// An argument visitor that formats the argument and writes it via the output
-// iterator. It's a class and not a generic lambda for compatibility with C++11.
-template <typename Char> struct default_arg_formatter {
-  using iterator = buffer_appender<Char>;
-  using context = buffer_context<Char>;
-
-  iterator out;
-  basic_format_args<context> args;
-  locale_ref loc;
-
-  template <typename T> auto operator()(T value) -> iterator {
-    return write<Char>(out, value);
-  }
-  auto operator()(typename basic_format_arg<context>::handle h) -> iterator {
-    basic_format_parse_context<Char> parse_ctx({});
-    context format_ctx(out, args, loc);
-    h.format(parse_ctx, format_ctx);
-    return format_ctx.out();
-  }
-};
-
-template <typename Char> struct arg_formatter {
-  using iterator = buffer_appender<Char>;
-  using context = buffer_context<Char>;
-
-  iterator out;
-  const format_specs<Char>& specs;
-  locale_ref locale;
-
-  template <typename T>
-  FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto operator()(T value) -> iterator {
-    return detail::write(out, value, specs, locale);
-  }
-  auto operator()(typename basic_format_arg<context>::handle) -> iterator {
-    // User-defined types are handled separately because they require access
-    // to the parse context.
-    return out;
-  }
-};
-
-struct width_checker {
-  template <typename T, FMTQUILL_ENABLE_IF(is_integer<T>::value)>
-  FMTQUILL_CONSTEXPR auto operator()(T value) -> unsigned long long {
-    if (is_negative(value)) throw_format_error("negative width");
-    return static_cast<unsigned long long>(value);
-  }
-
-  template <typename T, FMTQUILL_ENABLE_IF(!is_integer<T>::value)>
-  FMTQUILL_CONSTEXPR auto operator()(T) -> unsigned long long {
-    throw_format_error("width is not integer");
-    return 0;
-  }
-};
-
-struct precision_checker {
-  template <typename T, FMTQUILL_ENABLE_IF(is_integer<T>::value)>
-  FMTQUILL_CONSTEXPR auto operator()(T value) -> unsigned long long {
-    if (is_negative(value)) throw_format_error("negative precision");
-    return static_cast<unsigned long long>(value);
-  }
-
-  template <typename T, FMTQUILL_ENABLE_IF(!is_integer<T>::value)>
-  FMTQUILL_CONSTEXPR auto operator()(T) -> unsigned long long {
-    throw_format_error("precision is not integer");
-    return 0;
-  }
-};
-
-template <typename Handler, typename FormatArg>
-FMTQUILL_CONSTEXPR auto get_dynamic_spec(FormatArg arg) -> int {
-  unsigned long long value = visit_format_arg(Handler(), arg);
-  if (value > to_unsigned(max_value<int>()))
-    throw_format_error("number is too big");
-  return static_cast<int>(value);
-}
-
-template <typename Context, typename ID>
-FMTQUILL_CONSTEXPR auto get_arg(Context& ctx, ID id) -> decltype(ctx.arg(id)) {
-  auto arg = ctx.arg(id);
-  if (!arg) ctx.on_error("argument not found");
-  return arg;
-}
-
-template <typename Handler, typename Context>
-FMTQUILL_CONSTEXPR void handle_dynamic_spec(int& value,
-                                       arg_ref<typename Context::char_type> ref,
-                                       Context& ctx) {
-  switch (ref.kind) {
-  case arg_id_kind::none:
-    break;
-  case arg_id_kind::index:
-    value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.index));
-    break;
-  case arg_id_kind::name:
-    value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.name));
-    break;
-  }
-}
-
-#if FMTQUILL_USE_USER_DEFINED_LITERALS
-#  if FMTQUILL_USE_NONTYPE_TEMPLATE_ARGS
-template <typename T, typename Char, size_t N,
-          fmtquill::detail_exported::fixed_string<Char, N> Str>
-struct statically_named_arg : view {
-  static constexpr auto name = Str.data;
-
-  const T& value;
-  statically_named_arg(const T& v) : value(v) {}
-};
-
-template <typename T, typename Char, size_t N,
-          fmtquill::detail_exported::fixed_string<Char, N> Str>
-struct is_named_arg<statically_named_arg<T, Char, N, Str>> : std::true_type {};
-
-template <typename T, typename Char, size_t N,
-          fmtquill::detail_exported::fixed_string<Char, N> Str>
-struct is_statically_named_arg<statically_named_arg<T, Char, N, Str>>
-    : std::true_type {};
-
-template <typename Char, size_t N,
-          fmtquill::detail_exported::fixed_string<Char, N> Str>
-struct udl_arg {
-  template <typename T> auto operator=(T&& value) const {
-    return statically_named_arg<T, Char, N, Str>(std::forward<T>(value));
-  }
-};
-#  else
-template <typename Char> struct udl_arg {
-  const Char* str;
-
-  template <typename T> auto operator=(T&& value) const -> named_arg<Char, T> {
-    return {str, std::forward<T>(value)};
-  }
-};
-#  endif
-#endif  // FMTQUILL_USE_USER_DEFINED_LITERALS
-
-template <typename Locale, typename Char>
-auto vformat(const Locale& loc, basic_string_view<Char> fmt,
-             basic_format_args<buffer_context<type_identity_t<Char>>> args)
-    -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
-  return {buf.data(), buf.size()};
-}
-
-using format_func = void (*)(detail::buffer<char>&, int, const char*);
-
-FMTQUILL_API void format_error_code(buffer<char>& out, int error_code,
-                               string_view message) noexcept;
-
-FMTQUILL_API void report_error(format_func func, int error_code,
-                          const char* message) noexcept;
-}  // namespace detail
-
-FMTQUILL_API auto vsystem_error(int error_code, string_view format_str,
-                           format_args args) -> std::system_error;
-
-/**
-  \rst
-  Constructs :class:`std::system_error` with a message formatted with
-  ``fmtquill::format(fmt, args...)``.
-  *error_code* is a system error code as given by ``errno``.
-
-  **Example**::
-
-    // This throws std::system_error with the description
-    //   cannot open file 'madeup': No such file or directory
-    // or similar (system message may vary).
-    const char* filename = "madeup";
-    std::FILE* file = std::fopen(filename, "r");
-    if (!file)
-      throw fmtquill::system_error(errno, "cannot open file '{}'", filename);
-  \endrst
- */
-template <typename... T>
-auto system_error(int error_code, format_string<T...> fmt, T&&... args)
-    -> std::system_error {
-  return vsystem_error(error_code, fmt, fmtquill::make_format_args(args...));
-}
-
-/**
-  \rst
-  Formats an error message for an error returned by an operating system or a
-  language runtime, for example a file opening error, and writes it to *out*.
-  The format is the same as the one used by ``std::system_error(ec, message)``
-  where ``ec`` is ``std::error_code(error_code, std::generic_category()})``.
-  It is implementation-defined but normally looks like:
-
-  .. parsed-literal::
-     *<message>*: *<system-message>*
-
-  where *<message>* is the passed message and *<system-message>* is the system
-  message corresponding to the error code.
-  *error_code* is a system error code as given by ``errno``.
-  \endrst
- */
-FMTQUILL_API void format_system_error(detail::buffer<char>& out, int error_code,
-                                 const char* message) noexcept;
-
-// Reports a system error without throwing an exception.
-// Can be used to report errors from destructors.
-FMTQUILL_API void report_system_error(int error_code, const char* message) noexcept;
-
-/** Fast integer formatter. */
-class format_int {
- private:
-  // Buffer should be large enough to hold all digits (digits10 + 1),
-  // a sign and a null character.
-  enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 };
-  mutable char buffer_[buffer_size];
-  char* str_;
-
-  template <typename UInt> auto format_unsigned(UInt value) -> char* {
-    auto n = static_cast<detail::uint32_or_64_or_128_t<UInt>>(value);
-    return detail::format_decimal(buffer_, n, buffer_size - 1).begin;
-  }
-
-  template <typename Int> auto format_signed(Int value) -> char* {
-    auto abs_value = static_cast<detail::uint32_or_64_or_128_t<Int>>(value);
-    bool negative = value < 0;
-    if (negative) abs_value = 0 - abs_value;
-    auto begin = format_unsigned(abs_value);
-    if (negative) *--begin = '-';
-    return begin;
-  }
-
- public:
-  explicit format_int(int value) : str_(format_signed(value)) {}
-  explicit format_int(long value) : str_(format_signed(value)) {}
-  explicit format_int(long long value) : str_(format_signed(value)) {}
-  explicit format_int(unsigned value) : str_(format_unsigned(value)) {}
-  explicit format_int(unsigned long value) : str_(format_unsigned(value)) {}
-  explicit format_int(unsigned long long value)
-      : str_(format_unsigned(value)) {}
-
-  /** Returns the number of characters written to the output buffer. */
-  auto size() const -> size_t {
-    return detail::to_unsigned(buffer_ - str_ + buffer_size - 1);
-  }
-
-  /**
-    Returns a pointer to the output buffer content. No terminating null
-    character is appended.
-   */
-  auto data() const -> const char* { return str_; }
-
-  /**
-    Returns a pointer to the output buffer content with terminating null
-    character appended.
-   */
-  auto c_str() const -> const char* {
-    buffer_[buffer_size - 1] = '\0';
-    return str_;
-  }
-
-  /**
-    \rst
-    Returns the content of the output buffer as an ``std::string``.
-    \endrst
-   */
-  auto str() const -> std::string { return std::string(str_, size()); }
-};
-
-template <typename T, typename Char>
-struct formatter<T, Char, enable_if_t<detail::has_format_as<T>::value>>
-    : formatter<detail::format_as_t<T>, Char> {
-  template <typename FormatContext>
-  auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) {
-    using base = formatter<detail::format_as_t<T>, Char>;
-    return base::format(format_as(value), ctx);
-  }
-};
-
-#define FMTQUILL_FORMAT_AS(Type, Base) \
-  template <typename Char>        \
-  struct formatter<Type, Char> : formatter<Base, Char> {}
-
-FMTQUILL_FORMAT_AS(signed char, int);
-FMTQUILL_FORMAT_AS(unsigned char, unsigned);
-FMTQUILL_FORMAT_AS(short, int);
-FMTQUILL_FORMAT_AS(unsigned short, unsigned);
-FMTQUILL_FORMAT_AS(long, detail::long_type);
-FMTQUILL_FORMAT_AS(unsigned long, detail::ulong_type);
-FMTQUILL_FORMAT_AS(Char*, const Char*);
-FMTQUILL_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
-FMTQUILL_FORMAT_AS(std::nullptr_t, const void*);
-FMTQUILL_FORMAT_AS(detail::std_string_view<Char>, basic_string_view<Char>);
-FMTQUILL_FORMAT_AS(void*, const void*);
-
-template <typename Char, size_t N>
-struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {};
-
-/**
-  \rst
-  Converts ``p`` to ``const void*`` for pointer formatting.
-
-  **Example**::
-
-    auto s = fmtquill::format("{}", fmtquill::ptr(p));
-  \endrst
- */
-template <typename T> auto ptr(T p) -> const void* {
-  static_assert(std::is_pointer<T>::value, "");
-  return detail::bit_cast<const void*>(p);
-}
-template <typename T, typename Deleter>
-auto ptr(const std::unique_ptr<T, Deleter>& p) -> const void* {
-  return p.get();
-}
-template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* {
-  return p.get();
-}
-
-/**
-  \rst
-  Converts ``e`` to the underlying type.
-
-  **Example**::
-
-    enum class color { red, green, blue };
-    auto s = fmtquill::format("{}", fmtquill::underlying(color::red));
-  \endrst
- */
-template <typename Enum>
-constexpr auto underlying(Enum e) noexcept -> underlying_t<Enum> {
-  return static_cast<underlying_t<Enum>>(e);
-}
-
-namespace enums {
-template <typename Enum, FMTQUILL_ENABLE_IF(std::is_enum<Enum>::value)>
-constexpr auto format_as(Enum e) noexcept -> underlying_t<Enum> {
-  return static_cast<underlying_t<Enum>>(e);
-}
-}  // namespace enums
-
-class bytes {
- private:
-  string_view data_;
-  friend struct formatter<bytes>;
-
- public:
-  explicit bytes(string_view data) : data_(data) {}
-};
-
-template <> struct formatter<bytes> {
- private:
-  detail::dynamic_format_specs<> specs_;
-
- public:
-  template <typename ParseContext>
-  FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) -> const char* {
-    return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
-                              detail::type::string_type);
-  }
-
-  template <typename FormatContext>
-  auto format(bytes b, FormatContext& ctx) -> decltype(ctx.out()) {
-    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
-                                                       specs_.width_ref, ctx);
-    detail::handle_dynamic_spec<detail::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx);
-    return detail::write_bytes(ctx.out(), b.data_, specs_);
-  }
-};
-
-// group_digits_view is not derived from view because it copies the argument.
-template <typename T> struct group_digits_view {
-  T value;
-};
-
-/**
-  \rst
-  Returns a view that formats an integer value using ',' as a locale-independent
-  thousands separator.
-
-  **Example**::
-
-    fmtquill::print("{}", fmtquill::group_digits(12345));
-    // Output: "12,345"
-  \endrst
- */
-template <typename T> auto group_digits(T value) -> group_digits_view<T> {
-  return {value};
-}
-
-template <typename T> struct formatter<group_digits_view<T>> : formatter<T> {
- private:
-  detail::dynamic_format_specs<> specs_;
-
- public:
-  template <typename ParseContext>
-  FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) -> const char* {
-    return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
-                              detail::type::int_type);
-  }
-
-  template <typename FormatContext>
-  auto format(group_digits_view<T> t, FormatContext& ctx)
-      -> decltype(ctx.out()) {
-    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
-                                                       specs_.width_ref, ctx);
-    detail::handle_dynamic_spec<detail::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx);
-    return detail::write_int(
-        ctx.out(), static_cast<detail::uint64_or_128_t<T>>(t.value), 0, specs_,
-        detail::digit_grouping<char>("\3", ","));
-  }
-};
-
-template <typename T> struct nested_view {
-  const formatter<T>* fmt;
-  const T* value;
-};
-
-template <typename T> struct formatter<nested_view<T>> {
-  FMTQUILL_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* {
-    return ctx.begin();
-  }
-  auto format(nested_view<T> view, format_context& ctx) const
-      -> decltype(ctx.out()) {
-    return view.fmt->format(*view.value, ctx);
-  }
-};
-
-template <typename T> struct nested_formatter {
- private:
-  int width_;
-  detail::fill_t<char> fill_;
-  align_t align_ : 4;
-  formatter<T> formatter_;
-
- public:
-  constexpr nested_formatter() : width_(0), align_(align_t::none) {}
-
-  FMTQUILL_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* {
-    auto specs = detail::dynamic_format_specs<char>();
-    auto it = parse_format_specs(ctx.begin(), ctx.end(), specs, ctx,
-                                 detail::type::none_type);
-    width_ = specs.width;
-    fill_ = specs.fill;
-    align_ = specs.align;
-    ctx.advance_to(it);
-    return formatter_.parse(ctx);
-  }
-
-  template <typename F>
-  auto write_padded(format_context& ctx, F write) const -> decltype(ctx.out()) {
-    if (width_ == 0) return write(ctx.out());
-    auto buf = memory_buffer();
-    write(std::back_inserter(buf));
-    auto specs = format_specs<>();
-    specs.width = width_;
-    specs.fill = fill_;
-    specs.align = align_;
-    return detail::write(ctx.out(), string_view(buf.data(), buf.size()), specs);
-  }
-
-  auto nested(const T& value) const -> nested_view<T> {
-    return nested_view<T>{&formatter_, &value};
-  }
-};
-
-// DEPRECATED! join_view will be moved to ranges.h.
-template <typename It, typename Sentinel, typename Char = char>
-struct join_view : detail::view {
-  It begin;
-  Sentinel end;
-  basic_string_view<Char> sep;
-
-  join_view(It b, Sentinel e, basic_string_view<Char> s)
-      : begin(b), end(e), sep(s) {}
-};
-
-template <typename It, typename Sentinel, typename Char>
-struct formatter<join_view<It, Sentinel, Char>, Char> {
- private:
-  using value_type =
-#ifdef __cpp_lib_ranges
-      std::iter_value_t<It>;
-#else
-      typename std::iterator_traits<It>::value_type;
-#endif
-  formatter<remove_cvref_t<value_type>, Char> value_formatter_;
-
- public:
-  template <typename ParseContext>
-  FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* {
-    return value_formatter_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(const join_view<It, Sentinel, Char>& value,
-              FormatContext& ctx) const -> decltype(ctx.out()) {
-    auto it = value.begin;
-    auto out = ctx.out();
-    if (it != value.end) {
-      out = value_formatter_.format(*it, ctx);
-      ++it;
-      while (it != value.end) {
-        out = detail::copy_str<Char>(value.sep.begin(), value.sep.end(), out);
-        ctx.advance_to(out);
-        out = value_formatter_.format(*it, ctx);
-        ++it;
-      }
-    }
-    return out;
-  }
-};
-
-/**
-  Returns a view that formats the iterator range `[begin, end)` with elements
-  separated by `sep`.
- */
-template <typename It, typename Sentinel>
-auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> {
-  return {begin, end, sep};
-}
-
-/**
-  \rst
-  Returns a view that formats `range` with elements separated by `sep`.
-
-  **Example**::
-
-    std::vector<int> v = {1, 2, 3};
-    fmtquill::print("{}", fmtquill::join(v, ", "));
-    // Output: "1, 2, 3"
-
-  ``fmtquill::join`` applies passed format specifiers to the range elements::
-
-    fmtquill::print("{:02}", fmtquill::join(v, ", "));
-    // Output: "01, 02, 03"
-  \endrst
- */
-template <typename Range>
-auto join(Range&& range, string_view sep)
-    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>> {
-  return join(std::begin(range), std::end(range), sep);
-}
-
-/**
-  \rst
-  Converts *value* to ``std::string`` using the default format for type *T*.
-
-  **Example**::
-
-    #include <fmt/format.h>
-
-    std::string answer = fmtquill::to_string(42);
-  \endrst
- */
-template <typename T, FMTQUILL_ENABLE_IF(!std::is_integral<T>::value &&
-                                    !detail::has_format_as<T>::value)>
-inline auto to_string(const T& value) -> std::string {
-  auto buffer = memory_buffer();
-  detail::write<char>(appender(buffer), value);
-  return {buffer.data(), buffer.size()};
-}
-
-template <typename T, FMTQUILL_ENABLE_IF(std::is_integral<T>::value)>
-FMTQUILL_NODISCARD inline auto to_string(T value) -> std::string {
-  // The buffer should be large enough to store the number including the sign
-  // or "false" for bool.
-  constexpr int max_size = detail::digits10<T>() + 2;
-  char buffer[max_size > 5 ? static_cast<unsigned>(max_size) : 5];
-  char* begin = buffer;
-  return std::string(begin, detail::write<char>(begin, value));
-}
-
-template <typename Char, size_t SIZE>
-FMTQUILL_NODISCARD auto to_string(const basic_memory_buffer<Char, SIZE>& buf)
-    -> std::basic_string<Char> {
-  auto size = buf.size();
-  detail::assume(size < std::basic_string<Char>().max_size());
-  return std::basic_string<Char>(buf.data(), size);
-}
-
-template <typename T, FMTQUILL_ENABLE_IF(!std::is_integral<T>::value &&
-                                    detail::has_format_as<T>::value)>
-inline auto to_string(const T& value) -> std::string {
-  return to_string(format_as(value));
-}
-
-FMTQUILL_END_EXPORT
-
-namespace detail {
-
-template <typename Char>
-void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
-                typename vformat_args<Char>::type args, locale_ref loc) {
-  auto out = buffer_appender<Char>(buf);
-  if (fmt.size() == 2 && equal2(fmt.data(), "{}")) {
-    auto arg = args.get(0);
-    if (!arg) throw_format_error("argument not found");
-    visit_format_arg(default_arg_formatter<Char>{out, args, loc}, arg);
-    return;
-  }
-
-  struct format_handler : error_handler {
-    basic_format_parse_context<Char> parse_context;
-    buffer_context<Char> context;
-
-    format_handler(buffer_appender<Char> p_out, basic_string_view<Char> str,
-                   basic_format_args<buffer_context<Char>> p_args,
-                   locale_ref p_loc)
-        : parse_context(str), context(p_out, p_args, p_loc) {}
-
-    void on_text(const Char* begin, const Char* end) {
-      auto text = basic_string_view<Char>(begin, to_unsigned(end - begin));
-      context.advance_to(write<Char>(context.out(), text));
-    }
-
-    FMTQUILL_CONSTEXPR auto on_arg_id() -> int {
-      return parse_context.next_arg_id();
-    }
-    FMTQUILL_CONSTEXPR auto on_arg_id(int id) -> int {
-      return parse_context.check_arg_id(id), id;
-    }
-    FMTQUILL_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
-      int arg_id = context.arg_id(id);
-      if (arg_id < 0) throw_format_error("argument not found");
-      return arg_id;
-    }
-
-    FMTQUILL_INLINE void on_replacement_field(int id, const Char*) {
-      auto arg = get_arg(context, id);
-      context.advance_to(visit_format_arg(
-          default_arg_formatter<Char>{context.out(), context.args(),
-                                      context.locale()},
-          arg));
-    }
-
-    auto on_format_specs(int id, const Char* begin, const Char* end)
-        -> const Char* {
-      auto arg = get_arg(context, id);
-      // Not using a visitor for custom types gives better codegen.
-      if (arg.format_custom(begin, parse_context, context))
-        return parse_context.begin();
-      auto specs = detail::dynamic_format_specs<Char>();
-      begin = parse_format_specs(begin, end, specs, parse_context, arg.type());
-      detail::handle_dynamic_spec<detail::width_checker>(
-          specs.width, specs.width_ref, context);
-      detail::handle_dynamic_spec<detail::precision_checker>(
-          specs.precision, specs.precision_ref, context);
-      if (begin == end || *begin != '}')
-        throw_format_error("missing '}' in format string");
-      auto f = arg_formatter<Char>{context.out(), specs, context.locale()};
-      context.advance_to(visit_format_arg(f, arg));
-      return begin;
-    }
-  };
-  detail::parse_format_string<false>(fmt, format_handler(out, fmt, args, loc));
-}
-
-FMTQUILL_BEGIN_EXPORT
-
-#ifndef FMTQUILL_HEADER_ONLY
-extern template FMTQUILL_API void vformat_to(buffer<char>&, string_view,
-                                        typename vformat_args<>::type,
-                                        locale_ref);
-extern template FMTQUILL_API auto thousands_sep_impl<char>(locale_ref)
-    -> thousands_sep_result<char>;
-extern template FMTQUILL_API auto thousands_sep_impl<wchar_t>(locale_ref)
-    -> thousands_sep_result<wchar_t>;
-extern template FMTQUILL_API auto decimal_point_impl(locale_ref) -> char;
-extern template FMTQUILL_API auto decimal_point_impl(locale_ref) -> wchar_t;
-#endif  // FMTQUILL_HEADER_ONLY
-
-}  // namespace detail
-
-#if FMTQUILL_USE_USER_DEFINED_LITERALS
-inline namespace literals {
-/**
-  \rst
-  User-defined literal equivalent of :func:`fmtquill::arg`.
-
-  **Example**::
-
-    using namespace fmtquill::literals;
-    fmtquill::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
-  \endrst
- */
-#  if FMTQUILL_USE_NONTYPE_TEMPLATE_ARGS
-template <detail_exported::fixed_string Str> constexpr auto operator""_a() {
-  using char_t = remove_cvref_t<decltype(Str.data[0])>;
-  return detail::udl_arg<char_t, sizeof(Str.data) / sizeof(char_t), Str>();
-}
-#  else
-constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg<char> {
-  return {s};
-}
-#  endif
-}  // namespace literals
-#endif  // FMTQUILL_USE_USER_DEFINED_LITERALS
-
-template <typename Locale, FMTQUILL_ENABLE_IF(detail::is_locale<Locale>::value)>
-inline auto vformat(const Locale& loc, string_view fmt, format_args args)
-    -> std::string {
-  return detail::vformat(loc, fmt, args);
-}
-
-template <typename Locale, typename... T,
-          FMTQUILL_ENABLE_IF(detail::is_locale<Locale>::value)>
-inline auto format(const Locale& loc, format_string<T...> fmt, T&&... args)
-    -> std::string {
-  return fmtquill::vformat(loc, string_view(fmt), fmtquill::make_format_args(args...));
-}
-
-template <typename OutputIt, typename Locale,
-          FMTQUILL_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value&&
-                            detail::is_locale<Locale>::value)>
-auto vformat_to(OutputIt out, const Locale& loc, string_view fmt,
-                format_args args) -> OutputIt {
-  using detail::get_buffer;
-  auto&& buf = get_buffer<char>(out);
-  detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
-  return detail::get_iterator(buf, out);
-}
-
-template <typename OutputIt, typename Locale, typename... T,
-          FMTQUILL_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value&&
-                            detail::is_locale<Locale>::value)>
-FMTQUILL_INLINE auto format_to(OutputIt out, const Locale& loc,
-                          format_string<T...> fmt, T&&... args) -> OutputIt {
-  return vformat_to(out, loc, fmt, fmtquill::make_format_args(args...));
-}
-
-template <typename Locale, typename... T,
-          FMTQUILL_ENABLE_IF(detail::is_locale<Locale>::value)>
-FMTQUILL_NODISCARD FMTQUILL_INLINE auto formatted_size(const Locale& loc,
-                                             format_string<T...> fmt,
-                                             T&&... args) -> size_t {
-  auto buf = detail::counting_buffer<>();
-  detail::vformat_to<char>(buf, fmt, fmtquill::make_format_args(args...),
-                           detail::locale_ref(loc));
-  return buf.count();
-}
-
-FMTQUILL_END_EXPORT
-
-template <typename T, typename Char>
-template <typename FormatContext>
-FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto
-formatter<T, Char,
-          enable_if_t<detail::type_constant<T, Char>::value !=
-                      detail::type::custom_type>>::format(const T& val,
-                                                          FormatContext& ctx)
-    const -> decltype(ctx.out()) {
-  if (specs_.width_ref.kind == detail::arg_id_kind::none &&
-      specs_.precision_ref.kind == detail::arg_id_kind::none) {
-    return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
-  }
-  auto specs = specs_;
-  detail::handle_dynamic_spec<detail::width_checker>(specs.width,
-                                                     specs.width_ref, ctx);
-  detail::handle_dynamic_spec<detail::precision_checker>(
-      specs.precision, specs.precision_ref, ctx);
-  return detail::write<Char>(ctx.out(), val, specs, ctx.locale());
-}
-
-FMTQUILL_END_NAMESPACE
-
-#ifdef FMTQUILL_HEADER_ONLY
-#  define FMTQUILL_FUNC inline
-#  include "format-inl.h"
-#else
-#  define FMTQUILL_FUNC
-#endif
-
-#endif  // FMTQUILL_FORMAT_H_
diff --git a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/os.h b/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/os.h
deleted file mode 100644
index 67b7d48..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/os.h
+++ /dev/null
@@ -1,455 +0,0 @@
-// Formatting library for C++ - optional OS-specific functionality
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMTQUILL_OS_H_
-#define FMTQUILL_OS_H_
-
-#include <cerrno>
-#include <cstddef>
-#include <cstdio>
-#include <system_error>  // std::system_error
-
-#include "format.h"
-
-#if defined __APPLE__ || defined(__FreeBSD__)
-#  if FMTQUILL_HAS_INCLUDE(<xlocale.h>)
-#    include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
-#  endif
-#endif
-
-#ifndef FMTQUILL_USE_FCNTL
-// UWP doesn't provide _pipe.
-#  if FMTQUILL_HAS_INCLUDE("winapifamily.h")
-#    include <winapifamily.h>
-#  endif
-#  if (FMTQUILL_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || \
-       defined(__linux__)) &&                              \
-      (!defined(WINAPI_FAMILY) ||                          \
-       (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
-#    include <fcntl.h>  // for O_RDONLY
-#    define FMTQUILL_USE_FCNTL 1
-#  else
-#    define FMTQUILL_USE_FCNTL 0
-#  endif
-#endif
-
-#ifndef FMTQUILL_POSIX
-#  if defined(_WIN32) && !defined(__MINGW32__)
-// Fix warnings about deprecated symbols.
-#    define FMTQUILL_POSIX(call) _##call
-#  else
-#    define FMTQUILL_POSIX(call) call
-#  endif
-#endif
-
-// Calls to system functions are wrapped in FMTQUILL_SYSTEM for testability.
-#ifdef FMTQUILL_SYSTEM
-#  define FMTQUILL_HAS_SYSTEM
-#  define FMTQUILL_POSIX_CALL(call) FMTQUILL_SYSTEM(call)
-#else
-#  define FMTQUILL_SYSTEM(call) ::call
-#  ifdef _WIN32
-// Fix warnings about deprecated symbols.
-#    define FMTQUILL_POSIX_CALL(call) ::_##call
-#  else
-#    define FMTQUILL_POSIX_CALL(call) ::call
-#  endif
-#endif
-
-// Retries the expression while it evaluates to error_result and errno
-// equals to EINTR.
-#ifndef _WIN32
-#  define FMTQUILL_RETRY_VAL(result, expression, error_result) \
-    do {                                                  \
-      (result) = (expression);                            \
-    } while ((result) == (error_result) && errno == EINTR)
-#else
-#  define FMTQUILL_RETRY_VAL(result, expression, error_result) result = (expression)
-#endif
-
-#define FMTQUILL_RETRY(result, expression) FMTQUILL_RETRY_VAL(result, expression, -1)
-
-FMTQUILL_BEGIN_NAMESPACE
-FMTQUILL_BEGIN_EXPORT
-
-/**
-  \rst
-  A reference to a null-terminated string. It can be constructed from a C
-  string or ``std::string``.
-
-  You can use one of the following type aliases for common character types:
-
-  +---------------+-----------------------------+
-  | Type          | Definition                  |
-  +===============+=============================+
-  | cstring_view  | basic_cstring_view<char>    |
-  +---------------+-----------------------------+
-  | wcstring_view | basic_cstring_view<wchar_t> |
-  +---------------+-----------------------------+
-
-  This class is most useful as a parameter type to allow passing
-  different types of strings to a function, for example::
-
-    template <typename... Args>
-    std::string format(cstring_view format_str, const Args & ... args);
-
-    format("{}", 42);
-    format(std::string("{}"), 42);
-  \endrst
- */
-template <typename Char> class basic_cstring_view {
- private:
-  const Char* data_;
-
- public:
-  /** Constructs a string reference object from a C string. */
-  basic_cstring_view(const Char* s) : data_(s) {}
-
-  /**
-    \rst
-    Constructs a string reference from an ``std::string`` object.
-    \endrst
-   */
-  basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}
-
-  /** Returns the pointer to a C string. */
-  auto c_str() const -> const Char* { return data_; }
-};
-
-using cstring_view = basic_cstring_view<char>;
-using wcstring_view = basic_cstring_view<wchar_t>;
-
-#ifdef _WIN32
-FMTQUILL_API const std::error_category& system_category() noexcept;
-
-namespace detail {
-FMTQUILL_API void format_windows_error(buffer<char>& out, int error_code,
-                                  const char* message) noexcept;
-}
-
-FMTQUILL_API std::system_error vwindows_error(int error_code, string_view format_str,
-                                         format_args args);
-
-/**
- \rst
- Constructs a :class:`std::system_error` object with the description
- of the form
-
- .. parsed-literal::
-   *<message>*: *<system-message>*
-
- where *<message>* is the formatted message and *<system-message>* is the
- system message corresponding to the error code.
- *error_code* is a Windows error code as given by ``GetLastError``.
- If *error_code* is not a valid error code such as -1, the system message
- will look like "error -1".
-
- **Example**::
-
-   // This throws a system_error with the description
-   //   cannot open file 'madeup': The system cannot find the file specified.
-   // or similar (system message may vary).
-   const char *filename = "madeup";
-   LPOFSTRUCT of = LPOFSTRUCT();
-   HFILE file = OpenFile(filename, &of, OF_READ);
-   if (file == HFILE_ERROR) {
-     throw fmtquill::windows_error(GetLastError(),
-                              "cannot open file '{}'", filename);
-   }
- \endrst
-*/
-template <typename... Args>
-std::system_error windows_error(int error_code, string_view message,
-                                const Args&... args) {
-  return vwindows_error(error_code, message, fmtquill::make_format_args(args...));
-}
-
-// Reports a Windows error without throwing an exception.
-// Can be used to report errors from destructors.
-FMTQUILL_API void report_windows_error(int error_code, const char* message) noexcept;
-#else
-inline auto system_category() noexcept -> const std::error_category& {
-  return std::system_category();
-}
-#endif  // _WIN32
-
-// std::system is not available on some platforms such as iOS (#2248).
-#ifdef __OSX__
-template <typename S, typename... Args, typename Char = char_t<S>>
-void say(const S& format_str, Args&&... args) {
-  std::system(format("say \"{}\"", format(format_str, args...)).c_str());
-}
-#endif
-
-// A buffered file.
-class buffered_file {
- private:
-  FILE* file_;
-
-  friend class file;
-
-  explicit buffered_file(FILE* f) : file_(f) {}
-
- public:
-  buffered_file(const buffered_file&) = delete;
-  void operator=(const buffered_file&) = delete;
-
-  // Constructs a buffered_file object which doesn't represent any file.
-  buffered_file() noexcept : file_(nullptr) {}
-
-  // Destroys the object closing the file it represents if any.
-  FMTQUILL_API ~buffered_file() noexcept;
-
- public:
-  buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
-    other.file_ = nullptr;
-  }
-
-  auto operator=(buffered_file&& other) -> buffered_file& {
-    close();
-    file_ = other.file_;
-    other.file_ = nullptr;
-    return *this;
-  }
-
-  // Opens a file.
-  FMTQUILL_API buffered_file(cstring_view filename, cstring_view mode);
-
-  // Closes the file.
-  FMTQUILL_API void close();
-
-  // Returns the pointer to a FILE object representing this file.
-  auto get() const noexcept -> FILE* { return file_; }
-
-  FMTQUILL_API auto descriptor() const -> int;
-
-  void vprint(string_view format_str, format_args args) {
-    fmtquill::vprint(file_, format_str, args);
-  }
-
-  template <typename... Args>
-  inline void print(string_view format_str, const Args&... args) {
-    vprint(format_str, fmtquill::make_format_args(args...));
-  }
-};
-
-#if FMTQUILL_USE_FCNTL
-// A file. Closed file is represented by a file object with descriptor -1.
-// Methods that are not declared with noexcept may throw
-// fmtquill::system_error in case of failure. Note that some errors such as
-// closing the file multiple times will cause a crash on Windows rather
-// than an exception. You can get standard behavior by overriding the
-// invalid parameter handler with _set_invalid_parameter_handler.
-class FMTQUILL_API file {
- private:
-  int fd_;  // File descriptor.
-
-  // Constructs a file object with a given descriptor.
-  explicit file(int fd) : fd_(fd) {}
-
- public:
-  // Possible values for the oflag argument to the constructor.
-  enum {
-    RDONLY = FMTQUILL_POSIX(O_RDONLY),  // Open for reading only.
-    WRONLY = FMTQUILL_POSIX(O_WRONLY),  // Open for writing only.
-    RDWR = FMTQUILL_POSIX(O_RDWR),      // Open for reading and writing.
-    CREATE = FMTQUILL_POSIX(O_CREAT),   // Create if the file doesn't exist.
-    APPEND = FMTQUILL_POSIX(O_APPEND),  // Open in append mode.
-    TRUNC = FMTQUILL_POSIX(O_TRUNC)     // Truncate the content of the file.
-  };
-
-  // Constructs a file object which doesn't represent any file.
-  file() noexcept : fd_(-1) {}
-
-  // Opens a file and constructs a file object representing this file.
-  file(cstring_view path, int oflag);
-
- public:
-  file(const file&) = delete;
-  void operator=(const file&) = delete;
-
-  file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
-
-  // Move assignment is not noexcept because close may throw.
-  auto operator=(file&& other) -> file& {
-    close();
-    fd_ = other.fd_;
-    other.fd_ = -1;
-    return *this;
-  }
-
-  // Destroys the object closing the file it represents if any.
-  ~file() noexcept;
-
-  // Returns the file descriptor.
-  auto descriptor() const noexcept -> int { return fd_; }
-
-  // Closes the file.
-  void close();
-
-  // Returns the file size. The size has signed type for consistency with
-  // stat::st_size.
-  auto size() const -> long long;
-
-  // Attempts to read count bytes from the file into the specified buffer.
-  auto read(void* buffer, size_t count) -> size_t;
-
-  // Attempts to write count bytes from the specified buffer to the file.
-  auto write(const void* buffer, size_t count) -> size_t;
-
-  // Duplicates a file descriptor with the dup function and returns
-  // the duplicate as a file object.
-  static auto dup(int fd) -> file;
-
-  // Makes fd be the copy of this file descriptor, closing fd first if
-  // necessary.
-  void dup2(int fd);
-
-  // Makes fd be the copy of this file descriptor, closing fd first if
-  // necessary.
-  void dup2(int fd, std::error_code& ec) noexcept;
-
-  // Creates a pipe setting up read_end and write_end file objects for reading
-  // and writing respectively.
-  // DEPRECATED! Taking files as out parameters is deprecated.
-  static void pipe(file& read_end, file& write_end);
-
-  // Creates a buffered_file object associated with this file and detaches
-  // this file object from the file.
-  auto fdopen(const char* mode) -> buffered_file;
-
-#  if defined(_WIN32) && !defined(__MINGW32__)
-  // Opens a file and constructs a file object representing this file by
-  // wcstring_view filename. Windows only.
-  static file open_windows_file(wcstring_view path, int oflag);
-#  endif
-};
-
-// Returns the memory page size.
-auto getpagesize() -> long;
-
-namespace detail {
-
-struct buffer_size {
-  buffer_size() = default;
-  size_t value = 0;
-  auto operator=(size_t val) const -> buffer_size {
-    auto bs = buffer_size();
-    bs.value = val;
-    return bs;
-  }
-};
-
-struct ostream_params {
-  int oflag = file::WRONLY | file::CREATE | file::TRUNC;
-  size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;
-
-  ostream_params() {}
-
-  template <typename... T>
-  ostream_params(T... params, int new_oflag) : ostream_params(params...) {
-    oflag = new_oflag;
-  }
-
-  template <typename... T>
-  ostream_params(T... params, detail::buffer_size bs)
-      : ostream_params(params...) {
-    this->buffer_size = bs.value;
-  }
-
-// Intel has a bug that results in failure to deduce a constructor
-// for empty parameter packs.
-#  if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000
-  ostream_params(int new_oflag) : oflag(new_oflag) {}
-  ostream_params(detail::buffer_size bs) : buffer_size(bs.value) {}
-#  endif
-};
-
-class file_buffer final : public buffer<char> {
-  file file_;
-
-  FMTQUILL_API void grow(size_t) override;
-
- public:
-  FMTQUILL_API file_buffer(cstring_view path, const ostream_params& params);
-  FMTQUILL_API file_buffer(file_buffer&& other);
-  FMTQUILL_API ~file_buffer();
-
-  void flush() {
-    if (size() == 0) return;
-    file_.write(data(), size() * sizeof(data()[0]));
-    clear();
-  }
-
-  void close() {
-    flush();
-    file_.close();
-  }
-};
-
-}  // namespace detail
-
-// Added {} below to work around default constructor error known to
-// occur in Xcode versions 7.2.1 and 8.2.1.
-constexpr detail::buffer_size buffer_size{};
-
-/** A fast output stream which is not thread-safe. */
-class FMTQUILL_API ostream {
- private:
-  FMTQUILL_MSC_WARNING(suppress : 4251)
-  detail::file_buffer buffer_;
-
-  ostream(cstring_view path, const detail::ostream_params& params)
-      : buffer_(path, params) {}
-
- public:
-  ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {}
-
-  ~ostream();
-
-  void flush() { buffer_.flush(); }
-
-  template <typename... T>
-  friend auto output_file(cstring_view path, T... params) -> ostream;
-
-  void close() { buffer_.close(); }
-
-  /**
-    Formats ``args`` according to specifications in ``fmt`` and writes the
-    output to the file.
-   */
-  template <typename... T> void print(format_string<T...> fmt, T&&... args) {
-    vformat_to(std::back_inserter(buffer_), fmt,
-               fmtquill::make_format_args(args...));
-  }
-};
-
-/**
-  \rst
-  Opens a file for writing. Supported parameters passed in *params*:
-
-  * ``<integer>``: Flags passed to `open
-    <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_
-    (``file::WRONLY | file::CREATE | file::TRUNC`` by default)
-  * ``buffer_size=<integer>``: Output buffer size
-
-  **Example**::
-
-    auto out = fmtquill::output_file("guide.txt");
-    out.print("Don't {}", "Panic");
-  \endrst
- */
-template <typename... T>
-inline auto output_file(cstring_view path, T... params) -> ostream {
-  return {path, detail::ostream_params(params...)};
-}
-#endif  // FMTQUILL_USE_FCNTL
-
-FMTQUILL_END_EXPORT
-FMTQUILL_END_NAMESPACE
-
-#endif  // FMTQUILL_OS_H_
diff --git a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/ostream.h b/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/ostream.h
deleted file mode 100644
index d65cd3f..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/ostream.h
+++ /dev/null
@@ -1,245 +0,0 @@
-// Formatting library for C++ - std::ostream support
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMTQUILL_OSTREAM_H_
-#define FMTQUILL_OSTREAM_H_
-
-#include <fstream>  // std::filebuf
-
-#ifdef _WIN32
-#  ifdef __GLIBCXX__
-#    include <ext/stdio_filebuf.h>
-#    include <ext/stdio_sync_filebuf.h>
-#  endif
-#  include <io.h>
-#endif
-
-#include "format.h"
-
-FMTQUILL_BEGIN_NAMESPACE
-namespace detail {
-
-template <typename Streambuf> class formatbuf : public Streambuf {
- private:
-  using char_type = typename Streambuf::char_type;
-  using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
-  using int_type = typename Streambuf::int_type;
-  using traits_type = typename Streambuf::traits_type;
-
-  buffer<char_type>& buffer_;
-
- public:
-  explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}
-
- protected:
-  // The put area is always empty. This makes the implementation simpler and has
-  // the advantage that the streambuf and the buffer are always in sync and
-  // sputc never writes into uninitialized memory. A disadvantage is that each
-  // call to sputc always results in a (virtual) call to overflow. There is no
-  // disadvantage here for sputn since this always results in a call to xsputn.
-
-  auto overflow(int_type ch) -> int_type override {
-    if (!traits_type::eq_int_type(ch, traits_type::eof()))
-      buffer_.push_back(static_cast<char_type>(ch));
-    return ch;
-  }
-
-  auto xsputn(const char_type* s, streamsize count) -> streamsize override {
-    buffer_.append(s, s + count);
-    return count;
-  }
-};
-
-// Generate a unique explicit instantion in every translation unit using a tag
-// type in an anonymous namespace.
-namespace {
-struct file_access_tag {};
-}  // namespace
-template <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr>
-class file_access {
-  friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
-};
-
-#if FMTQUILL_MSC_VERSION
-template class file_access<file_access_tag, std::filebuf,
-                           &std::filebuf::_Myfile>;
-auto get_file(std::filebuf&) -> FILE*;
-#endif
-
-inline auto write_ostream_unicode(std::ostream& os, fmtquill::string_view data)
-    -> bool {
-  FILE* f = nullptr;
-#if FMTQUILL_MSC_VERSION
-  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
-    f = get_file(*buf);
-  else
-    return false;
-#elif defined(_WIN32) && defined(__GLIBCXX__)
-  auto* rdbuf = os.rdbuf();
-  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
-    f = sfbuf->file();
-  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
-    f = fbuf->file();
-  else
-    return false;
-#else
-  ignore_unused(os, data, f);
-#endif
-#ifdef _WIN32
-  if (f) {
-    int fd = _fileno(f);
-    if (_isatty(fd)) {
-      os.flush();
-      return write_console(fd, data);
-    }
-  }
-#endif
-  return false;
-}
-inline auto write_ostream_unicode(std::wostream&,
-                                  fmtquill::basic_string_view<wchar_t>) -> bool {
-  return false;
-}
-
-// Write the content of buf to os.
-// It is a separate function rather than a part of vprint to simplify testing.
-template <typename Char>
-void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
-  const Char* buf_data = buf.data();
-  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
-  unsigned_streamsize size = buf.size();
-  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
-  do {
-    unsigned_streamsize n = size <= max_size ? size : max_size;
-    os.write(buf_data, static_cast<std::streamsize>(n));
-    buf_data += n;
-    size -= n;
-  } while (size != 0);
-}
-
-template <typename Char, typename T>
-void format_value(buffer<Char>& buf, const T& value) {
-  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
-  auto&& output = std::basic_ostream<Char>(&format_buf);
-#if !defined(FMTQUILL_STATIC_THOUSANDS_SEPARATOR)
-  output.imbue(std::locale::classic());  // The default is always unlocalized.
-#endif
-  output << value;
-  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-}
-
-template <typename T> struct streamed_view {
-  const T& value;
-};
-
-}  // namespace detail
-
-// Formats an object of type T that has an overloaded ostream operator<<.
-template <typename Char>
-struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
-  void set_debug_format() = delete;
-
-  template <typename T, typename OutputIt>
-  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
-      -> OutputIt {
-    auto buffer = basic_memory_buffer<Char>();
-    detail::format_value(buffer, value);
-    return formatter<basic_string_view<Char>, Char>::format(
-        {buffer.data(), buffer.size()}, ctx);
-  }
-};
-
-using ostream_formatter = basic_ostream_formatter<char>;
-
-template <typename T, typename Char>
-struct formatter<detail::streamed_view<T>, Char>
-    : basic_ostream_formatter<Char> {
-  template <typename OutputIt>
-  auto format(detail::streamed_view<T> view,
-              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
-    return basic_ostream_formatter<Char>::format(view.value, ctx);
-  }
-};
-
-/**
-  \rst
-  Returns a view that formats `value` via an ostream ``operator<<``.
-
-  **Example**::
-
-    fmtquill::print("Current thread id: {}\n",
-               fmtquill::streamed(std::this_thread::get_id()));
-  \endrst
- */
-template <typename T>
-constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
-  return {value};
-}
-
-namespace detail {
-
-inline void vprint_directly(std::ostream& os, string_view format_str,
-                            format_args args) {
-  auto buffer = memory_buffer();
-  detail::vformat_to(buffer, format_str, args);
-  detail::write_buffer(os, buffer);
-}
-
-}  // namespace detail
-
-FMTQUILL_EXPORT template <typename Char>
-void vprint(std::basic_ostream<Char>& os,
-            basic_string_view<type_identity_t<Char>> format_str,
-            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
-  auto buffer = basic_memory_buffer<Char>();
-  detail::vformat_to(buffer, format_str, args);
-  if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return;
-  detail::write_buffer(os, buffer);
-}
-
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    fmtquill::print(cerr, "Don't {}!", "panic");
-  \endrst
- */
-FMTQUILL_EXPORT template <typename... T>
-void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
-  const auto& vargs = fmtquill::make_format_args(args...);
-  if (detail::is_utf8())
-    vprint(os, fmt, vargs);
-  else
-    detail::vprint_directly(os, fmt, vargs);
-}
-
-FMTQUILL_EXPORT
-template <typename... Args>
-void print(std::wostream& os,
-           basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
-           Args&&... args) {
-  vprint(os, fmt, fmtquill::make_format_args<buffer_context<wchar_t>>(args...));
-}
-
-FMTQUILL_EXPORT template <typename... T>
-void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
-  fmtquill::print(os, "{}\n", fmtquill::format(fmt, std::forward<T>(args)...));
-}
-
-FMTQUILL_EXPORT
-template <typename... Args>
-void println(std::wostream& os,
-             basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
-             Args&&... args) {
-  print(os, L"{}\n", fmtquill::format(fmt, std::forward<Args>(args)...));
-}
-
-FMTQUILL_END_NAMESPACE
-
-#endif  // FMTQUILL_OSTREAM_H_
diff --git a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/printf.h b/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/printf.h
deleted file mode 100644
index 01ad47d..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/printf.h
+++ /dev/null
@@ -1,675 +0,0 @@
-// Formatting library for C++ - legacy printf implementation
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMTQUILL_PRINTF_H_
-#define FMTQUILL_PRINTF_H_
-
-#include <algorithm>  // std::max
-#include <limits>     // std::numeric_limits
-
-#include "format.h"
-
-FMTQUILL_BEGIN_NAMESPACE
-FMTQUILL_BEGIN_EXPORT
-
-template <typename T> struct printf_formatter {
-  printf_formatter() = delete;
-};
-
-template <typename Char> class basic_printf_context {
- private:
-  detail::buffer_appender<Char> out_;
-  basic_format_args<basic_printf_context> args_;
-
-  static_assert(std::is_same<Char, char>::value ||
-                    std::is_same<Char, wchar_t>::value,
-                "Unsupported code unit type.");
-
- public:
-  using char_type = Char;
-  using parse_context_type = basic_format_parse_context<Char>;
-  template <typename T> using formatter_type = printf_formatter<T>;
-
-  /**
-    \rst
-    Constructs a ``printf_context`` object. References to the arguments are
-    stored in the context object so make sure they have appropriate lifetimes.
-    \endrst
-   */
-  basic_printf_context(detail::buffer_appender<Char> out,
-                       basic_format_args<basic_printf_context> args)
-      : out_(out), args_(args) {}
-
-  auto out() -> detail::buffer_appender<Char> { return out_; }
-  void advance_to(detail::buffer_appender<Char>) {}
-
-  auto locale() -> detail::locale_ref { return {}; }
-
-  auto arg(int id) const -> basic_format_arg<basic_printf_context> {
-    return args_.get(id);
-  }
-
-  FMTQUILL_CONSTEXPR void on_error(const char* message) {
-    detail::error_handler().on_error(message);
-  }
-};
-
-namespace detail {
-
-// Checks if a value fits in int - used to avoid warnings about comparing
-// signed and unsigned integers.
-template <bool IsSigned> struct int_checker {
-  template <typename T> static auto fits_in_int(T value) -> bool {
-    unsigned max = max_value<int>();
-    return value <= max;
-  }
-  static auto fits_in_int(bool) -> bool { return true; }
-};
-
-template <> struct int_checker<true> {
-  template <typename T> static auto fits_in_int(T value) -> bool {
-    return value >= (std::numeric_limits<int>::min)() &&
-           value <= max_value<int>();
-  }
-  static auto fits_in_int(int) -> bool { return true; }
-};
-
-struct printf_precision_handler {
-  template <typename T, FMTQUILL_ENABLE_IF(std::is_integral<T>::value)>
-  auto operator()(T value) -> int {
-    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      throw_format_error("number is too big");
-    return (std::max)(static_cast<int>(value), 0);
-  }
-
-  template <typename T, FMTQUILL_ENABLE_IF(!std::is_integral<T>::value)>
-  auto operator()(T) -> int {
-    throw_format_error("precision is not integer");
-    return 0;
-  }
-};
-
-// An argument visitor that returns true iff arg is a zero integer.
-struct is_zero_int {
-  template <typename T, FMTQUILL_ENABLE_IF(std::is_integral<T>::value)>
-  auto operator()(T value) -> bool {
-    return value == 0;
-  }
-
-  template <typename T, FMTQUILL_ENABLE_IF(!std::is_integral<T>::value)>
-  auto operator()(T) -> bool {
-    return false;
-  }
-};
-
-template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
-
-template <> struct make_unsigned_or_bool<bool> {
-  using type = bool;
-};
-
-template <typename T, typename Context> class arg_converter {
- private:
-  using char_type = typename Context::char_type;
-
-  basic_format_arg<Context>& arg_;
-  char_type type_;
-
- public:
-  arg_converter(basic_format_arg<Context>& arg, char_type type)
-      : arg_(arg), type_(type) {}
-
-  void operator()(bool value) {
-    if (type_ != 's') operator()<bool>(value);
-  }
-
-  template <typename U, FMTQUILL_ENABLE_IF(std::is_integral<U>::value)>
-  void operator()(U value) {
-    bool is_signed = type_ == 'd' || type_ == 'i';
-    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
-    if (const_check(sizeof(target_type) <= sizeof(int))) {
-      // Extra casts are used to silence warnings.
-      if (is_signed) {
-        auto n = static_cast<int>(static_cast<target_type>(value));
-        arg_ = detail::make_arg<Context>(n);
-      } else {
-        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
-        auto n = static_cast<unsigned>(static_cast<unsigned_type>(value));
-        arg_ = detail::make_arg<Context>(n);
-      }
-    } else {
-      if (is_signed) {
-        // glibc's printf doesn't sign extend arguments of smaller types:
-        //   std::printf("%lld", -42);  // prints "4294967254"
-        // but we don't have to do the same because it's a UB.
-        auto n = static_cast<long long>(value);
-        arg_ = detail::make_arg<Context>(n);
-      } else {
-        auto n = static_cast<typename make_unsigned_or_bool<U>::type>(value);
-        arg_ = detail::make_arg<Context>(n);
-      }
-    }
-  }
-
-  template <typename U, FMTQUILL_ENABLE_IF(!std::is_integral<U>::value)>
-  void operator()(U) {}  // No conversion needed for non-integral types.
-};
-
-// Converts an integer argument to T for printf, if T is an integral type.
-// If T is void, the argument is converted to corresponding signed or unsigned
-// type depending on the type specifier: 'd' and 'i' - signed, other -
-// unsigned).
-template <typename T, typename Context, typename Char>
-void convert_arg(basic_format_arg<Context>& arg, Char type) {
-  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
-}
-
-// Converts an integer argument to char for printf.
-template <typename Context> class char_converter {
- private:
-  basic_format_arg<Context>& arg_;
-
- public:
-  explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}
-
-  template <typename T, FMTQUILL_ENABLE_IF(std::is_integral<T>::value)>
-  void operator()(T value) {
-    auto c = static_cast<typename Context::char_type>(value);
-    arg_ = detail::make_arg<Context>(c);
-  }
-
-  template <typename T, FMTQUILL_ENABLE_IF(!std::is_integral<T>::value)>
-  void operator()(T) {}  // No conversion needed for non-integral types.
-};
-
-// An argument visitor that return a pointer to a C string if argument is a
-// string or null otherwise.
-template <typename Char> struct get_cstring {
-  template <typename T> auto operator()(T) -> const Char* { return nullptr; }
-  auto operator()(const Char* s) -> const Char* { return s; }
-};
-
-// Checks if an argument is a valid printf width specifier and sets
-// left alignment if it is negative.
-template <typename Char> class printf_width_handler {
- private:
-  format_specs<Char>& specs_;
-
- public:
-  explicit printf_width_handler(format_specs<Char>& specs) : specs_(specs) {}
-
-  template <typename T, FMTQUILL_ENABLE_IF(std::is_integral<T>::value)>
-  auto operator()(T value) -> unsigned {
-    auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
-    if (detail::is_negative(value)) {
-      specs_.align = align::left;
-      width = 0 - width;
-    }
-    unsigned int_max = max_value<int>();
-    if (width > int_max) throw_format_error("number is too big");
-    return static_cast<unsigned>(width);
-  }
-
-  template <typename T, FMTQUILL_ENABLE_IF(!std::is_integral<T>::value)>
-  auto operator()(T) -> unsigned {
-    throw_format_error("width is not integer");
-    return 0;
-  }
-};
-
-// Workaround for a bug with the XL compiler when initializing
-// printf_arg_formatter's base class.
-template <typename Char>
-auto make_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s)
-    -> arg_formatter<Char> {
-  return {iter, s, locale_ref()};
-}
-
-// The ``printf`` argument formatter.
-template <typename Char>
-class printf_arg_formatter : public arg_formatter<Char> {
- private:
-  using base = arg_formatter<Char>;
-  using context_type = basic_printf_context<Char>;
-
-  context_type& context_;
-
-  void write_null_pointer(bool is_string = false) {
-    auto s = this->specs;
-    s.type = presentation_type::none;
-    write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
-  }
-
- public:
-  printf_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s,
-                       context_type& ctx)
-      : base(make_arg_formatter(iter, s)), context_(ctx) {}
-
-  void operator()(monostate value) { base::operator()(value); }
-
-  template <typename T, FMTQUILL_ENABLE_IF(detail::is_integral<T>::value)>
-  void operator()(T value) {
-    // MSVC2013 fails to compile separate overloads for bool and Char so use
-    // std::is_same instead.
-    if (!std::is_same<T, Char>::value) {
-      base::operator()(value);
-      return;
-    }
-    format_specs<Char> fmt_specs = this->specs;
-    if (fmt_specs.type != presentation_type::none &&
-        fmt_specs.type != presentation_type::chr) {
-      return (*this)(static_cast<int>(value));
-    }
-    fmt_specs.sign = sign::none;
-    fmt_specs.alt = false;
-    fmt_specs.fill[0] = ' ';  // Ignore '0' flag for char types.
-    // align::numeric needs to be overwritten here since the '0' flag is
-    // ignored for non-numeric types
-    if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
-      fmt_specs.align = align::right;
-    write<Char>(this->out, static_cast<Char>(value), fmt_specs);
-  }
-
-  template <typename T, FMTQUILL_ENABLE_IF(std::is_floating_point<T>::value)>
-  void operator()(T value) {
-    base::operator()(value);
-  }
-
-  /** Formats a null-terminated C string. */
-  void operator()(const char* value) {
-    if (value)
-      base::operator()(value);
-    else
-      write_null_pointer(this->specs.type != presentation_type::pointer);
-  }
-
-  /** Formats a null-terminated wide C string. */
-  void operator()(const wchar_t* value) {
-    if (value)
-      base::operator()(value);
-    else
-      write_null_pointer(this->specs.type != presentation_type::pointer);
-  }
-
-  void operator()(basic_string_view<Char> value) { base::operator()(value); }
-
-  /** Formats a pointer. */
-  void operator()(const void* value) {
-    if (value)
-      base::operator()(value);
-    else
-      write_null_pointer();
-  }
-
-  /** Formats an argument of a custom (user-defined) type. */
-  void operator()(typename basic_format_arg<context_type>::handle handle) {
-    auto parse_ctx = basic_format_parse_context<Char>({});
-    handle.format(parse_ctx, context_);
-  }
-};
-
-template <typename Char>
-void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) {
-  for (; it != end; ++it) {
-    switch (*it) {
-    case '-':
-      specs.align = align::left;
-      break;
-    case '+':
-      specs.sign = sign::plus;
-      break;
-    case '0':
-      specs.fill[0] = '0';
-      break;
-    case ' ':
-      if (specs.sign != sign::plus) specs.sign = sign::space;
-      break;
-    case '#':
-      specs.alt = true;
-      break;
-    default:
-      return;
-    }
-  }
-}
-
-template <typename Char, typename GetArg>
-auto parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
-                  GetArg get_arg) -> int {
-  int arg_index = -1;
-  Char c = *it;
-  if (c >= '0' && c <= '9') {
-    // Parse an argument index (if followed by '$') or a width possibly
-    // preceded with '0' flag(s).
-    int value = parse_nonnegative_int(it, end, -1);
-    if (it != end && *it == '$') {  // value is an argument index
-      ++it;
-      arg_index = value != -1 ? value : max_value<int>();
-    } else {
-      if (c == '0') specs.fill[0] = '0';
-      if (value != 0) {
-        // Nonzero value means that we parsed width and don't need to
-        // parse it or flags again, so return now.
-        if (value == -1) throw_format_error("number is too big");
-        specs.width = value;
-        return arg_index;
-      }
-    }
-  }
-  parse_flags(specs, it, end);
-  // Parse width.
-  if (it != end) {
-    if (*it >= '0' && *it <= '9') {
-      specs.width = parse_nonnegative_int(it, end, -1);
-      if (specs.width == -1) throw_format_error("number is too big");
-    } else if (*it == '*') {
-      ++it;
-      specs.width = static_cast<int>(visit_format_arg(
-          detail::printf_width_handler<Char>(specs), get_arg(-1)));
-    }
-  }
-  return arg_index;
-}
-
-inline auto parse_printf_presentation_type(char c, type t)
-    -> presentation_type {
-  using pt = presentation_type;
-  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
-  switch (c) {
-  case 'd':
-    return in(t, integral_set) ? pt::dec : pt::none;
-  case 'o':
-    return in(t, integral_set) ? pt::oct : pt::none;
-  case 'x':
-    return in(t, integral_set) ? pt::hex_lower : pt::none;
-  case 'X':
-    return in(t, integral_set) ? pt::hex_upper : pt::none;
-  case 'a':
-    return in(t, float_set) ? pt::hexfloat_lower : pt::none;
-  case 'A':
-    return in(t, float_set) ? pt::hexfloat_upper : pt::none;
-  case 'e':
-    return in(t, float_set) ? pt::exp_lower : pt::none;
-  case 'E':
-    return in(t, float_set) ? pt::exp_upper : pt::none;
-  case 'f':
-    return in(t, float_set) ? pt::fixed_lower : pt::none;
-  case 'F':
-    return in(t, float_set) ? pt::fixed_upper : pt::none;
-  case 'g':
-    return in(t, float_set) ? pt::general_lower : pt::none;
-  case 'G':
-    return in(t, float_set) ? pt::general_upper : pt::none;
-  case 'c':
-    return in(t, integral_set) ? pt::chr : pt::none;
-  case 's':
-    return in(t, string_set | cstring_set) ? pt::string : pt::none;
-  case 'p':
-    return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
-  default:
-    return pt::none;
-  }
-}
-
-template <typename Char, typename Context>
-void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
-             basic_format_args<Context> args) {
-  using iterator = buffer_appender<Char>;
-  auto out = iterator(buf);
-  auto context = basic_printf_context<Char>(out, args);
-  auto parse_ctx = basic_format_parse_context<Char>(format);
-
-  // Returns the argument with specified index or, if arg_index is -1, the next
-  // argument.
-  auto get_arg = [&](int arg_index) {
-    if (arg_index < 0)
-      arg_index = parse_ctx.next_arg_id();
-    else
-      parse_ctx.check_arg_id(--arg_index);
-    return detail::get_arg(context, arg_index);
-  };
-
-  const Char* start = parse_ctx.begin();
-  const Char* end = parse_ctx.end();
-  auto it = start;
-  while (it != end) {
-    if (!find<false, Char>(it, end, '%', it)) {
-      it = end;  // find leaves it == nullptr if it doesn't find '%'.
-      break;
-    }
-    Char c = *it++;
-    if (it != end && *it == c) {
-      write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
-      start = ++it;
-      continue;
-    }
-    write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
-
-    auto specs = format_specs<Char>();
-    specs.align = align::right;
-
-    // Parse argument index, flags and width.
-    int arg_index = parse_header(it, end, specs, get_arg);
-    if (arg_index == 0) throw_format_error("argument not found");
-
-    // Parse precision.
-    if (it != end && *it == '.') {
-      ++it;
-      c = it != end ? *it : 0;
-      if ('0' <= c && c <= '9') {
-        specs.precision = parse_nonnegative_int(it, end, 0);
-      } else if (c == '*') {
-        ++it;
-        specs.precision = static_cast<int>(
-            visit_format_arg(printf_precision_handler(), get_arg(-1)));
-      } else {
-        specs.precision = 0;
-      }
-    }
-
-    auto arg = get_arg(arg_index);
-    // For d, i, o, u, x, and X conversion specifiers, if a precision is
-    // specified, the '0' flag is ignored
-    if (specs.precision >= 0 && arg.is_integral()) {
-      // Ignore '0' for non-numeric types or if '-' present.
-      specs.fill[0] = ' ';
-    }
-    if (specs.precision >= 0 && arg.type() == type::cstring_type) {
-      auto str = visit_format_arg(get_cstring<Char>(), arg);
-      auto str_end = str + specs.precision;
-      auto nul = std::find(str, str_end, Char());
-      auto sv = basic_string_view<Char>(
-          str, to_unsigned(nul != str_end ? nul - str : specs.precision));
-      arg = make_arg<basic_printf_context<Char>>(sv);
-    }
-    if (specs.alt && visit_format_arg(is_zero_int(), arg)) specs.alt = false;
-    if (specs.fill[0] == '0') {
-      if (arg.is_arithmetic() && specs.align != align::left)
-        specs.align = align::numeric;
-      else
-        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types or if '-'
-                              // flag is also present.
-    }
-
-    // Parse length and convert the argument to the required type.
-    c = it != end ? *it++ : 0;
-    Char t = it != end ? *it : 0;
-    switch (c) {
-    case 'h':
-      if (t == 'h') {
-        ++it;
-        t = it != end ? *it : 0;
-        convert_arg<signed char>(arg, t);
-      } else {
-        convert_arg<short>(arg, t);
-      }
-      break;
-    case 'l':
-      if (t == 'l') {
-        ++it;
-        t = it != end ? *it : 0;
-        convert_arg<long long>(arg, t);
-      } else {
-        convert_arg<long>(arg, t);
-      }
-      break;
-    case 'j':
-      convert_arg<intmax_t>(arg, t);
-      break;
-    case 'z':
-      convert_arg<size_t>(arg, t);
-      break;
-    case 't':
-      convert_arg<std::ptrdiff_t>(arg, t);
-      break;
-    case 'L':
-      // printf produces garbage when 'L' is omitted for long double, no
-      // need to do the same.
-      break;
-    default:
-      --it;
-      convert_arg<void>(arg, c);
-    }
-
-    // Parse type.
-    if (it == end) throw_format_error("invalid format string");
-    char type = static_cast<char>(*it++);
-    if (arg.is_integral()) {
-      // Normalize type.
-      switch (type) {
-      case 'i':
-      case 'u':
-        type = 'd';
-        break;
-      case 'c':
-        visit_format_arg(char_converter<basic_printf_context<Char>>(arg), arg);
-        break;
-      }
-    }
-    specs.type = parse_printf_presentation_type(type, arg.type());
-    if (specs.type == presentation_type::none)
-      throw_format_error("invalid format specifier");
-
-    start = it;
-
-    // Format argument.
-    visit_format_arg(printf_arg_formatter<Char>(out, specs, context), arg);
-  }
-  write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
-}
-}  // namespace detail
-
-using printf_context = basic_printf_context<char>;
-using wprintf_context = basic_printf_context<wchar_t>;
-
-using printf_args = basic_format_args<printf_context>;
-using wprintf_args = basic_format_args<wprintf_context>;
-
-/**
-  \rst
-  Constructs an `~fmtquill::format_arg_store` object that contains references to
-  arguments and can be implicitly converted to `~fmtquill::printf_args`.
-  \endrst
- */
-template <typename... T>
-inline auto make_printf_args(const T&... args)
-    -> format_arg_store<printf_context, T...> {
-  return {args...};
-}
-
-// DEPRECATED!
-template <typename... T>
-inline auto make_wprintf_args(const T&... args)
-    -> format_arg_store<wprintf_context, T...> {
-  return {args...};
-}
-
-template <typename Char>
-inline auto vsprintf(
-    basic_string_view<Char> fmt,
-    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
-    -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vprintf(buf, fmt, args);
-  return to_string(buf);
-}
-
-/**
-  \rst
-  Formats arguments and returns the result as a string.
-
-  **Example**::
-
-    std::string message = fmtquill::sprintf("The answer is %d", 42);
-  \endrst
-*/
-template <typename S, typename... T,
-          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
-inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
-  return vsprintf(detail::to_string_view(fmt),
-                  fmtquill::make_format_args<basic_printf_context<Char>>(args...));
-}
-
-template <typename Char>
-inline auto vfprintf(
-    std::FILE* f, basic_string_view<Char> fmt,
-    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
-    -> int {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vprintf(buf, fmt, args);
-  size_t size = buf.size();
-  return std::fwrite(buf.data(), sizeof(Char), size, f) < size
-             ? -1
-             : static_cast<int>(size);
-}
-
-/**
-  \rst
-  Prints formatted data to the file *f*.
-
-  **Example**::
-
-    fmtquill::fprintf(stderr, "Don't %s!", "panic");
-  \endrst
- */
-template <typename S, typename... T, typename Char = char_t<S>>
-inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
-  return vfprintf(f, detail::to_string_view(fmt),
-                  fmtquill::make_format_args<basic_printf_context<Char>>(args...));
-}
-
-template <typename Char>
-FMTQUILL_DEPRECATED inline auto vprintf(
-    basic_string_view<Char> fmt,
-    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
-    -> int {
-  return vfprintf(stdout, fmt, args);
-}
-
-/**
-  \rst
-  Prints formatted data to ``stdout``.
-
-  **Example**::
-
-    fmtquill::printf("Elapsed time: %.2f seconds", 1.23);
-  \endrst
- */
-template <typename... T>
-inline auto printf(string_view fmt, const T&... args) -> int {
-  return vfprintf(stdout, fmt, make_printf_args(args...));
-}
-template <typename... T>
-FMTQUILL_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt,
-                                  const T&... args) -> int {
-  return vfprintf(stdout, fmt, make_wprintf_args(args...));
-}
-
-FMTQUILL_END_EXPORT
-FMTQUILL_END_NAMESPACE
-
-#endif  // FMTQUILL_PRINTF_H_
diff --git a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/ranges.h b/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/ranges.h
deleted file mode 100644
index 376da7e..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/ranges.h
+++ /dev/null
@@ -1,738 +0,0 @@
-// Formatting library for C++ - range and tuple support
-//
-// Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMTQUILL_RANGES_H_
-#define FMTQUILL_RANGES_H_
-
-#include <initializer_list>
-#include <tuple>
-#include <type_traits>
-
-#include "format.h"
-
-FMTQUILL_BEGIN_NAMESPACE
-
-namespace detail {
-
-template <typename Range, typename OutputIt>
-auto copy(const Range& range, OutputIt out) -> OutputIt {
-  for (auto it = range.begin(), end = range.end(); it != end; ++it)
-    *out++ = *it;
-  return out;
-}
-
-template <typename OutputIt>
-auto copy(const char* str, OutputIt out) -> OutputIt {
-  while (*str) *out++ = *str++;
-  return out;
-}
-
-template <typename OutputIt> auto copy(char ch, OutputIt out) -> OutputIt {
-  *out++ = ch;
-  return out;
-}
-
-template <typename OutputIt> auto copy(wchar_t ch, OutputIt out) -> OutputIt {
-  *out++ = ch;
-  return out;
-}
-
-// Returns true if T has a std::string-like interface, like std::string_view.
-template <typename T> class is_std_string_like {
-  template <typename U>
-  static auto check(U* p)
-      -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
-  template <typename> static void check(...);
-
- public:
-  static constexpr const bool value =
-      is_string<T>::value ||
-      std::is_convertible<T, std_string_view<char>>::value ||
-      !std::is_void<decltype(check<T>(nullptr))>::value;
-};
-
-template <typename Char>
-struct is_std_string_like<fmtquill::basic_string_view<Char>> : std::true_type {};
-
-template <typename T> class is_map {
-  template <typename U> static auto check(U*) -> typename U::mapped_type;
-  template <typename> static void check(...);
-
- public:
-#ifdef FMTQUILL_FORMAT_MAP_AS_LIST  // DEPRECATED!
-  static constexpr const bool value = false;
-#else
-  static constexpr const bool value =
-      !std::is_void<decltype(check<T>(nullptr))>::value;
-#endif
-};
-
-template <typename T> class is_set {
-  template <typename U> static auto check(U*) -> typename U::key_type;
-  template <typename> static void check(...);
-
- public:
-#ifdef FMTQUILL_FORMAT_SET_AS_LIST  // DEPRECATED!
-  static constexpr const bool value = false;
-#else
-  static constexpr const bool value =
-      !std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value;
-#endif
-};
-
-template <typename... Ts> struct conditional_helper {};
-
-template <typename T, typename _ = void> struct is_range_ : std::false_type {};
-
-#if !FMTQUILL_MSC_VERSION || FMTQUILL_MSC_VERSION > 1800
-
-#  define FMTQUILL_DECLTYPE_RETURN(val)  \
-    ->decltype(val) { return val; } \
-    static_assert(                  \
-        true, "")  // This makes it so that a semicolon is required after the
-                   // macro, which helps clang-format handle the formatting.
-
-// C array overload
-template <typename T, std::size_t N>
-auto range_begin(const T (&arr)[N]) -> const T* {
-  return arr;
-}
-template <typename T, std::size_t N>
-auto range_end(const T (&arr)[N]) -> const T* {
-  return arr + N;
-}
-
-template <typename T, typename Enable = void>
-struct has_member_fn_begin_end_t : std::false_type {};
-
-template <typename T>
-struct has_member_fn_begin_end_t<T, void_t<decltype(std::declval<T>().begin()),
-                                           decltype(std::declval<T>().end())>>
-    : std::true_type {};
-
-// Member function overload
-template <typename T>
-auto range_begin(T&& rng) FMTQUILL_DECLTYPE_RETURN(static_cast<T&&>(rng).begin());
-template <typename T>
-auto range_end(T&& rng) FMTQUILL_DECLTYPE_RETURN(static_cast<T&&>(rng).end());
-
-// ADL overload. Only participates in overload resolution if member functions
-// are not found.
-template <typename T>
-auto range_begin(T&& rng)
-    -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
-                   decltype(begin(static_cast<T&&>(rng)))> {
-  return begin(static_cast<T&&>(rng));
-}
-template <typename T>
-auto range_end(T&& rng) -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
-                                       decltype(end(static_cast<T&&>(rng)))> {
-  return end(static_cast<T&&>(rng));
-}
-
-template <typename T, typename Enable = void>
-struct has_const_begin_end : std::false_type {};
-template <typename T, typename Enable = void>
-struct has_mutable_begin_end : std::false_type {};
-
-template <typename T>
-struct has_const_begin_end<
-    T,
-    void_t<
-        decltype(detail::range_begin(std::declval<const remove_cvref_t<T>&>())),
-        decltype(detail::range_end(std::declval<const remove_cvref_t<T>&>()))>>
-    : std::true_type {};
-
-template <typename T>
-struct has_mutable_begin_end<
-    T, void_t<decltype(detail::range_begin(std::declval<T>())),
-              decltype(detail::range_end(std::declval<T>())),
-              // the extra int here is because older versions of MSVC don't
-              // SFINAE properly unless there are distinct types
-              int>> : std::true_type {};
-
-template <typename T>
-struct is_range_<T, void>
-    : std::integral_constant<bool, (has_const_begin_end<T>::value ||
-                                    has_mutable_begin_end<T>::value)> {};
-#  undef FMTQUILL_DECLTYPE_RETURN
-#endif
-
-// tuple_size and tuple_element check.
-template <typename T> class is_tuple_like_ {
-  template <typename U>
-  static auto check(U* p) -> decltype(std::tuple_size<U>::value, int());
-  template <typename> static void check(...);
-
- public:
-  static constexpr const bool value =
-      !std::is_void<decltype(check<T>(nullptr))>::value;
-};
-
-// Check for integer_sequence
-#if defined(__cpp_lib_integer_sequence) || FMTQUILL_MSC_VERSION >= 1900
-template <typename T, T... N>
-using integer_sequence = std::integer_sequence<T, N...>;
-template <size_t... N> using index_sequence = std::index_sequence<N...>;
-template <size_t N> using make_index_sequence = std::make_index_sequence<N>;
-#else
-template <typename T, T... N> struct integer_sequence {
-  using value_type = T;
-
-  static FMTQUILL_CONSTEXPR auto size() -> size_t { return sizeof...(N); }
-};
-
-template <size_t... N> using index_sequence = integer_sequence<size_t, N...>;
-
-template <typename T, size_t N, T... Ns>
-struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
-template <typename T, T... Ns>
-struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
-
-template <size_t N>
-using make_index_sequence = make_integer_sequence<size_t, N>;
-#endif
-
-template <typename T>
-using tuple_index_sequence = make_index_sequence<std::tuple_size<T>::value>;
-
-template <typename T, typename C, bool = is_tuple_like_<T>::value>
-class is_tuple_formattable_ {
- public:
-  static constexpr const bool value = false;
-};
-template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
-  template <std::size_t... Is>
-  static auto check2(index_sequence<Is...>,
-                     integer_sequence<bool, (Is == Is)...>) -> std::true_type;
-  static auto check2(...) -> std::false_type;
-  template <std::size_t... Is>
-  static auto check(index_sequence<Is...>) -> decltype(check2(
-      index_sequence<Is...>{},
-      integer_sequence<bool,
-                       (is_formattable<typename std::tuple_element<Is, T>::type,
-                                       C>::value)...>{}));
-
- public:
-  static constexpr const bool value =
-      decltype(check(tuple_index_sequence<T>{}))::value;
-};
-
-template <typename Tuple, typename F, size_t... Is>
-FMTQUILL_CONSTEXPR void for_each(index_sequence<Is...>, Tuple&& t, F&& f) {
-  using std::get;
-  // Using a free function get<Is>(Tuple) now.
-  const int unused[] = {0, ((void)f(get<Is>(t)), 0)...};
-  ignore_unused(unused);
-}
-
-template <typename Tuple, typename F>
-FMTQUILL_CONSTEXPR void for_each(Tuple&& t, F&& f) {
-  for_each(tuple_index_sequence<remove_cvref_t<Tuple>>(),
-           std::forward<Tuple>(t), std::forward<F>(f));
-}
-
-template <typename Tuple1, typename Tuple2, typename F, size_t... Is>
-void for_each2(index_sequence<Is...>, Tuple1&& t1, Tuple2&& t2, F&& f) {
-  using std::get;
-  const int unused[] = {0, ((void)f(get<Is>(t1), get<Is>(t2)), 0)...};
-  ignore_unused(unused);
-}
-
-template <typename Tuple1, typename Tuple2, typename F>
-void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) {
-  for_each2(tuple_index_sequence<remove_cvref_t<Tuple1>>(),
-            std::forward<Tuple1>(t1), std::forward<Tuple2>(t2),
-            std::forward<F>(f));
-}
-
-namespace tuple {
-// Workaround a bug in MSVC 2019 (v140).
-template <typename Char, typename... T>
-using result_t = std::tuple<formatter<remove_cvref_t<T>, Char>...>;
-
-using std::get;
-template <typename Tuple, typename Char, std::size_t... Is>
-auto get_formatters(index_sequence<Is...>)
-    -> result_t<Char, decltype(get<Is>(std::declval<Tuple>()))...>;
-}  // namespace tuple
-
-#if FMTQUILL_MSC_VERSION && FMTQUILL_MSC_VERSION < 1920
-// Older MSVC doesn't get the reference type correctly for arrays.
-template <typename R> struct range_reference_type_impl {
-  using type = decltype(*detail::range_begin(std::declval<R&>()));
-};
-
-template <typename T, std::size_t N> struct range_reference_type_impl<T[N]> {
-  using type = T&;
-};
-
-template <typename T>
-using range_reference_type = typename range_reference_type_impl<T>::type;
-#else
-template <typename Range>
-using range_reference_type =
-    decltype(*detail::range_begin(std::declval<Range&>()));
-#endif
-
-// We don't use the Range's value_type for anything, but we do need the Range's
-// reference type, with cv-ref stripped.
-template <typename Range>
-using uncvref_type = remove_cvref_t<range_reference_type<Range>>;
-
-template <typename Formatter>
-FMTQUILL_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set)
-    -> decltype(f.set_debug_format(set)) {
-  f.set_debug_format(set);
-}
-template <typename Formatter>
-FMTQUILL_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {}
-
-// These are not generic lambdas for compatibility with C++11.
-template <typename ParseContext> struct parse_empty_specs {
-  template <typename Formatter> FMTQUILL_CONSTEXPR void operator()(Formatter& f) {
-    f.parse(ctx);
-    detail::maybe_set_debug_format(f, true);
-  }
-  ParseContext& ctx;
-};
-template <typename FormatContext> struct format_tuple_element {
-  using char_type = typename FormatContext::char_type;
-
-  template <typename T>
-  void operator()(const formatter<T, char_type>& f, const T& v) {
-    if (i > 0)
-      ctx.advance_to(detail::copy_str<char_type>(separator, ctx.out()));
-    ctx.advance_to(f.format(v, ctx));
-    ++i;
-  }
-
-  int i;
-  FormatContext& ctx;
-  basic_string_view<char_type> separator;
-};
-
-}  // namespace detail
-
-template <typename T> struct is_tuple_like {
-  static constexpr const bool value =
-      detail::is_tuple_like_<T>::value && !detail::is_range_<T>::value;
-};
-
-template <typename T, typename C> struct is_tuple_formattable {
-  static constexpr const bool value =
-      detail::is_tuple_formattable_<T, C>::value;
-};
-
-template <typename Tuple, typename Char>
-struct formatter<Tuple, Char,
-                 enable_if_t<fmtquill::is_tuple_like<Tuple>::value &&
-                             fmtquill::is_tuple_formattable<Tuple, Char>::value>> {
- private:
-  decltype(detail::tuple::get_formatters<Tuple, Char>(
-      detail::tuple_index_sequence<Tuple>())) formatters_;
-
-  basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
-  basic_string_view<Char> opening_bracket_ =
-      detail::string_literal<Char, '('>{};
-  basic_string_view<Char> closing_bracket_ =
-      detail::string_literal<Char, ')'>{};
-
- public:
-  FMTQUILL_CONSTEXPR formatter() {}
-
-  FMTQUILL_CONSTEXPR void set_separator(basic_string_view<Char> sep) {
-    separator_ = sep;
-  }
-
-  FMTQUILL_CONSTEXPR void set_brackets(basic_string_view<Char> open,
-                                  basic_string_view<Char> close) {
-    opening_bracket_ = open;
-    closing_bracket_ = close;
-  }
-
-  template <typename ParseContext>
-  FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    auto it = ctx.begin();
-    if (it != ctx.end() && *it != '}')
-      FMTQUILL_THROW(format_error("invalid format specifier"));
-    detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
-    return it;
-  }
-
-  template <typename FormatContext>
-  auto format(const Tuple& value, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    ctx.advance_to(detail::copy_str<Char>(opening_bracket_, ctx.out()));
-    detail::for_each2(
-        formatters_, value,
-        detail::format_tuple_element<FormatContext>{0, ctx, separator_});
-    return detail::copy_str<Char>(closing_bracket_, ctx.out());
-  }
-};
-
-template <typename T, typename Char> struct is_range {
-  static constexpr const bool value =
-      detail::is_range_<T>::value && !detail::is_std_string_like<T>::value &&
-      !std::is_convertible<T, std::basic_string<Char>>::value &&
-      !std::is_convertible<T, detail::std_string_view<Char>>::value;
-};
-
-namespace detail {
-template <typename Context> struct range_mapper {
-  using mapper = arg_mapper<Context>;
-
-  template <typename T,
-            FMTQUILL_ENABLE_IF(has_formatter<remove_cvref_t<T>, Context>::value)>
-  static auto map(T&& value) -> T&& {
-    return static_cast<T&&>(value);
-  }
-  template <typename T,
-            FMTQUILL_ENABLE_IF(!has_formatter<remove_cvref_t<T>, Context>::value)>
-  static auto map(T&& value)
-      -> decltype(mapper().map(static_cast<T&&>(value))) {
-    return mapper().map(static_cast<T&&>(value));
-  }
-};
-
-template <typename Char, typename Element>
-using range_formatter_type =
-    formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map(
-                  std::declval<Element>()))>,
-              Char>;
-
-template <typename R>
-using maybe_const_range =
-    conditional_t<has_const_begin_end<R>::value, const R, R>;
-
-// Workaround a bug in MSVC 2015 and earlier.
-#if !FMTQUILL_MSC_VERSION || FMTQUILL_MSC_VERSION >= 1910
-template <typename R, typename Char>
-struct is_formattable_delayed
-    : is_formattable<uncvref_type<maybe_const_range<R>>, Char> {};
-#endif
-}  // namespace detail
-
-template <typename...> struct conjunction : std::true_type {};
-template <typename P> struct conjunction<P> : P {};
-template <typename P1, typename... Pn>
-struct conjunction<P1, Pn...>
-    : conditional_t<bool(P1::value), conjunction<Pn...>, P1> {};
-
-template <typename T, typename Char, typename Enable = void>
-struct range_formatter;
-
-template <typename T, typename Char>
-struct range_formatter<
-    T, Char,
-    enable_if_t<conjunction<std::is_same<T, remove_cvref_t<T>>,
-                            is_formattable<T, Char>>::value>> {
- private:
-  detail::range_formatter_type<Char, T> underlying_;
-  basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
-  basic_string_view<Char> opening_bracket_ =
-      detail::string_literal<Char, '['>{};
-  basic_string_view<Char> closing_bracket_ =
-      detail::string_literal<Char, ']'>{};
-
- public:
-  FMTQUILL_CONSTEXPR range_formatter() {}
-
-  FMTQUILL_CONSTEXPR auto underlying() -> detail::range_formatter_type<Char, T>& {
-    return underlying_;
-  }
-
-  FMTQUILL_CONSTEXPR void set_separator(basic_string_view<Char> sep) {
-    separator_ = sep;
-  }
-
-  FMTQUILL_CONSTEXPR void set_brackets(basic_string_view<Char> open,
-                                  basic_string_view<Char> close) {
-    opening_bracket_ = open;
-    closing_bracket_ = close;
-  }
-
-  template <typename ParseContext>
-  FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    auto it = ctx.begin();
-    auto end = ctx.end();
-
-    if (it != end && *it == 'n') {
-      set_brackets({}, {});
-      ++it;
-    }
-
-    if (it != end && *it != '}') {
-      if (*it != ':') FMTQUILL_THROW(format_error("invalid format specifier"));
-      ++it;
-    } else {
-      detail::maybe_set_debug_format(underlying_, true);
-    }
-
-    ctx.advance_to(it);
-    return underlying_.parse(ctx);
-  }
-
-  template <typename R, typename FormatContext>
-  auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
-    detail::range_mapper<buffer_context<Char>> mapper;
-    auto out = ctx.out();
-    out = detail::copy_str<Char>(opening_bracket_, out);
-    int i = 0;
-    auto it = detail::range_begin(range);
-    auto end = detail::range_end(range);
-    for (; it != end; ++it) {
-      if (i > 0) out = detail::copy_str<Char>(separator_, out);
-      ctx.advance_to(out);
-      auto&& item = *it;
-      out = underlying_.format(mapper.map(item), ctx);
-      ++i;
-    }
-    out = detail::copy_str<Char>(closing_bracket_, out);
-    return out;
-  }
-};
-
-enum class range_format { disabled, map, set, sequence, string, debug_string };
-
-namespace detail {
-template <typename T>
-struct range_format_kind_
-    : std::integral_constant<range_format,
-                             std::is_same<uncvref_type<T>, T>::value
-                                 ? range_format::disabled
-                             : is_map<T>::value ? range_format::map
-                             : is_set<T>::value ? range_format::set
-                                                : range_format::sequence> {};
-
-template <range_format K, typename R, typename Char, typename Enable = void>
-struct range_default_formatter;
-
-template <range_format K>
-using range_format_constant = std::integral_constant<range_format, K>;
-
-template <range_format K, typename R, typename Char>
-struct range_default_formatter<
-    K, R, Char,
-    enable_if_t<(K == range_format::sequence || K == range_format::map ||
-                 K == range_format::set)>> {
-  using range_type = detail::maybe_const_range<R>;
-  range_formatter<detail::uncvref_type<range_type>, Char> underlying_;
-
-  FMTQUILL_CONSTEXPR range_default_formatter() { init(range_format_constant<K>()); }
-
-  FMTQUILL_CONSTEXPR void init(range_format_constant<range_format::set>) {
-    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
-                             detail::string_literal<Char, '}'>{});
-  }
-
-  FMTQUILL_CONSTEXPR void init(range_format_constant<range_format::map>) {
-    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
-                             detail::string_literal<Char, '}'>{});
-    underlying_.underlying().set_brackets({}, {});
-    underlying_.underlying().set_separator(
-        detail::string_literal<Char, ':', ' '>{});
-  }
-
-  FMTQUILL_CONSTEXPR void init(range_format_constant<range_format::sequence>) {}
-
-  template <typename ParseContext>
-  FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return underlying_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(range_type& range, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return underlying_.format(range, ctx);
-  }
-};
-}  // namespace detail
-
-template <typename T, typename Char, typename Enable = void>
-struct range_format_kind
-    : conditional_t<
-          is_range<T, Char>::value, detail::range_format_kind_<T>,
-          std::integral_constant<range_format, range_format::disabled>> {};
-
-template <typename R, typename Char>
-struct formatter<
-    R, Char,
-    enable_if_t<conjunction<bool_constant<range_format_kind<R, Char>::value !=
-                                          range_format::disabled>
-// Workaround a bug in MSVC 2015 and earlier.
-#if !FMTQUILL_MSC_VERSION || FMTQUILL_MSC_VERSION >= 1910
-                            ,
-                            detail::is_formattable_delayed<R, Char>
-#endif
-                            >::value>>
-    : detail::range_default_formatter<range_format_kind<R, Char>::value, R,
-                                      Char> {
-};
-
-template <typename Char, typename... T> struct tuple_join_view : detail::view {
-  const std::tuple<T...>& tuple;
-  basic_string_view<Char> sep;
-
-  tuple_join_view(const std::tuple<T...>& t, basic_string_view<Char> s)
-      : tuple(t), sep{s} {}
-};
-
-// Define FMTQUILL_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers
-// support in tuple_join. It is disabled by default because of issues with
-// the dynamic width and precision.
-#ifndef FMTQUILL_TUPLE_JOIN_SPECIFIERS
-#  define FMTQUILL_TUPLE_JOIN_SPECIFIERS 0
-#endif
-
-template <typename Char, typename... T>
-struct formatter<tuple_join_view<Char, T...>, Char> {
-  template <typename ParseContext>
-  FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return do_parse(ctx, std::integral_constant<size_t, sizeof...(T)>());
-  }
-
-  template <typename FormatContext>
-  auto format(const tuple_join_view<Char, T...>& value,
-              FormatContext& ctx) const -> typename FormatContext::iterator {
-    return do_format(value, ctx,
-                     std::integral_constant<size_t, sizeof...(T)>());
-  }
-
- private:
-  std::tuple<formatter<typename std::decay<T>::type, Char>...> formatters_;
-
-  template <typename ParseContext>
-  FMTQUILL_CONSTEXPR auto do_parse(ParseContext& ctx,
-                              std::integral_constant<size_t, 0>)
-      -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  template <typename ParseContext, size_t N>
-  FMTQUILL_CONSTEXPR auto do_parse(ParseContext& ctx,
-                              std::integral_constant<size_t, N>)
-      -> decltype(ctx.begin()) {
-    auto end = ctx.begin();
-#if FMTQUILL_TUPLE_JOIN_SPECIFIERS
-    end = std::get<sizeof...(T) - N>(formatters_).parse(ctx);
-    if (N > 1) {
-      auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>());
-      if (end != end1)
-        FMTQUILL_THROW(format_error("incompatible format specs for tuple elements"));
-    }
-#endif
-    return end;
-  }
-
-  template <typename FormatContext>
-  auto do_format(const tuple_join_view<Char, T...>&, FormatContext& ctx,
-                 std::integral_constant<size_t, 0>) const ->
-      typename FormatContext::iterator {
-    return ctx.out();
-  }
-
-  template <typename FormatContext, size_t N>
-  auto do_format(const tuple_join_view<Char, T...>& value, FormatContext& ctx,
-                 std::integral_constant<size_t, N>) const ->
-      typename FormatContext::iterator {
-    auto out = std::get<sizeof...(T) - N>(formatters_)
-                   .format(std::get<sizeof...(T) - N>(value.tuple), ctx);
-    if (N > 1) {
-      out = std::copy(value.sep.begin(), value.sep.end(), out);
-      ctx.advance_to(out);
-      return do_format(value, ctx, std::integral_constant<size_t, N - 1>());
-    }
-    return out;
-  }
-};
-
-namespace detail {
-// Check if T has an interface like a container adaptor (e.g. std::stack,
-// std::queue, std::priority_queue).
-template <typename T> class is_container_adaptor_like {
-  template <typename U> static auto check(U* p) -> typename U::container_type;
-  template <typename> static void check(...);
-
- public:
-  static constexpr const bool value =
-      !std::is_void<decltype(check<T>(nullptr))>::value;
-};
-
-template <typename Container> struct all {
-  const Container& c;
-  auto begin() const -> typename Container::const_iterator { return c.begin(); }
-  auto end() const -> typename Container::const_iterator { return c.end(); }
-};
-}  // namespace detail
-
-template <typename T, typename Char>
-struct formatter<
-    T, Char,
-    enable_if_t<conjunction<detail::is_container_adaptor_like<T>,
-                            bool_constant<range_format_kind<T, Char>::value ==
-                                          range_format::disabled>>::value>>
-    : formatter<detail::all<typename T::container_type>, Char> {
-  using all = detail::all<typename T::container_type>;
-  template <typename FormatContext>
-  auto format(const T& t, FormatContext& ctx) const -> decltype(ctx.out()) {
-    struct getter : T {
-      static auto get(const T& t) -> all {
-        return {t.*(&getter::c)};  // Access c through the derived class.
-      }
-    };
-    return formatter<all>::format(getter::get(t), ctx);
-  }
-};
-
-FMTQUILL_BEGIN_EXPORT
-
-/**
-  \rst
-  Returns an object that formats `tuple` with elements separated by `sep`.
-
-  **Example**::
-
-    std::tuple<int, char> t = {1, 'a'};
-    fmtquill::print("{}", fmtquill::join(t, ", "));
-    // Output: "1, a"
-  \endrst
- */
-template <typename... T>
-FMTQUILL_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
-    -> tuple_join_view<char, T...> {
-  return {tuple, sep};
-}
-
-template <typename... T>
-FMTQUILL_CONSTEXPR auto join(const std::tuple<T...>& tuple,
-                        basic_string_view<wchar_t> sep)
-    -> tuple_join_view<wchar_t, T...> {
-  return {tuple, sep};
-}
-
-/**
-  \rst
-  Returns an object that formats `initializer_list` with elements separated by
-  `sep`.
-
-  **Example**::
-
-    fmtquill::print("{}", fmtquill::join({1, 2, 3}, ", "));
-    // Output: "1, 2, 3"
-  \endrst
- */
-template <typename T>
-auto join(std::initializer_list<T> list, string_view sep)
-    -> join_view<const T*, const T*> {
-  return join(std::begin(list), std::end(list), sep);
-}
-
-FMTQUILL_END_EXPORT
-FMTQUILL_END_NAMESPACE
-
-#endif  // FMTQUILL_RANGES_H_
diff --git a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/std.h b/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/std.h
deleted file mode 100644
index 32299be..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/std.h
+++ /dev/null
@@ -1,537 +0,0 @@
-// Formatting library for C++ - formatters for standard library types
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMTQUILL_STD_H_
-#define FMTQUILL_STD_H_
-
-#include <atomic>
-#include <bitset>
-#include <cstdlib>
-#include <exception>
-#include <memory>
-#include <thread>
-#include <type_traits>
-#include <typeinfo>
-#include <utility>
-#include <vector>
-
-#include "format.h"
-#include "ostream.h"
-
-#if FMTQUILL_HAS_INCLUDE(<version>)
-#  include <version>
-#endif
-// Checking FMTQUILL_CPLUSPLUS for warning suppression in MSVC.
-#if FMTQUILL_CPLUSPLUS >= 201703L
-#  if FMTQUILL_HAS_INCLUDE(<filesystem>)
-#    include <filesystem>
-#  endif
-#  if FMTQUILL_HAS_INCLUDE(<variant>)
-#    include <variant>
-#  endif
-#  if FMTQUILL_HAS_INCLUDE(<optional>)
-#    include <optional>
-#  endif
-#endif
-
-#if FMTQUILL_CPLUSPLUS > 201703L && FMTQUILL_HAS_INCLUDE(<source_location>)
-#  include <source_location>
-#endif
-
-// GCC 4 does not support FMTQUILL_HAS_INCLUDE.
-#if FMTQUILL_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
-#  include <cxxabi.h>
-// Android NDK with gabi++ library on some architectures does not implement
-// abi::__cxa_demangle().
-#  ifndef __GABIXX_CXXABI_H__
-#    define FMTQUILL_HAS_ABI_CXA_DEMANGLE
-#  endif
-#endif
-
-// Check if typeid is available.
-#ifndef FMTQUILL_USE_TYPEID
-// __RTTI is for EDG compilers. In MSVC typeid is available without RTTI.
-#  if defined(__GXX_RTTI) || FMTQUILL_HAS_FEATURE(cxx_rtti) || FMTQUILL_MSC_VERSION || \
-      defined(__INTEL_RTTI__) || defined(__RTTI)
-#    define FMTQUILL_USE_TYPEID 1
-#  else
-#    define FMTQUILL_USE_TYPEID 0
-#  endif
-#endif
-
-// For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
-#ifndef FMTQUILL_CPP_LIB_FILESYSTEM
-#  ifdef __cpp_lib_filesystem
-#    define FMTQUILL_CPP_LIB_FILESYSTEM __cpp_lib_filesystem
-#  else
-#    define FMTQUILL_CPP_LIB_FILESYSTEM 0
-#  endif
-#endif
-
-#ifndef FMTQUILL_CPP_LIB_VARIANT
-#  ifdef __cpp_lib_variant
-#    define FMTQUILL_CPP_LIB_VARIANT __cpp_lib_variant
-#  else
-#    define FMTQUILL_CPP_LIB_VARIANT 0
-#  endif
-#endif
-
-#if FMTQUILL_CPP_LIB_FILESYSTEM
-FMTQUILL_BEGIN_NAMESPACE
-
-namespace detail {
-
-template <typename Char, typename PathChar>
-auto get_path_string(const std::filesystem::path& p,
-                     const std::basic_string<PathChar>& native) {
-  if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>)
-    return to_utf8<wchar_t>(native, to_utf8_error_policy::replace);
-  else
-    return p.string<Char>();
-}
-
-template <typename Char, typename PathChar>
-void write_escaped_path(basic_memory_buffer<Char>& quoted,
-                        const std::filesystem::path& p,
-                        const std::basic_string<PathChar>& native) {
-  if constexpr (std::is_same_v<Char, char> &&
-                std::is_same_v<PathChar, wchar_t>) {
-    auto buf = basic_memory_buffer<wchar_t>();
-    write_escaped_string<wchar_t>(std::back_inserter(buf), native);
-    bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
-    FMTQUILL_ASSERT(valid, "invalid utf16");
-  } else if constexpr (std::is_same_v<Char, PathChar>) {
-    write_escaped_string<std::filesystem::path::value_type>(
-        std::back_inserter(quoted), native);
-  } else {
-    write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
-  }
-}
-
-}  // namespace detail
-
-FMTQUILL_EXPORT
-template <typename Char> struct formatter<std::filesystem::path, Char> {
- private:
-  format_specs<Char> specs_;
-  detail::arg_ref<Char> width_ref_;
-  bool debug_ = false;
-  char path_type_ = 0;
-
- public:
-  FMTQUILL_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
-
-  template <typename ParseContext> FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) {
-    auto it = ctx.begin(), end = ctx.end();
-    if (it == end) return it;
-
-    it = detail::parse_align(it, end, specs_);
-    if (it == end) return it;
-
-    it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
-    if (it != end && *it == '?') {
-      debug_ = true;
-      ++it;
-    }
-    if (it != end && (*it == 'g')) path_type_ = *it++;
-    return it;
-  }
-
-  template <typename FormatContext>
-  auto format(const std::filesystem::path& p, FormatContext& ctx) const {
-    auto specs = specs_;
-#  ifdef _WIN32
-    auto path_string = !path_type_ ? p.native() : p.generic_wstring();
-#  else
-    auto path_string = !path_type_ ? p.native() : p.generic_string();
-#  endif
-
-    detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
-                                                       ctx);
-    if (!debug_) {
-      auto s = detail::get_path_string<Char>(p, path_string);
-      return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
-    }
-    auto quoted = basic_memory_buffer<Char>();
-    detail::write_escaped_path(quoted, p, path_string);
-    return detail::write(ctx.out(),
-                         basic_string_view<Char>(quoted.data(), quoted.size()),
-                         specs);
-  }
-};
-FMTQUILL_END_NAMESPACE
-#endif  // FMTQUILL_CPP_LIB_FILESYSTEM
-
-FMTQUILL_BEGIN_NAMESPACE
-FMTQUILL_EXPORT
-template <std::size_t N, typename Char>
-struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> {
- private:
-  // Functor because C++11 doesn't support generic lambdas.
-  struct writer {
-    const std::bitset<N>& bs;
-
-    template <typename OutputIt>
-    FMTQUILL_CONSTEXPR auto operator()(OutputIt out) -> OutputIt {
-      for (auto pos = N; pos > 0; --pos) {
-        out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0'));
-      }
-
-      return out;
-    }
-  };
-
- public:
-  template <typename FormatContext>
-  auto format(const std::bitset<N>& bs, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return write_padded(ctx, writer{bs});
-  }
-};
-
-FMTQUILL_EXPORT
-template <typename Char>
-struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
-FMTQUILL_END_NAMESPACE
-
-#ifdef __cpp_lib_optional
-FMTQUILL_BEGIN_NAMESPACE
-FMTQUILL_EXPORT
-template <typename T, typename Char>
-struct formatter<std::optional<T>, Char,
-                 std::enable_if_t<is_formattable<T, Char>::value>> {
- private:
-  formatter<T, Char> underlying_;
-  static constexpr basic_string_view<Char> optional =
-      detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l',
-                             '('>{};
-  static constexpr basic_string_view<Char> none =
-      detail::string_literal<Char, 'n', 'o', 'n', 'e'>{};
-
-  template <class U>
-  FMTQUILL_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set)
-      -> decltype(u.set_debug_format(set)) {
-    u.set_debug_format(set);
-  }
-
-  template <class U>
-  FMTQUILL_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
-
- public:
-  template <typename ParseContext> FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) {
-    maybe_set_debug_format(underlying_, true);
-    return underlying_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(const std::optional<T>& opt, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    if (!opt) return detail::write<Char>(ctx.out(), none);
-
-    auto out = ctx.out();
-    out = detail::write<Char>(out, optional);
-    ctx.advance_to(out);
-    out = underlying_.format(*opt, ctx);
-    return detail::write(out, ')');
-  }
-};
-FMTQUILL_END_NAMESPACE
-#endif  // __cpp_lib_optional
-
-#ifdef __cpp_lib_source_location
-FMTQUILL_BEGIN_NAMESPACE
-FMTQUILL_EXPORT
-template <> struct formatter<std::source_location> {
-  template <typename ParseContext> FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const std::source_location& loc, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    out = detail::write(out, loc.file_name());
-    out = detail::write(out, ':');
-    out = detail::write<char>(out, loc.line());
-    out = detail::write(out, ':');
-    out = detail::write<char>(out, loc.column());
-    out = detail::write(out, ": ");
-    out = detail::write(out, loc.function_name());
-    return out;
-  }
-};
-FMTQUILL_END_NAMESPACE
-#endif
-
-#if FMTQUILL_CPP_LIB_VARIANT
-FMTQUILL_BEGIN_NAMESPACE
-namespace detail {
-
-template <typename T>
-using variant_index_sequence =
-    std::make_index_sequence<std::variant_size<T>::value>;
-
-template <typename> struct is_variant_like_ : std::false_type {};
-template <typename... Types>
-struct is_variant_like_<std::variant<Types...>> : std::true_type {};
-
-// formattable element check.
-template <typename T, typename C> class is_variant_formattable_ {
-  template <std::size_t... Is>
-  static std::conjunction<
-      is_formattable<std::variant_alternative_t<Is, T>, C>...>
-      check(std::index_sequence<Is...>);
-
- public:
-  static constexpr const bool value =
-      decltype(check(variant_index_sequence<T>{}))::value;
-};
-
-template <typename Char, typename OutputIt, typename T>
-auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt {
-  if constexpr (is_string<T>::value)
-    return write_escaped_string<Char>(out, detail::to_string_view(v));
-  else if constexpr (std::is_same_v<T, Char>)
-    return write_escaped_char(out, v);
-  else
-    return write<Char>(out, v);
-}
-
-}  // namespace detail
-
-template <typename T> struct is_variant_like {
-  static constexpr const bool value = detail::is_variant_like_<T>::value;
-};
-
-template <typename T, typename C> struct is_variant_formattable {
-  static constexpr const bool value =
-      detail::is_variant_formattable_<T, C>::value;
-};
-
-FMTQUILL_EXPORT
-template <typename Char> struct formatter<std::monostate, Char> {
-  template <typename ParseContext>
-  FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const std::monostate&, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return detail::write<Char>(ctx.out(), "monostate");
-  }
-};
-
-FMTQUILL_EXPORT
-template <typename Variant, typename Char>
-struct formatter<
-    Variant, Char,
-    std::enable_if_t<std::conjunction_v<
-        is_variant_like<Variant>, is_variant_formattable<Variant, Char>>>> {
-  template <typename ParseContext>
-  FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const Variant& value, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-
-    out = detail::write<Char>(out, "variant(");
-    FMTQUILL_TRY {
-      std::visit(
-          [&](const auto& v) {
-            out = detail::write_variant_alternative<Char>(out, v);
-          },
-          value);
-    }
-    FMTQUILL_CATCH(const std::bad_variant_access&) {
-      detail::write<Char>(out, "valueless by exception");
-    }
-    *out++ = ')';
-    return out;
-  }
-};
-FMTQUILL_END_NAMESPACE
-#endif  // FMTQUILL_CPP_LIB_VARIANT
-
-FMTQUILL_BEGIN_NAMESPACE
-FMTQUILL_EXPORT
-template <typename Char> struct formatter<std::error_code, Char> {
-  template <typename ParseContext>
-  FMTQUILL_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  FMTQUILL_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    out = detail::write_bytes(out, ec.category().name(), format_specs<Char>());
-    out = detail::write<Char>(out, Char(':'));
-    out = detail::write<Char>(out, ec.value());
-    return out;
-  }
-};
-
-FMTQUILL_EXPORT
-template <typename T, typename Char>
-struct formatter<
-    T, Char,  // DEPRECATED! Mixing code unit types.
-    typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
- private:
-  bool with_typename_ = false;
-
- public:
-  FMTQUILL_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-      -> decltype(ctx.begin()) {
-    auto it = ctx.begin();
-    auto end = ctx.end();
-    if (it == end || *it == '}') return it;
-    if (*it == 't') {
-      ++it;
-      with_typename_ = FMTQUILL_USE_TYPEID != 0;
-    }
-    return it;
-  }
-
-  template <typename OutputIt>
-  auto format(const std::exception& ex,
-              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
-    format_specs<Char> spec;
-    auto out = ctx.out();
-    if (!with_typename_)
-      return detail::write_bytes(out, string_view(ex.what()), spec);
-
-#if FMTQUILL_USE_TYPEID
-    const std::type_info& ti = typeid(ex);
-#  ifdef FMTQUILL_HAS_ABI_CXA_DEMANGLE
-    int status = 0;
-    std::size_t size = 0;
-    std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
-        abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
-
-    string_view demangled_name_view;
-    if (demangled_name_ptr) {
-      demangled_name_view = demangled_name_ptr.get();
-
-      // Normalization of stdlib inline namespace names.
-      // libc++ inline namespaces.
-      //  std::__1::*       -> std::*
-      //  std::__1::__fs::* -> std::*
-      // libstdc++ inline namespaces.
-      //  std::__cxx11::*             -> std::*
-      //  std::filesystem::__cxx11::* -> std::filesystem::*
-      if (demangled_name_view.starts_with("std::")) {
-        char* begin = demangled_name_ptr.get();
-        char* to = begin + 5;  // std::
-        for (char *from = to, *end = begin + demangled_name_view.size();
-             from < end;) {
-          // This is safe, because demangled_name is NUL-terminated.
-          if (from[0] == '_' && from[1] == '_') {
-            char* next = from + 1;
-            while (next < end && *next != ':') next++;
-            if (next[0] == ':' && next[1] == ':') {
-              from = next + 2;
-              continue;
-            }
-          }
-          *to++ = *from++;
-        }
-        demangled_name_view = {begin, detail::to_unsigned(to - begin)};
-      }
-    } else {
-      demangled_name_view = string_view(ti.name());
-    }
-    out = detail::write_bytes(out, demangled_name_view, spec);
-#  elif FMTQUILL_MSC_VERSION
-    string_view demangled_name_view(ti.name());
-    if (demangled_name_view.starts_with("class "))
-      demangled_name_view.remove_prefix(6);
-    else if (demangled_name_view.starts_with("struct "))
-      demangled_name_view.remove_prefix(7);
-    out = detail::write_bytes(out, demangled_name_view, spec);
-#  else
-    out = detail::write_bytes(out, string_view(ti.name()), spec);
-#  endif
-    *out++ = ':';
-    *out++ = ' ';
-    return detail::write_bytes(out, string_view(ex.what()), spec);
-#endif
-  }
-};
-
-namespace detail {
-
-template <typename T, typename Enable = void>
-struct has_flip : std::false_type {};
-
-template <typename T>
-struct has_flip<T, void_t<decltype(std::declval<T>().flip())>>
-    : std::true_type {};
-
-template <typename T> struct is_bit_reference_like {
-  static constexpr const bool value =
-      std::is_convertible<T, bool>::value &&
-      std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value;
-};
-
-#ifdef _LIBCPP_VERSION
-
-// Workaround for libc++ incompatibility with C++ standard.
-// According to the Standard, `bitset::operator[] const` returns bool.
-template <typename C>
-struct is_bit_reference_like<std::__bit_const_reference<C>> {
-  static constexpr const bool value = true;
-};
-
-#endif
-
-}  // namespace detail
-
-// We can't use std::vector<bool, Allocator>::reference and
-// std::bitset<N>::reference because the compiler can't deduce Allocator and N
-// in partial specialization.
-FMTQUILL_EXPORT
-template <typename BitRef, typename Char>
-struct formatter<BitRef, Char,
-                 enable_if_t<detail::is_bit_reference_like<BitRef>::value>>
-    : formatter<bool, Char> {
-  template <typename FormatContext>
-  FMTQUILL_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<bool, Char>::format(v, ctx);
-  }
-};
-
-FMTQUILL_EXPORT
-template <typename T, typename Char>
-struct formatter<std::atomic<T>, Char,
-                 enable_if_t<is_formattable<T, Char>::value>>
-    : formatter<T, Char> {
-  template <typename FormatContext>
-  auto format(const std::atomic<T>& v, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<T, Char>::format(v.load(), ctx);
-  }
-};
-
-#ifdef __cpp_lib_atomic_flag_test
-FMTQUILL_EXPORT
-template <typename Char>
-struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
-  template <typename FormatContext>
-  auto format(const std::atomic_flag& v, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<bool, Char>::format(v.test(), ctx);
-  }
-};
-#endif  // __cpp_lib_atomic_flag_test
-
-FMTQUILL_END_NAMESPACE
-#endif  // FMTQUILL_STD_H_
diff --git a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/xchar.h b/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/xchar.h
deleted file mode 100644
index 572d5c1..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/bundled/fmt/xchar.h
+++ /dev/null
@@ -1,259 +0,0 @@
-// Formatting library for C++ - optional wchar_t and exotic character support
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMTQUILL_XCHAR_H_
-#define FMTQUILL_XCHAR_H_
-
-#include <cwchar>
-
-#include "format.h"
-
-#ifndef FMTQUILL_STATIC_THOUSANDS_SEPARATOR
-#  include <locale>
-#endif
-
-FMTQUILL_BEGIN_NAMESPACE
-namespace detail {
-
-template <typename T>
-using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
-
-inline auto write_loc(std::back_insert_iterator<detail::buffer<wchar_t>> out,
-                      loc_value value, const format_specs<wchar_t>& specs,
-                      locale_ref loc) -> bool {
-#ifndef FMTQUILL_STATIC_THOUSANDS_SEPARATOR
-  auto& numpunct =
-      std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>());
-  auto separator = std::wstring();
-  auto grouping = numpunct.grouping();
-  if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep());
-  return value.visit(loc_writer<wchar_t>{out, specs, separator, grouping, {}});
-#endif
-  return false;
-}
-}  // namespace detail
-
-FMTQUILL_BEGIN_EXPORT
-
-using wstring_view = basic_string_view<wchar_t>;
-using wformat_parse_context = basic_format_parse_context<wchar_t>;
-using wformat_context = buffer_context<wchar_t>;
-using wformat_args = basic_format_args<wformat_context>;
-using wmemory_buffer = basic_memory_buffer<wchar_t>;
-
-#if FMTQUILL_GCC_VERSION && FMTQUILL_GCC_VERSION < 409
-// Workaround broken conversion on older gcc.
-template <typename... Args> using wformat_string = wstring_view;
-inline auto runtime(wstring_view s) -> wstring_view { return s; }
-#else
-template <typename... Args>
-using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
-inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
-  return {{s}};
-}
-#endif
-
-template <> struct is_char<wchar_t> : std::true_type {};
-template <> struct is_char<detail::char8_type> : std::true_type {};
-template <> struct is_char<char16_t> : std::true_type {};
-template <> struct is_char<char32_t> : std::true_type {};
-
-template <typename... T>
-constexpr auto make_wformat_args(const T&... args)
-    -> format_arg_store<wformat_context, T...> {
-  return {args...};
-}
-
-inline namespace literals {
-#if FMTQUILL_USE_USER_DEFINED_LITERALS && !FMTQUILL_USE_NONTYPE_TEMPLATE_ARGS
-constexpr auto operator""_a(const wchar_t* s, size_t)
-    -> detail::udl_arg<wchar_t> {
-  return {s};
-}
-#endif
-}  // namespace literals
-
-template <typename It, typename Sentinel>
-auto join(It begin, Sentinel end, wstring_view sep)
-    -> join_view<It, Sentinel, wchar_t> {
-  return {begin, end, sep};
-}
-
-template <typename Range>
-auto join(Range&& range, wstring_view sep)
-    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>,
-                 wchar_t> {
-  return join(std::begin(range), std::end(range), sep);
-}
-
-template <typename T>
-auto join(std::initializer_list<T> list, wstring_view sep)
-    -> join_view<const T*, const T*, wchar_t> {
-  return join(std::begin(list), std::end(list), sep);
-}
-
-template <typename Char, FMTQUILL_ENABLE_IF(!std::is_same<Char, char>::value)>
-auto vformat(basic_string_view<Char> format_str,
-             basic_format_args<buffer_context<type_identity_t<Char>>> args)
-    -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vformat_to(buf, format_str, args);
-  return to_string(buf);
-}
-
-template <typename... T>
-auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
-  return vformat(fmtquill::wstring_view(fmt), fmtquill::make_wformat_args(args...));
-}
-
-// Pass char_t as a default template parameter instead of using
-// std::basic_string<char_t<S>> to reduce the symbol size.
-template <typename S, typename... T, typename Char = char_t<S>,
-          FMTQUILL_ENABLE_IF(!std::is_same<Char, char>::value &&
-                        !std::is_same<Char, wchar_t>::value)>
-auto format(const S& format_str, T&&... args) -> std::basic_string<Char> {
-  return vformat(detail::to_string_view(format_str),
-                 fmtquill::make_format_args<buffer_context<Char>>(args...));
-}
-
-template <typename Locale, typename S, typename Char = char_t<S>,
-          FMTQUILL_ENABLE_IF(detail::is_locale<Locale>::value&&
-                            detail::is_exotic_char<Char>::value)>
-inline auto vformat(
-    const Locale& loc, const S& format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args)
-    -> std::basic_string<Char> {
-  return detail::vformat(loc, detail::to_string_view(format_str), args);
-}
-
-template <typename Locale, typename S, typename... T, typename Char = char_t<S>,
-          FMTQUILL_ENABLE_IF(detail::is_locale<Locale>::value&&
-                            detail::is_exotic_char<Char>::value)>
-inline auto format(const Locale& loc, const S& format_str, T&&... args)
-    -> std::basic_string<Char> {
-  return detail::vformat(loc, detail::to_string_view(format_str),
-                         fmtquill::make_format_args<buffer_context<Char>>(args...));
-}
-
-template <typename OutputIt, typename S, typename Char = char_t<S>,
-          FMTQUILL_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
-                            detail::is_exotic_char<Char>::value)>
-auto vformat_to(OutputIt out, const S& format_str,
-                basic_format_args<buffer_context<type_identity_t<Char>>> args)
-    -> OutputIt {
-  auto&& buf = detail::get_buffer<Char>(out);
-  detail::vformat_to(buf, detail::to_string_view(format_str), args);
-  return detail::get_iterator(buf, out);
-}
-
-template <typename OutputIt, typename S, typename... T,
-          typename Char = char_t<S>,
-          FMTQUILL_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
-                            detail::is_exotic_char<Char>::value)>
-inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
-  return vformat_to(out, detail::to_string_view(fmt),
-                    fmtquill::make_format_args<buffer_context<Char>>(args...));
-}
-
-template <typename Locale, typename S, typename OutputIt, typename... Args,
-          typename Char = char_t<S>,
-          FMTQUILL_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
-                            detail::is_locale<Locale>::value&&
-                                detail::is_exotic_char<Char>::value)>
-inline auto vformat_to(
-    OutputIt out, const Locale& loc, const S& format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt {
-  auto&& buf = detail::get_buffer<Char>(out);
-  vformat_to(buf, detail::to_string_view(format_str), args,
-             detail::locale_ref(loc));
-  return detail::get_iterator(buf, out);
-}
-
-template <typename OutputIt, typename Locale, typename S, typename... T,
-          typename Char = char_t<S>,
-          bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
-                        detail::is_locale<Locale>::value &&
-                        detail::is_exotic_char<Char>::value>
-inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
-                      T&&... args) ->
-    typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, loc, detail::to_string_view(format_str),
-                    fmtquill::make_format_args<buffer_context<Char>>(args...));
-}
-
-template <typename OutputIt, typename Char, typename... Args,
-          FMTQUILL_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
-                            detail::is_exotic_char<Char>::value)>
-inline auto vformat_to_n(
-    OutputIt out, size_t n, basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args)
-    -> format_to_n_result<OutputIt> {
-  using traits = detail::fixed_buffer_traits;
-  auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n);
-  detail::vformat_to(buf, format_str, args);
-  return {buf.out(), buf.count()};
-}
-
-template <typename OutputIt, typename S, typename... T,
-          typename Char = char_t<S>,
-          FMTQUILL_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
-                            detail::is_exotic_char<Char>::value)>
-inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args)
-    -> format_to_n_result<OutputIt> {
-  return vformat_to_n(out, n, detail::to_string_view(fmt),
-                      fmtquill::make_format_args<buffer_context<Char>>(args...));
-}
-
-template <typename S, typename... T, typename Char = char_t<S>,
-          FMTQUILL_ENABLE_IF(detail::is_exotic_char<Char>::value)>
-inline auto formatted_size(const S& fmt, T&&... args) -> size_t {
-  auto buf = detail::counting_buffer<Char>();
-  detail::vformat_to(buf, detail::to_string_view(fmt),
-                     fmtquill::make_format_args<buffer_context<Char>>(args...));
-  return buf.count();
-}
-
-inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
-  auto buf = wmemory_buffer();
-  detail::vformat_to(buf, fmt, args);
-  buf.push_back(L'\0');
-  if (std::fputws(buf.data(), f) == -1)
-    FMTQUILL_THROW(system_error(errno, FMTQUILL_STRING("cannot write to file")));
-}
-
-inline void vprint(wstring_view fmt, wformat_args args) {
-  vprint(stdout, fmt, args);
-}
-
-template <typename... T>
-void print(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
-  return vprint(f, wstring_view(fmt), fmtquill::make_wformat_args(args...));
-}
-
-template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
-  return vprint(wstring_view(fmt), fmtquill::make_wformat_args(args...));
-}
-
-template <typename... T>
-void println(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
-  return print(f, L"{}\n", fmtquill::format(fmt, std::forward<T>(args)...));
-}
-
-template <typename... T> void println(wformat_string<T...> fmt, T&&... args) {
-  return print(L"{}\n", fmtquill::format(fmt, std::forward<T>(args)...));
-}
-
-/**
-  Converts *value* to ``std::wstring`` using the default format for type *T*.
- */
-template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
-  return format(FMTQUILL_STRING(L"{}"), value);
-}
-FMTQUILL_END_EXPORT
-FMTQUILL_END_NAMESPACE
-
-#endif  // FMTQUILL_XCHAR_H_
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/Attributes.h b/subprojects/quill-4.2.0/quill/include/quill/core/Attributes.h
deleted file mode 100644
index e7451b0..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/Attributes.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-/**
- * C++ language standard detection
- */
-#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
-  #define QUILL_HAS_CPP_17
-  #define QUILL_HAS_CPP_14
-#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
-  #define QUILL_HAS_CPP_14
-#endif
-
-/**
- * __has_attribute
- */
-#ifdef __has_attribute
-  #define QUILL_HAS_ATTRIBUTE(x) __has_attribute(x)
-#else
-  #define QUILL_HAS_ATTRIBUTE(x) 0
-#endif
-
-/**
- * __has_cpp_attribute
- */
-#if defined(__cplusplus) && defined(__has_cpp_attribute)
-  #define QUILL_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-  #define QUILL_HAS_CPP_ATTRIBUTE(x) 0
-#endif
-
-#if defined(__has_include) && !defined(__INTELLISENSE__) &&                                        \
-  !(defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1600)
-  #define QUILL_HAS_INCLUDE(x) __has_include(x)
-#else
-  #define QUILL_HAS_INCLUDE(x) 0
-#endif
-
-/**
- * Portable no discard warnings
- */
-#if QUILL_HAS_CPP_ATTRIBUTE(nodiscard)
-  #if defined(__clang__) && !defined(QUILL_HAS_CPP_17)
-    #define QUILL_NODISCARD
-  #else
-    #define QUILL_NODISCARD [[nodiscard]]
-  #endif
-#elif QUILL_HAS_CPP_ATTRIBUTE(gnu::warn_unused_result)
-  #define QUILL_NODISCARD [[gnu::warn_unused_result]]
-#else
-  #define QUILL_NODISCARD
-#endif
-
-/**
- * Portable maybe_unused
- */
-#if QUILL_HAS_CPP_ATTRIBUTE(maybe_unused) && (defined(_HAS_CXX17) && _HAS_CXX17 == 1)
-  #define QUILL_MAYBE_UNUSED [[maybe_unused]]
-#elif QUILL_HAS_ATTRIBUTE(__unused__) || defined(__GNUC__)
-  #define QUILL_MAYBE_UNUSED __attribute__((__unused__))
-#else
-  #define QUILL_MAYBE_UNUSED
-#endif
-
-/**
- * Gcc hot/cold attributes
- * Tells GCC that a function is hot or cold. GCC can use this information to
- * improve static analysis, i.e. a conditional branch to a cold function
- * is likely to be not-taken.
- */
-#if QUILL_HAS_ATTRIBUTE(hot) || (defined(__GNUC__) && !defined(__clang__))
-  #define QUILL_ATTRIBUTE_HOT __attribute__((hot))
-#else
-  #define QUILL_ATTRIBUTE_HOT
-#endif
-
-#if QUILL_HAS_ATTRIBUTE(cold) || (defined(__GNUC__) && !defined(__clang__))
-  #define QUILL_ATTRIBUTE_COLD __attribute__((cold))
-#else
-  #define QUILL_ATTRIBUTE_COLD
-#endif
-
-/**
- * Likely
- */
-#if defined(__GNUC__)
-  #define QUILL_LIKELY(x) (__builtin_expect((x), 1))
-  #define QUILL_UNLIKELY(x) (__builtin_expect((x), 0))
-#else
-  #define QUILL_LIKELY(x) (x)
-  #define QUILL_UNLIKELY(x) (x)
-#endif
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/BoundedSPSCQueue.h b/subprojects/quill-4.2.0/quill/include/quill/core/BoundedSPSCQueue.h
deleted file mode 100644
index 7531f39..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/BoundedSPSCQueue.h
+++ /dev/null
@@ -1,327 +0,0 @@
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/MathUtils.h"
-#include "quill/core/QuillError.h"
-
-#include <atomic>
-#include <cassert>
-#include <cerrno>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <string>
-
-#if defined(_WIN32)
-  #include <malloc.h>
-#elif defined(__APPLE__)
-  #include <sys/mman.h>
-  #include <unistd.h>
-#elif defined(__CYGWIN__)
-  #include <sys/mman.h>
-  #include <unistd.h>
-#elif defined(__linux__)
-  #include <sys/mman.h>
-#elif defined(__NetBSD__)
-  #include <lwp.h>
-  #include <sys/mman.h>
-  #include <unistd.h>
-#elif defined(__FreeBSD__)
-  #include <sys/mman.h>
-  #include <sys/thr.h>
-  #include <unistd.h>
-#elif defined(__DragonFly__)
-  #include <sys/lwp.h>
-  #include <sys/mman.h>
-  #include <unistd.h>
-#else
-  #include <sys/mman.h>
-  #include <sys/stat.h>
-  #include <unistd.h>
-#endif
-
-#if defined(QUILL_X86ARCH)
-  #if defined(_WIN32)
-    #include <intrin.h>
-  #else
-    #if __has_include(<x86gprintrin.h>)
-      #if defined(__GNUC__) && __GNUC__ > 10
-        #include <emmintrin.h>
-        #include <x86gprintrin.h>
-      #elif defined(__clang_major__)
-      // clang needs immintrin for _mm_clflushopt
-        #include <immintrin.h>
-      #endif
-    #else
-      #include <immintrin.h>
-      #include <x86intrin.h>
-    #endif
-  #endif
-#endif
-
-namespace quill::detail
-{
-/**
- * A bounded single producer single consumer ring buffer.
- */
-template <typename T>
-class BoundedSPSCQueueImpl
-{
-public:
-  using integer_type = T;
-
-  QUILL_ATTRIBUTE_HOT explicit BoundedSPSCQueueImpl(integer_type capacity, bool huges_pages_enabled = false,
-                                                    integer_type reader_store_percent = 5)
-    : _capacity(next_power_of_two(capacity)),
-      _mask(_capacity - 1),
-      _bytes_per_batch(static_cast<integer_type>(_capacity * static_cast<double>(reader_store_percent) / 100.0)),
-      _storage(static_cast<std::byte*>(_alloc_aligned(2ull * static_cast<uint64_t>(_capacity),
-                                                      CACHE_LINE_ALIGNED, huges_pages_enabled))),
-      _huge_pages_enabled(huges_pages_enabled)
-  {
-    std::memset(_storage, 0, 2ull * static_cast<uint64_t>(_capacity));
-
-    _atomic_writer_pos.store(0);
-    _atomic_reader_pos.store(0);
-
-#if defined(QUILL_X86ARCH)
-    // remove log memory from cache
-    for (uint64_t i = 0; i < (2ull * static_cast<uint64_t>(_capacity)); i += CACHE_LINE_SIZE)
-    {
-      _mm_clflush(_storage + i);
-    }
-
-    // load cache lines into memory
-    if (_capacity < 1024)
-    {
-      QUILL_THROW(QuillError{"Capacity must be at least 1024"});
-    }
-
-    uint64_t const cache_lines = (_capacity >= 2048) ? 32 : 16;
-
-    for (uint64_t i = 0; i < cache_lines; ++i)
-    {
-      _mm_prefetch(reinterpret_cast<char const*>(_storage + (CACHE_LINE_SIZE * i)), _MM_HINT_T0);
-    }
-#endif
-  }
-
-  ~BoundedSPSCQueueImpl() { _free_aligned(_storage); }
-
-  /**
-   * Deleted
-   */
-  BoundedSPSCQueueImpl(BoundedSPSCQueueImpl const&) = delete;
-  BoundedSPSCQueueImpl& operator=(BoundedSPSCQueueImpl const&) = delete;
-
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT std::byte* prepare_write(integer_type n) noexcept
-  {
-    if ((_capacity - static_cast<integer_type>(_writer_pos - _reader_pos_cache)) < n)
-    {
-      // not enough space, we need to load reader and re-check
-      _reader_pos_cache = _atomic_reader_pos.load(std::memory_order_acquire);
-
-      if ((_capacity - static_cast<integer_type>(_writer_pos - _reader_pos_cache)) < n)
-      {
-        return nullptr;
-      }
-    }
-
-    return _storage + (_writer_pos & _mask);
-  }
-
-  QUILL_ATTRIBUTE_HOT void finish_write(integer_type n) noexcept { _writer_pos += n; }
-
-  QUILL_ATTRIBUTE_HOT void commit_write() noexcept
-  {
-    // set the atomic flag so the reader can see write
-    _atomic_writer_pos.store(_writer_pos, std::memory_order_release);
-
-#if defined(QUILL_X86ARCH)
-    // flush writen cache lines
-    _flush_cachelines(_last_flushed_writer_pos, _writer_pos);
-
-    // prefetch a future cache line
-    _mm_prefetch(reinterpret_cast<char const*>(_storage + (_writer_pos & _mask) + (CACHE_LINE_SIZE * 10)),
-                 _MM_HINT_T0);
-#endif
-  }
-
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT std::byte* prepare_read() noexcept
-  {
-    if (_writer_pos_cache == _reader_pos)
-    {
-      _writer_pos_cache = _atomic_writer_pos.load(std::memory_order_acquire);
-
-      if (_writer_pos_cache == _reader_pos)
-      {
-        return nullptr;
-      }
-    }
-
-    return _storage + (_reader_pos & _mask);
-  }
-
-  QUILL_ATTRIBUTE_HOT void finish_read(integer_type n) noexcept { _reader_pos += n; }
-
-  QUILL_ATTRIBUTE_HOT void commit_read() noexcept
-  {
-    if (static_cast<integer_type>(_reader_pos - _atomic_reader_pos.load(std::memory_order_relaxed)) >= _bytes_per_batch)
-    {
-      _atomic_reader_pos.store(_reader_pos, std::memory_order_release);
-
-#if defined(QUILL_X86ARCH)
-      _flush_cachelines(_last_flushed_reader_pos, _reader_pos);
-#endif
-    }
-  }
-
-  /**
-   * Only meant to be called by the reader
-   * @return true if the queue is empty
-   */
-  QUILL_NODISCARD bool empty() const noexcept
-  {
-    return _reader_pos == _atomic_writer_pos.load(std::memory_order_relaxed);
-  }
-
-  QUILL_NODISCARD integer_type capacity() const noexcept
-  {
-    return static_cast<integer_type>(_capacity);
-  }
-
-  QUILL_NODISCARD bool huge_pages_enabled() const noexcept { return _huge_pages_enabled; }
-
-private:
-#if defined(QUILL_X86ARCH)
-  QUILL_ATTRIBUTE_HOT void _flush_cachelines(integer_type& last, integer_type offset)
-  {
-    integer_type last_diff = last - (last & CACHELINE_MASK);
-    integer_type const cur_diff = offset - (offset & CACHELINE_MASK);
-
-    while (cur_diff > last_diff)
-    {
-      _mm_clflushopt(_storage + (last_diff & _mask));
-      last_diff += CACHE_LINE_SIZE;
-      last = last_diff;
-    }
-  }
-#endif
-
-  /**
-   * align a pointer to the given alignment
-   * @param pointer a pointer the object
-   * @return an aligned pointer for the given object
-   */
-  QUILL_NODISCARD static std::byte* _align_pointer(void* pointer, size_t alignment) noexcept
-  {
-    assert(is_power_of_two(alignment) && "alignment must be a power of two");
-    return reinterpret_cast<std::byte*>((reinterpret_cast<uintptr_t>(pointer) + (alignment - 1ul)) &
-                                        ~(alignment - 1ul));
-  }
-
-  /**
-   * Aligned alloc
-   * @param size number of bytes to allocate. An integral multiple of alignment
-   * @param alignment specifies the alignment. Must be a valid alignment supported by the implementation.
-   * @param huges_pages_enabled allocate huge pages, only supported on linux
-   * @return On success, returns the pointer to the beginning of newly allocated memory.
-   * To avoid a memory leak, the returned pointer must be deallocated with _free_aligned().
-   * @throws  std::system_error on failure
-   */
-
-  QUILL_NODISCARD static void* _alloc_aligned(size_t size, size_t alignment, bool huges_pages_enabled)
-  {
-#if defined(_WIN32)
-    void* p = _aligned_malloc(size, alignment);
-
-    if (!p)
-    {
-      QUILL_THROW(QuillError{std::string{"_alloc_aligned failed with error message errno: "} +
-                             std::to_string(errno)});
-    }
-
-    return p;
-#else
-    // Calculate the total size including the metadata and alignment
-    constexpr size_t metadata_size{2u * sizeof(size_t)};
-    size_t const total_size{size + metadata_size + alignment};
-
-    // Allocate the memory
-    int flags = MAP_PRIVATE | MAP_ANONYMOUS;
-
-  #if defined(__linux__)
-    if (huges_pages_enabled)
-    {
-      flags |= MAP_HUGETLB;
-    }
-  #endif
-
-    void* mem = ::mmap(nullptr, total_size, PROT_READ | PROT_WRITE, flags, -1, 0);
-
-    if (mem == MAP_FAILED)
-    {
-      QUILL_THROW(QuillError{std::string{"mmap failed. errno: "} + std::to_string(errno) +
-                             " error: " + strerror(errno)});
-    }
-
-    // Calculate the aligned address after the metadata
-    std::byte* aligned_address = _align_pointer(static_cast<std::byte*>(mem) + metadata_size, alignment);
-
-    // Calculate the offset from the original memory location
-    auto const offset = static_cast<size_t>(aligned_address - static_cast<std::byte*>(mem));
-
-    // Store the size and offset information in the metadata
-    std::memcpy(aligned_address - sizeof(size_t), &total_size, sizeof(total_size));
-    std::memcpy(aligned_address - (2u * sizeof(size_t)), &offset, sizeof(offset));
-
-    return aligned_address;
-#endif
-  }
-
-  /**
-   * Free aligned memory allocated with _alloc_aligned
-   * @param ptr address to aligned memory
-   */
-  void static _free_aligned(void* ptr) noexcept
-  {
-#if defined(_WIN32)
-    _aligned_free(ptr);
-#else
-    // Retrieve the size and offset information from the metadata
-    size_t offset;
-    std::memcpy(&offset, static_cast<std::byte*>(ptr) - (2u * sizeof(size_t)), sizeof(offset));
-
-    size_t total_size;
-    std::memcpy(&total_size, static_cast<std::byte*>(ptr) - sizeof(size_t), sizeof(total_size));
-
-    // Calculate the original memory block address
-    void* mem = static_cast<std::byte*>(ptr) - offset;
-
-    ::munmap(mem, total_size);
-#endif
-  }
-
-private:
-  static constexpr integer_type CACHELINE_MASK{CACHE_LINE_SIZE - 1};
-
-  integer_type const _capacity;
-  integer_type const _mask;
-  integer_type const _bytes_per_batch;
-  std::byte* const _storage{nullptr};
-  bool const _huge_pages_enabled;
-
-  alignas(CACHE_LINE_ALIGNED) std::atomic<integer_type> _atomic_writer_pos{0};
-  alignas(CACHE_LINE_ALIGNED) integer_type _writer_pos{0};
-  integer_type _reader_pos_cache{0};
-  integer_type _last_flushed_writer_pos{0};
-
-  alignas(CACHE_LINE_ALIGNED) std::atomic<integer_type> _atomic_reader_pos{0};
-  alignas(CACHE_LINE_ALIGNED) integer_type _reader_pos{0};
-  integer_type _writer_pos_cache{0};
-  integer_type _last_flushed_reader_pos{0};
-};
-
-using BoundedSPSCQueue = BoundedSPSCQueueImpl<uint32_t>;
-} // namespace quill::detail
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/Codec.h b/subprojects/quill-4.2.0/quill/include/quill/core/Codec.h
deleted file mode 100644
index c925952..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/Codec.h
+++ /dev/null
@@ -1,435 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#ifndef __STDC_WANT_LIB_EXT1__
-  #define __STDC_WANT_LIB_EXT1__ 1
-#endif
-
-#include "quill/bundled/fmt/core.h"
-
-#include "quill/core/Attributes.h"
-#include "quill/core/DynamicFormatArgStore.h"
-
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <string>
-#include <string_view>
-#include <type_traits>
-#include <vector>
-
-#if defined(_WIN32)
-  #if !defined(WIN32_LEAN_AND_MEAN)
-    #define WIN32_LEAN_AND_MEAN
-  #endif
-
-  #if !defined(NOMINMAX)
-    // Mingw already defines this, so no need to redefine
-    #define NOMINMAX
-  #endif
-
-  #include <memory>
-  #include <windows.h>
-#endif
-
-namespace quill::detail
-{
-/**
- * C++14 implementation of C++20's remove_cvref
- */
-template <class T>
-struct remove_cvref
-{
-  typedef std::remove_cv_t<std::remove_reference_t<T>> type;
-};
-
-template <class T>
-using remove_cvref_t = typename remove_cvref<T>::type;
-
-template <class>
-constexpr bool always_false_v = false;
-
-constexpr auto strnlen =
-#if defined(__STDC_LIB_EXT1__) || defined(_MSC_VER)
-  ::strnlen_s
-#else
-  ::strnlen
-#endif
-  ;
-
-#if defined(_WIN32)
-/**
- * @brief Convert a wide Unicode string to a UTF-8 encoded string.
- *
- * @param input_string_data Pointer to the wide string data.
- * @param input_string_length Length of the wide string.
- * @return The UTF-8 encoded string.
- *
- * @remarks If the input string is empty or the conversion fails, an empty string is returned.
- */
-inline std::string utf8_encode(std::byte const* data, size_t wide_str_len)
-{
-  // Check if the input is empty
-  if (wide_str_len == 0)
-  {
-    return std::string{};
-  }
-
-  // Create a unique_ptr to hold the buffer and one for the null terminator
-  std::unique_ptr<wchar_t[]> wide_buffer{new wchar_t[wide_str_len + 1]};
-
-  // Because we are using a std::byte* buffer and the data are coming from there we will cast
-  // back the data to char* and then copy them to a wide string buffer before accessing them
-  std::memcpy(wide_buffer.get(), data, wide_str_len * sizeof(wchar_t));
-  wide_buffer[wide_str_len] = L'\0';
-
-  // Calculate the size needed for the UTF-8 string
-  int const size_needed = WideCharToMultiByte(
-    CP_UTF8, 0, wide_buffer.get(), static_cast<int>(wide_str_len), nullptr, 0, nullptr, nullptr);
-
-  // Check for conversion failure
-  if (size_needed == 0)
-  {
-    return std::string{};
-  }
-
-  // Create a buffer to hold the UTF-8 string
-  std::string ret_val(static_cast<size_t>(size_needed), 0);
-
-  // Convert the wide string to UTF-8
-  if (WideCharToMultiByte(CP_UTF8, 0, wide_buffer.get(), static_cast<int>(wide_str_len),
-                          &ret_val[0], size_needed, nullptr, nullptr) == 0)
-  {
-    // conversion failure
-    return std::string{};
-  }
-
-  return ret_val;
-}
-
-inline std::string utf8_encode(std::wstring_view str)
-{
-  return utf8_encode(reinterpret_cast<std::byte const*>(str.data()), str.size());
-}
-#endif
-
-/** typename = void for specializations with enable_if **/
-template <typename Arg, typename = void>
-struct ArgSizeCalculator
-{
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT static size_t calculate(QUILL_MAYBE_UNUSED std::vector<size_t>& conditional_arg_size_cache,
-                                                              QUILL_MAYBE_UNUSED Arg const& arg) noexcept
-  {
-    if constexpr (std::disjunction_v<std::is_arithmetic<Arg>, std::is_enum<Arg>>)
-    {
-      return sizeof(Arg);
-    }
-    else if constexpr (std::conjunction_v<std::is_array<Arg>, std::is_same<remove_cvref_t<std::remove_extent_t<Arg>>, char>>)
-    {
-      size_t constexpr N = std::extent_v<Arg>;
-      conditional_arg_size_cache.push_back(static_cast<size_t>(strnlen(arg, N) + 1u));
-      return conditional_arg_size_cache.back();
-    }
-    else if constexpr (std::disjunction_v<std::is_same<Arg, char*>, std::is_same<Arg, char const*>>)
-    {
-      // include one extra for the zero termination
-      conditional_arg_size_cache.push_back(static_cast<size_t>(strlen(arg) + 1u));
-      return conditional_arg_size_cache.back();
-    }
-    else if constexpr (std::disjunction_v<std::is_same<Arg, std::string>, std::is_same<Arg, std::string_view>>)
-    {
-      // for std::string we also need to store the size in order to correctly retrieve it
-      // the reason for this is that if we create e.g:
-      // std::string msg = fmtquill::format("{} {} {} {} {}", (char)0, (char)0, (char)0, (char)0,
-      // "sssssssssssssssssssssss"); then strlen(msg.data()) = 0 but msg.size() = 31
-      return sizeof(size_t) + arg.length();
-    }
-#if defined(_WIN32)
-    else if constexpr (std::disjunction_v<std::is_same<Arg, wchar_t*>, std::is_same<Arg, wchar_t const*>,
-                                          std::is_same<Arg, std::wstring>, std::is_same<Arg, std::wstring_view>>)
-    {
-      // Calculate the size of the string in bytes
-      size_t len;
-
-      if constexpr (std::disjunction_v<std::is_same<Arg, wchar_t*>, std::is_same<Arg, wchar_t const*>>)
-      {
-        len = wcslen(arg);
-      }
-      else
-      {
-        len = arg.size();
-      }
-
-      conditional_arg_size_cache.push_back(len);
-
-      // also include the size of the string in the buffer as a separate variable
-      // we can retrieve it when we decode. We do not store the null terminator in the buffer
-      return static_cast<size_t>(sizeof(size_t) + (len * sizeof(wchar_t)));
-    }
-#endif
-    else
-    {
-      static_assert(always_false_v<Arg>, "Unsupported type");
-    }
-  }
-};
-
-/**
- * @brief Calculates the total size required to encode the provided arguments
-
- * @param conditional_arg_size_cache Storage to avoid repeating calculations eg. cache strlen
- * @param args The arguments to be encoded.
- * @return The total size required to encode the arguments.
- */
-template <typename... Args>
-QUILL_NODISCARD QUILL_ATTRIBUTE_HOT size_t calculate_args_size_and_populate_string_lengths(
-  QUILL_MAYBE_UNUSED std::vector<size_t>& conditional_arg_size_cache, Args const&... args) noexcept
-{
-  // Do not use fold expression with '+ ...' as we need a guaranteed sequence for the args here
-  size_t total_sum{0};
-  ((total_sum += ArgSizeCalculator<remove_cvref_t<Args>>::calculate(conditional_arg_size_cache, args)), ...);
-  return total_sum;
-}
-
-/** typename = void for specializations with enable_if **/
-template <typename Arg, typename = void>
-struct Encoder
-{
-  QUILL_ATTRIBUTE_HOT static void encode(std::byte*& buffer,
-                                         QUILL_MAYBE_UNUSED std::vector<size_t> const& conditional_arg_size_cache,
-                                         QUILL_MAYBE_UNUSED uint32_t& conditional_arg_size_cache_index,
-                                         Arg const& arg) noexcept
-  {
-    if constexpr (std::disjunction_v<std::is_arithmetic<Arg>, std::is_enum<Arg>>)
-    {
-      std::memcpy(buffer, &arg, sizeof(Arg));
-      buffer += sizeof(Arg);
-    }
-    else if constexpr (std::conjunction_v<std::is_array<Arg>, std::is_same<remove_cvref_t<std::remove_extent_t<Arg>>, char>>)
-    {
-      size_t constexpr N = std::extent_v<Arg>;
-      size_t const len = conditional_arg_size_cache[conditional_arg_size_cache_index++];
-
-      if (QUILL_UNLIKELY(len > N))
-      {
-        // no '\0' in c array
-        assert(len == N + 1);
-        std::memcpy(buffer, arg, N);
-        buffer[len - 1] = std::byte{'\0'};
-      }
-      else
-      {
-        std::memcpy(buffer, arg, len);
-      }
-
-      buffer += len;
-    }
-    else if constexpr (std::disjunction_v<std::is_same<Arg, char*>, std::is_same<Arg, char const*>>)
-    {
-      // null terminator is included in the len for c style strings
-      size_t const len = conditional_arg_size_cache[conditional_arg_size_cache_index++];
-      std::memcpy(buffer, arg, len);
-      buffer += len;
-    }
-    else if constexpr (std::disjunction_v<std::is_same<Arg, std::string>, std::is_same<Arg, std::string_view>>)
-    {
-      // for std::string we store the size first, in order to correctly retrieve it
-      // Copy the length first and then the actual string
-      size_t const len = arg.length();
-      std::memcpy(buffer, &len, sizeof(len));
-
-      if (len != 0)
-      {
-        // copy the string, no need to zero terminate it as we got the length
-        std::memcpy(buffer + sizeof(len), arg.data(), arg.length());
-      }
-
-      buffer += sizeof(len) + len;
-    }
-#if defined(_WIN32)
-    else if constexpr (std::disjunction_v<std::is_same<Arg, wchar_t*>, std::is_same<Arg, wchar_t const*>,
-                                          std::is_same<Arg, std::wstring>, std::is_same<Arg, std::wstring_view>>)
-    {
-      // The wide string size in bytes
-      size_t const len = conditional_arg_size_cache[conditional_arg_size_cache_index++];
-      std::memcpy(buffer, &len, sizeof(len));
-      buffer += sizeof(len);
-
-      if (len != 0)
-      {
-        // copy the string, no need to zero terminate it as we got the length and e.g a wstring_view
-        // might not always be zero terminated
-        size_t const size_in_bytes = len * sizeof(wchar_t);
-
-        if constexpr (std::disjunction_v<std::is_same<Arg, wchar_t*>, std::is_same<Arg, wchar_t const*>>)
-        {
-          std::memcpy(buffer, arg, size_in_bytes);
-        }
-        else
-        {
-          std::memcpy(buffer, arg.data(), size_in_bytes);
-        }
-
-        buffer += size_in_bytes;
-      }
-    }
-#endif
-    else
-    {
-      static_assert(always_false_v<Arg>, "Unsupported type");
-    }
-  }
-};
-
-/**
- * @brief Encoders multiple arguments into a buffer.
- * @param buffer Pointer to the buffer for encoding.
- * @param conditional_arg_size_cache Storage to avoid repeating calculations eg. cache strlen
- * @param args The arguments to be encoded.
- */
-template <typename... Args>
-QUILL_ATTRIBUTE_HOT void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                                Args const&... args) noexcept
-{
-  QUILL_MAYBE_UNUSED uint32_t conditional_arg_size_cache_index{0};
-  (Encoder<remove_cvref_t<Args>>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, args),
-   ...);
-}
-
-/** typename = void for specializations with enable_if **/
-template <typename Arg, typename = void>
-struct Decoder
-{
-  static auto decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    if constexpr (std::disjunction_v<std::is_arithmetic<Arg>, std::is_enum<Arg>>)
-    {
-      Arg arg;
-      std::memcpy(&arg, buffer, sizeof(Arg));
-      buffer += sizeof(Arg);
-
-      if (args_store)
-      {
-        args_store->push_back(arg);
-      }
-
-      return arg;
-    }
-    else if constexpr (std::disjunction_v<std::is_same<Arg, char*>, std::is_same<Arg, char const*>,
-                                          std::conjunction<std::is_array<Arg>, std::is_same<remove_cvref_t<std::remove_extent_t<Arg>>, char>>>)
-    {
-      // c strings or char array
-      char const* str = reinterpret_cast<char const*>(buffer);
-      size_t const len = strlen(str);
-      buffer += len + 1; // for c_strings we add +1 to the length as we also want to copy the null terminated char
-
-      if (args_store)
-      {
-        // pass the std::string_view to args_store to avoid the dynamic allocation
-        args_store->push_back(std::string_view{str, len});
-      }
-
-      return str;
-    }
-    else if constexpr (std::disjunction_v<std::is_same<Arg, std::string>, std::is_same<Arg, std::string_view>>)
-    {
-      // for std::string we first need to retrieve the length
-      size_t len;
-      std::memcpy(&len, buffer, sizeof(len));
-
-      // retrieve the rest of the string
-      char const* str = reinterpret_cast<char const*>(buffer + sizeof(size_t));
-      std::string_view v{str, len};
-      buffer += sizeof(len) + v.length();
-
-      if (args_store)
-      {
-        args_store->push_back(v);
-      }
-
-      return v;
-    }
-#if defined(_WIN32)
-    else if constexpr (std::disjunction_v<std::is_same<Arg, wchar_t*>, std::is_same<Arg, wchar_t const*>,
-                                          std::is_same<Arg, std::wstring>, std::is_same<Arg, std::wstring_view>>)
-    {
-      // we first need to retrieve the length
-      size_t len;
-      std::memcpy(&len, buffer, sizeof(len));
-      buffer += sizeof(len);
-
-      std::wstring_view wstr{reinterpret_cast<wchar_t const*>(buffer), len};
-
-      if (args_store)
-      {
-        std::string str = utf8_encode(buffer, len);
-        args_store->push_back(static_cast<std::string&&>(str));
-      }
-
-      size_t size_bytes = len * sizeof(wchar_t);
-      buffer += size_bytes;
-      return wstr;
-    }
-#endif
-    else
-    {
-      static_assert(always_false_v<Arg>, "Unsupported type");
-    }
-  }
-};
-
-template <typename... Args>
-void decode(std::byte*& buffer, QUILL_MAYBE_UNUSED DynamicFormatArgStore* args_store) noexcept
-{
-  (Decoder<Args>::decode(buffer, args_store), ...);
-}
-
-/**
- * Decoder functions
- */
-using FormatArgsDecoder = void (*)(std::byte*& data, DynamicFormatArgStore& args_store);
-
-template <typename... Args>
-void decode_and_populate_format_args(std::byte*& buffer, DynamicFormatArgStore& args_store)
-{
-  args_store.clear();
-  decode<Args...>(buffer, &args_store);
-}
-
-/** Codec helpers for user defined types convenience **/
-/***/
-template <typename... TMembers>
-size_t calculate_total_size(std::vector<size_t>& conditional_arg_size_cache, TMembers const&... members)
-{
-  size_t total_size{0};
-  ((total_size += ArgSizeCalculator<remove_cvref_t<TMembers>>::calculate(conditional_arg_size_cache, members)), ...);
-  return total_size;
-}
-
-/***/
-template <typename... TMembers>
-void encode_members(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                    uint32_t& conditional_arg_size_cache_index, TMembers const&... members)
-{
-  ((Encoder<remove_cvref_t<TMembers>>::encode(buffer, conditional_arg_size_cache,
-                                              conditional_arg_size_cache_index, members)),
-   ...);
-}
-
-/***/
-template <typename T, typename... TMembers>
-void decode_and_assign_members(std::byte*& buffer, DynamicFormatArgStore* args_store, T& arg, TMembers&... members)
-{
-  ((members = Decoder<remove_cvref_t<TMembers>>::decode(buffer, nullptr)), ...);
-
-  if (args_store)
-  {
-    args_store->push_back(arg);
-  }
-}
-} // namespace quill::detail
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/Common.h b/subprojects/quill-4.2.0/quill/include/quill/core/Common.h
deleted file mode 100644
index 33b0a98..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/Common.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-#include <string>
-
-/**
- * Convert number to string
- */
-#define QUILL_AS_STR(x) #x
-#define QUILL_STRINGIFY(x) QUILL_AS_STR(x)
-
-namespace quill
-{
-namespace detail
-{
-/**
- * Cache line size
- */
-static constexpr size_t CACHE_LINE_SIZE{64u};
-static constexpr size_t CACHE_LINE_ALIGNED{2 * CACHE_LINE_SIZE};
-} // namespace detail
-
-/**
- * Enum to select a queue type
- */
-enum class QueueType
-{
-  UnboundedBlocking,
-  UnboundedDropping,
-  UnboundedUnlimited,
-  BoundedBlocking,
-  BoundedDropping
-};
-
-/**
- * Enum to select a timezone
- */
-enum class Timezone : uint8_t
-{
-  LocalTime,
-  GmtTime
-};
-
-/**
- * Enum for the used clock type
- */
-enum class ClockSourceType : uint8_t
-{
-  Tsc,
-  System,
-  User
-};
-
-#if defined(__clang__)
-  #pragma clang diagnostic push
-  #pragma clang diagnostic ignored "-Wnon-virtual-dtor"
-#elif defined(__GNUC__)
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
-#elif defined(_WIN32)
-  #pragma warning(push)
-  #pragma warning(disable : 4265) // Disable warning about non-virtual destructor in MSVC
-#endif
-
-/**
- * Tags class that can be used for _WITH_TAGS log macros
- */
-class Tags
-{
-public:
-  constexpr Tags() = default;
-  virtual void format(std::string&) const = 0;
-};
-
-#if defined(__clang__)
-  #pragma clang diagnostic pop
-#elif defined(__GNUC__)
-  #pragma GCC diagnostic pop
-#elif defined(_WIN32)
-  #pragma warning(pop)
-#endif
-
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/DynamicFormatArgStore.h b/subprojects/quill-4.2.0/quill/include/quill/core/DynamicFormatArgStore.h
deleted file mode 100644
index 8ac1f56..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/DynamicFormatArgStore.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include <memory>
-#include <string>
-#include <string_view>
-#include <type_traits>
-#include <vector>
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/core/Attributes.h"
-
-namespace quill::detail
-{
-class DynamicArgList
-{
-  struct Node
-  {
-    virtual ~Node() = default;
-    std::unique_ptr<Node> next;
-  };
-
-  template <typename T>
-  struct TypedNode : Node
-  {
-    template <typename Arg>
-    explicit TypedNode(Arg const& arg) : value(arg)
-    {
-    }
-
-    T value;
-  };
-
-  std::unique_ptr<Node> _head;
-
-public:
-  template <typename T, typename Arg>
-  T const& push(Arg const& arg)
-  {
-    auto new_node = std::unique_ptr<TypedNode<T>>(new TypedNode<T>(arg));
-    T& value = new_node->value;
-    new_node->next = std::move(_head);
-    _head = std::move(new_node);
-    return value;
-  }
-};
-
-/**
- * Similar to fmt::dynamic_arg_store but better suited to our needs
- * e.g does not include <functional> and requires less space
- */
-class DynamicFormatArgStore
-{
-private:
-  // Storage of basic_format_arg must be contiguous.
-  std::vector<fmtquill::basic_format_arg<fmtquill::format_context>> _data;
-
-  // Storage of arguments not fitting into basic_format_arg must grow
-  // without relocation because items in data_ refer to it.
-  DynamicArgList _dynamic_arg_list;
-
-  template <typename T>
-  void emplace_arg(T const& arg)
-  {
-    _data.emplace_back(fmtquill::detail::make_arg<fmtquill::format_context>(arg));
-  }
-
-public:
-  DynamicFormatArgStore() = default;
-
-  QUILL_NODISCARD unsigned long long get_types() const
-  {
-    return fmtquill::detail::is_unpacked_bit | _data.size();
-  }
-
-  QUILL_NODISCARD fmtquill::basic_format_arg<fmtquill::format_context> const* data() const
-  {
-    return _data.data();
-  }
-
-  /**
-    Adds an argument for later passing to a formatting function.
-
-    **Example**::
-
-      fmtquill::dynamic_format_arg_store<fmtquill::format_fmtquill::format_context> store;
-      store.push_back(42);
-      store.push_back("abc");
-      store.push_back(1.5f);
-      std::string result = fmtquill::vformat("{} and {} and {}", store);
-  */
-  template <typename T>
-  void push_back(T const& arg)
-  {
-    constexpr auto mapped_type = fmtquill::detail::mapped_type_constant<T, fmtquill::format_context>::value;
-    using stored_type = std::conditional_t<std::is_convertible_v<T, std::string>, std::string, T>;
-
-    if constexpr (!(std::is_same_v<std::remove_cv_t<std::remove_reference_t<T>>, std::string_view> ||
-                    (mapped_type != fmtquill::detail::type::cstring_type &&
-                     mapped_type != fmtquill::detail::type::string_type &&
-                     mapped_type != fmtquill::detail::type::custom_type)))
-    {
-      emplace_arg(_dynamic_arg_list.push<stored_type>(arg));
-    }
-    else
-    {
-      emplace_arg(arg);
-    }
-  }
-
-  /** Erase all elements from the store */
-  void clear()
-  {
-    _data.clear();
-    _dynamic_arg_list = DynamicArgList{};
-  }
-};
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/Filesystem.h b/subprojects/quill-4.2.0/quill/include/quill/core/Filesystem.h
deleted file mode 100644
index 97c7e73..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/Filesystem.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#if !defined(QUILL_HAS_FILESYSTEM) && !defined(QUILL_HAS_EXPERIMENTAL_FILESYSTEM)
-  #if defined(__cpp_lib_filesystem)
-    #define QUILL_HAS_FILESYSTEM 1
-  #elif defined(__cpp_lib_experimental_filesystem)
-    #define QUILL_HAS_EXPERIMENTAL_FILESYSTEM 1
-  #elif !defined(__has_include)
-    #define QUILL_HAS_EXPERIMENTAL_FILESYSTEM 1
-  #elif __has_include(<filesystem>)
-    #define QUILL_HAS_FILESYSTEM 1
-  #elif __has_include(<experimental/filesystem>)
-    #define QUILL_HAS_EXPERIMENTAL_FILESYSTEM 1
-  #endif
-
-  // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
-  #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
-    #undef QUILL_HAS_FILESYSTEM
-    #undef QUILL_HAS_EXPERIMENTAL_FILESYSTEM
-  #endif
-
-  // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support
-  #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
-    #undef QUILL_HAS_FILESYSTEM
-  // #undef QUILL_HAS_EXPERIMENTAL_FILESYSTEM
-  #endif
-
-  // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support
-  #if defined(__clang_major__) && __clang_major__ < 7
-    #undef QUILL_HAS_FILESYSTEM
-    #undef QUILL_HAS_EXPERIMENTAL_FILESYSTEM
-  #endif
-#endif
-
-#ifndef QUILL_HAS_EXPERIMENTAL_FILESYSTEM
-  #define QUILL_HAS_EXPERIMENTAL_FILESYSTEM 0
-#endif
-
-#ifndef QUILL_HAS_FILESYSTEM
-  #define QUILL_HAS_FILESYSTEM 0
-#endif
-
-#if QUILL_HAS_EXPERIMENTAL_FILESYSTEM
-  #include <experimental/filesystem>
-
-namespace quill
-{
-namespace fs = std::experimental::filesystem;
-} // namespace quill
-
-#elif QUILL_HAS_FILESYSTEM
-  #include <filesystem>
-
-namespace quill
-{
-namespace fs = std::filesystem;
-} // namespace quill
-#endif
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/FormatBuffer.h b/subprojects/quill-4.2.0/quill/include/quill/core/FormatBuffer.h
deleted file mode 100644
index 8303634..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/FormatBuffer.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/bundled/fmt/core.h"
-
-#include <cstddef>
-#include <memory>
-#include <string>
-
-namespace quill::detail
-{
-/**
- * This is a replication of fmt::basic_memory_buffer with only dynamic storage
- */
-class FormatBuffer final : public fmtquill::detail::buffer<char>
-{
-public:
-  using value_type = char;
-  using const_reference = char const&;
-
-  FormatBuffer() { this->set(nullptr, 0); }
-
-  ~FormatBuffer() noexcept { _deallocate(); }
-
-  FormatBuffer(FormatBuffer&& other) noexcept { _move(other); }
-
-  FormatBuffer& operator=(FormatBuffer&& other) noexcept
-  {
-    FMTQUILL_ASSERT(this != &other, "");
-    _deallocate();
-    _move(other);
-    return *this;
-  }
-
-  void resize(size_t count) { this->try_resize(count); }
-
-  void reserve(size_t new_capacity) { this->try_reserve(new_capacity); }
-
-  void append(std::string const& str) { append(str.data(), str.data() + str.size()); }
-
-  void append(char const* begin, char const* end)
-  {
-    while (begin != end)
-    {
-      auto count = fmtquill::detail::to_unsigned(end - begin);
-      this->try_reserve(size_ + count);
-
-      auto free_cap = capacity_ - size_;
-      if (free_cap < count)
-      {
-        count = free_cap;
-      }
-
-      std::uninitialized_copy_n(begin, count, ptr_ + size_);
-      size_ += count;
-      begin += count;
-    }
-  }
-
-private:
-  // Move data from other to this buffer.
-  void _move(FormatBuffer& other)
-  {
-    this->set(other.data(), other.capacity());
-    this->resize(other.size());
-
-    // Set pointer to the inline array so that delete is not called
-    // when deallocating.
-    other.set(nullptr, 0);
-    other.clear();
-  }
-
-  // Deallocate memory allocated by the buffer.
-  void _deallocate()
-  {
-    if (this->data())
-    {
-      delete[] this->data();
-    }
-  }
-
-protected:
-  void grow(size_t size) override
-  {
-    size_t const old_capacity = this->capacity();
-    size_t new_capacity = old_capacity * 2;
-
-    if (size > new_capacity)
-    {
-      new_capacity = size;
-    }
-
-    char* old_data = this->data();
-    char* new_data = new char[new_capacity];
-
-    // The following code doesn't throw, so the raw pointer above doesn't leak.
-    std::uninitialized_copy_n(old_data, this->size(), new_data);
-    this->set(new_data, new_capacity);
-
-    if (old_data)
-    {
-      delete[] old_data;
-    }
-  }
-};
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/FrontendOptions.h b/subprojects/quill-4.2.0/quill/include/quill/core/FrontendOptions.h
deleted file mode 100644
index 71c0e6c..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/FrontendOptions.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Common.h"
-#include <cstdint>
-
-namespace quill
-{
-struct FrontendOptions
-{
-  /**
-   * Each frontend thread has its own queue, which can be configured with various options:
-   * - UnboundedBlocking: Starts with initial_queue_capacity and reallocates up to 2GB, then blocks.
-   * - UnboundedDropping: Starts with initial_queue_capacity and reallocates up to 2GB, then drops log messages.
-   * - UnboundedUnlimited: Starts with initial_queue_capacity and reallocates up to 2GB; subsequent queues are reallocated as needed. Never blocks or drops.
-   * - BoundedBlocking: Starts with initial_queue_capacity and never reallocates; blocks when the limit is reached.
-   * - BoundedDropping: Starts with initial_queue_capacity and never reallocates; drops log messages when the limit is reached.
-   *
-   * By default, the library uses an UnboundedBlocking queue, which starts with initial_queue_capacity.
-   */
-  static constexpr quill::QueueType queue_type = quill::QueueType::UnboundedBlocking;
-
-  /**
-   * Initial capacity of the queue. Used for UnboundedBlocking, UnboundedDropping, and
-   * UnboundedUnlimited. Also serves as the capacity for BoundedBlocking and BoundedDropping.
-   */
-  static constexpr uint32_t initial_queue_capacity = 131'072;
-
-  /**
-   * Interval for retrying when using BoundedBlocking or UnboundedBlocking.
-   * Applicable only when using BoundedBlocking or UnboundedBlocking.
-   */
-  static constexpr uint32_t blocking_queue_retry_interval_ns = 800;
-
-  /**
-   * Enables huge pages on the frontend queues to reduce TLB misses. Available only for Linux.
-   */
-  static constexpr bool huge_pages_enabled = false;
-};
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/LogLevel.h b/subprojects/quill-4.2.0/quill/include/quill/core/LogLevel.h
deleted file mode 100644
index 9635a51..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/LogLevel.h
+++ /dev/null
@@ -1,156 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/QuillError.h"
-
-#include <cctype>
-#include <cstdint>
-#include <string>
-#include <string_view>
-
-namespace quill
-{
-/**
- * Log level enum
- */
-enum class LogLevel : uint8_t
-{
-  TraceL3,
-  TraceL2,
-  TraceL1,
-  Debug,
-  Info,
-  Warning,
-  Error,
-  Critical,
-  Backtrace, /**< This is only used for backtrace logging. Should not be set by the user. */
-  None,
-  Dynamic /**< This is only used for dynamic logging. Should not be set by the user. */
-};
-
-namespace detail
-{
-QUILL_NODISCARD QUILL_ATTRIBUTE_HOT inline std::string_view _get_log_level_string(
-  LogLevel log_level, std::string_view const* log_levels_map, uint32_t log_levels_map_size)
-{
-  auto const log_lvl = static_cast<uint32_t>(log_level);
-
-  if (QUILL_UNLIKELY(log_lvl >= log_levels_map_size))
-  {
-    std::string const error_msg = "Invalid get_log_level value \"" + std::to_string(log_lvl) + "\"";
-    QUILL_THROW(QuillError{error_msg});
-  }
-
-  return log_levels_map[log_lvl];
-}
-} // namespace detail
-
-/**
- * Converts a LogLevel enum to string
- * @param log_level LogLevel
- * @return the corresponding string value
- */
-QUILL_NODISCARD QUILL_ATTRIBUTE_HOT inline std::string_view loglevel_to_string(LogLevel log_level)
-{
-  static constexpr std::string_view log_levels_map[] = {
-    "TRACE_L3", "TRACE_L2", "TRACE_L1",  "DEBUG", "INFO",   "WARNING",
-    "ERROR",    "CRITICAL", "BACKTRACE", "NONE",  "DYNAMIC"};
-
-  static constexpr uint32_t log_levels_map_size = sizeof(log_levels_map) / sizeof(log_levels_map[0]);
-
-  return detail::_get_log_level_string(log_level, log_levels_map, log_levels_map_size);
-}
-
-/**
- * Converts a LogLevel enum to string id
- * @param log_level LogLevel
- * @return the corresponding string id
- */
-QUILL_NODISCARD QUILL_ATTRIBUTE_HOT inline std::string_view loglevel_to_string_id(LogLevel log_level)
-{
-  static constexpr std::string_view log_levels_map[] = {"T3", "T2", "T1", "D", "I", "W",
-                                                        "E",  "C",  "BT", "N", "DN"};
-
-  static constexpr uint32_t log_levels_map_size = sizeof(log_levels_map) / sizeof(log_levels_map[0]);
-
-  return detail::_get_log_level_string(log_level, log_levels_map, log_levels_map_size);
-}
-
-/**
- * Converts a string to a LogLevel enum value
- * @param log_level the log level string to convert
- * "tracel3", "tracel2", "tracel1", "debug", "info", "warning", "error", "backtrace", "none"
- * @return the corresponding LogLevel enum value
- */
-QUILL_NODISCARD LogLevel inline loglevel_from_string(std::string log_level)
-{
-  // Convert to lowercase
-  for (char& c : log_level)
-  {
-    c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-  }
-
-  if (log_level == "tracel3" || log_level == "trace_l3")
-  {
-    return LogLevel::TraceL3;
-  }
-
-  if (log_level == "tracel2" || log_level == "trace_l2")
-  {
-    return LogLevel::TraceL2;
-  }
-
-  if (log_level == "tracel1" || log_level == "trace_l1")
-  {
-    return LogLevel::TraceL1;
-  }
-
-  if (log_level == "debug")
-  {
-    return LogLevel::Debug;
-  }
-
-  if (log_level == "info")
-  {
-    return LogLevel::Info;
-  }
-
-  if (log_level == "warning")
-  {
-    return LogLevel::Warning;
-  }
-
-  if (log_level == "error")
-  {
-    return LogLevel::Error;
-  }
-
-  if (log_level == "critical")
-  {
-    return LogLevel::Critical;
-  }
-
-  if (log_level == "backtrace")
-  {
-    return LogLevel::Backtrace;
-  }
-
-  if (log_level == "none")
-  {
-    return LogLevel::None;
-  }
-
-  if (log_level == "dynamic")
-  {
-    return LogLevel::Dynamic;
-  }
-
-  std::string const error_msg = "LogLevel enum value does not exist for \"" + log_level + "\"";
-  QUILL_THROW(QuillError{error_msg});
-}
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/LoggerBase.h b/subprojects/quill-4.2.0/quill/include/quill/core/LoggerBase.h
deleted file mode 100644
index e8a4798..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/LoggerBase.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/LogLevel.h"
-
-#include <atomic>
-#include <cassert>
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace quill
-{
-/** Forward Declarations **/
-class Sink;
-class PatternFormatter;
-class UserClockSource;
-
-namespace detail
-{
-class BackendWorker;
-
-/***/
-class LoggerBase
-{
-public:
-  /***/
-  LoggerBase(std::string logger_name, std::vector<std::shared_ptr<Sink>> sinks,
-             std::string format_pattern, std::string time_pattern, Timezone timezone,
-             ClockSourceType clock_source, UserClockSource* user_clock)
-    : format_pattern(static_cast<std::string&&>(format_pattern)),
-      time_pattern(static_cast<std::string&&>(time_pattern)),
-      logger_name(static_cast<std::string&&>(logger_name)),
-      user_clock(user_clock),
-      timezone(timezone),
-      clock_source(clock_source)
-  {
-#ifndef NDEBUG
-    for (auto const& sink : sinks)
-    {
-      assert(sink && "sink pointer is nullptr");
-    }
-#endif
-
-    this->sinks = static_cast<std::vector<std::shared_ptr<Sink>>&&>(sinks);
-  }
-
-  /***/
-  LoggerBase(LoggerBase const&) = delete;
-  LoggerBase& operator=(LoggerBase const&) = delete;
-
-  /***/
-  virtual ~LoggerBase() = default;
-
-  /**
-   * Returns the name of the logger.
-   * @return A constant reference to the logger's name.
-   */
-  QUILL_NODISCARD std::string const& get_logger_name() const noexcept { return logger_name; }
-
-  /**
-   * This function sets the logger's validity flag to false, indicating that the logger is no longer valid.
-   */
-  void mark_invalid() { valid.store(false, std::memory_order_release); }
-
-  /**
-   * @brief Checks if the logger is valid.
-   * @return True if the logger is valid, false otherwise.
-   */
-  QUILL_NODISCARD bool is_valid_logger() const noexcept
-  {
-    return valid.load(std::memory_order_acquire);
-  }
-
-  /**
-   * @return The log level of the logger
-   */
-  QUILL_NODISCARD LogLevel get_log_level() const noexcept
-  {
-    return log_level.load(std::memory_order_relaxed);
-  }
-
-  /**
-   * Set the log level of the logger
-   * @param new_log_level The new log level
-   */
-  void set_log_level(LogLevel new_log_level)
-  {
-    if (QUILL_UNLIKELY(new_log_level == LogLevel::Backtrace))
-    {
-      QUILL_THROW(QuillError{"LogLevel::Backtrace is only used internally. Please don't use it."});
-    }
-
-    log_level.store(new_log_level, std::memory_order_relaxed);
-  }
-
-  /**
-   * Checks if the given log_statement_level can be logged by this logger
-   * @return bool if a message can be logged based on the current log level
-   */
-  template <LogLevel log_statement_level>
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT bool should_log_message() const noexcept
-  {
-    return log_statement_level >= get_log_level();
-  }
-
-  /**
-   * Checks if the given log_statement_level can be logged by this logger
-   * @param log_statement_level The log level of the log statement to be logged
-   * @return bool if a message can be logged based on the current log level
-   */
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT bool should_log_message(LogLevel log_statement_level) const noexcept
-  {
-    return log_statement_level >= get_log_level();
-  }
-
-protected:
-  friend class detail::BackendWorker;
-
-  std::shared_ptr<PatternFormatter> pattern_formatter; /* The backend thread will set this once, we never access it on the frontend */
-  std::string format_pattern; /* Set by the frontend and accessed by the backend to initialise PatternFormatter */
-  std::string time_pattern; /* Set by the frontend and accessed by the backend to initialise PatternFormatter */
-  std::string logger_name; /* Set by the frontend, accessed by the frontend AND backend */
-  std::vector<std::shared_ptr<Sink>> sinks; /* Set by the frontend and accessed by the backend */
-  UserClockSource* user_clock{nullptr}; /* A non owned pointer to a custom timestamp clock, valid only when provided. used by frontend only */
-  Timezone timezone; /* Set by the frontend and accessed by the backend to initialise PatternFormatter */
-  ClockSourceType clock_source; /* Set by the frontend and accessed by the frontend AND backend */
-
-  std::atomic<LogLevel> log_level{LogLevel::Info}; /* used by frontend only */
-  std::atomic<LogLevel> backtrace_flush_level{LogLevel::None}; /** Updated by the frontend at any time, accessed by the backend */
-  std::atomic<bool> valid{true}; /* Updated by the frontend at any time, accessed by the backend */
-};
-} // namespace detail
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/LoggerManager.h b/subprojects/quill-4.2.0/quill/include/quill/core/LoggerManager.h
deleted file mode 100644
index ed669e4..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/LoggerManager.h
+++ /dev/null
@@ -1,223 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/LoggerBase.h"
-
-#include <algorithm>
-#include <atomic>
-#include <cassert>
-#include <initializer_list>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <vector>
-
-namespace quill
-{
-/** Forward Declarations **/
-class Sink;
-class UserClockSource;
-
-namespace detail
-{
-class LoggerManager
-{
-public:
-  LoggerManager(LoggerManager const&) = delete;
-  LoggerManager& operator=(LoggerManager const&) = delete;
-
-  /***/
-  static LoggerManager& instance() noexcept
-  {
-    static LoggerManager instance;
-    return instance;
-  }
-
-  /***/
-  QUILL_NODISCARD LoggerBase* get_logger(std::string const& logger_name) const
-  {
-    std::lock_guard<std::recursive_mutex> const lock{_mutex};
-    LoggerBase* logger = _find_logger(logger_name);
-    return logger && logger->is_valid_logger() ? logger : nullptr;
-  }
-
-  /***/
-  QUILL_NODISCARD std::vector<LoggerBase*> get_all_loggers() const
-  {
-    std::lock_guard<std::recursive_mutex> const lock{_mutex};
-
-    std::vector<LoggerBase*> loggers;
-
-    for (auto const& elem : _loggers)
-    {
-      // we can not add invalidated loggers as they can be removed at any time
-      if (elem->is_valid_logger())
-      {
-        loggers.push_back(elem.get());
-      }
-    }
-
-    return loggers;
-  }
-
-  /***/
-  QUILL_NODISCARD LoggerBase* get_valid_logger() const
-  {
-    // Retrieves any valid logger without the need for constructing a vector
-    std::lock_guard<std::recursive_mutex> const lock{_mutex};
-
-    for (auto const& elem : _loggers)
-    {
-      // we can not add invalidated loggers as they can be removed at any time
-      if (elem->is_valid_logger())
-      {
-        return elem.get();
-      }
-    }
-
-    return nullptr;
-  }
-
-  /***/
-  QUILL_NODISCARD size_t get_number_of_loggers() const noexcept
-  {
-    std::lock_guard<std::recursive_mutex> const lock{_mutex};
-    return _loggers.size();
-  }
-
-  /**
-   * For backend use only
-   */
-  template <typename TCallback>
-  void for_each_logger(TCallback cb) const
-  {
-    std::lock_guard<std::recursive_mutex> const lock{_mutex};
-
-    for (auto const& elem : _loggers)
-    {
-      // Here we do not check for valid_logger() like in get_all_loggers() because this
-      // function is only called by the backend
-      cb(elem.get());
-    }
-  }
-
-  /***/
-  template <typename TLogger>
-  LoggerBase* create_or_get_logger(std::string const& logger_name, std::vector<std::shared_ptr<Sink>> sinks,
-                                   std::string const& format_pattern,
-                                                   std::string const& time_pattern, Timezone timestamp_timezone,
-                                                   ClockSourceType clock_source, UserClockSource* user_clock)
-  {
-    std::lock_guard<std::recursive_mutex> const lock{_mutex};
-
-    LoggerBase* logger_ptr = _find_logger(logger_name);
-
-    if (!logger_ptr)
-    {
-      // If logger pointer is null, create a new logger instance.
-      std::unique_ptr<LoggerBase> new_logger{new TLogger{logger_name, static_cast<std::vector<std::shared_ptr<Sink>>&&>(sinks),
-                    format_pattern, time_pattern, timestamp_timezone, clock_source, user_clock}};
-
-      _insert_logger(static_cast<std::unique_ptr<LoggerBase>&&>(new_logger));
-
-      // Although we could directly return .get() from the new_logger here,
-      // we retain this portion of code for additional safety in case of potential re-lookup of
-      // the logger. This section is not performance-critical.
-      logger_ptr = _find_logger(logger_name);
-    }
-
-    assert(logger_ptr);
-    assert(logger_ptr->is_valid_logger());
-    return logger_ptr;
-  }
-
-  /***/
-  void remove_logger(LoggerBase* logger)
-  {
-    logger->mark_invalid();
-    _has_invalidated_loggers.store(true, std::memory_order_release);
-  }
-
-  /***/
-  template <typename TCheckQueuesEmpty>
-  QUILL_NODISCARD std::vector<std::string> cleanup_invalidated_loggers(TCheckQueuesEmpty check_queues_empty)
-  {
-    std::vector<std::string> removed_loggers;
-
-    if (_has_invalidated_loggers.load(std::memory_order_acquire))
-    {
-      _has_invalidated_loggers.store(false, std::memory_order_release);
-
-      std::lock_guard<std::recursive_mutex> const lock{_mutex};
-      for (auto it = _loggers.begin(); it != _loggers.end();)
-      {
-        if (!it->get()->is_valid_logger())
-        {
-          // invalid logger, check if the logger has any pending records in the queue
-          if (!check_queues_empty())
-          {
-            // we have pending records in the queue, we can not remove the logger yet
-            ++it;
-            _has_invalidated_loggers.store(true, std::memory_order_release);
-          }
-          else
-          {
-            removed_loggers.push_back(it->get()->get_logger_name());
-            it = _loggers.erase(it);
-          }
-        }
-        else
-        {
-          ++it;
-        }
-      }
-    }
-
-    return removed_loggers;
-  }
-
-  /***/
-  QUILL_NODISCARD bool has_invalidated_loggers() const noexcept
-  {
-    return _has_invalidated_loggers.load(std::memory_order_acquire);
-  }
-
-private:
-  LoggerManager() = default;
-  ~LoggerManager() = default;
-
-  /***/
-  void _insert_logger(std::unique_ptr<LoggerBase> logger)
-  {
-    auto search_it = std::lower_bound(_loggers.begin(), _loggers.end(), logger->get_logger_name(),
-                                      [](std::unique_ptr<LoggerBase> const& a, std::string const& b)
-                                      { return a->get_logger_name() < b; });
-
-    _loggers.insert(search_it, static_cast<std::unique_ptr<LoggerBase>&&>(logger));
-  }
-
-  /***/
-  QUILL_NODISCARD LoggerBase* _find_logger(std::string const& target) const noexcept
-  {
-    auto search_it = std::lower_bound(_loggers.begin(), _loggers.end(), target,
-                                      [](std::unique_ptr<LoggerBase> const& a, std::string const& b)
-                                      { return a->get_logger_name() < b; });
-
-    return (search_it != std::end(_loggers) && search_it->get()->get_logger_name() == target)
-      ? search_it->get()
-      : nullptr;
-  }
-
-private:
-  std::vector<std::unique_ptr<LoggerBase>> _loggers;
-  mutable std::recursive_mutex _mutex;
-  std::atomic<bool> _has_invalidated_loggers{false};
-};
-} // namespace detail
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/MacroMetadata.h b/subprojects/quill-4.2.0/quill/include/quill/core/MacroMetadata.h
deleted file mode 100644
index f013eec..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/MacroMetadata.h
+++ /dev/null
@@ -1,220 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/LogLevel.h"
-
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <string_view>
-
-namespace quill
-{
-/**
- * Captures and stores information about a logging event in compile time
- */
-class MacroMetadata
-{
-public:
-  enum Event : uint8_t
-  {
-    Log,
-    InitBacktrace,
-    FlushBacktrace,
-    Flush
-  };
-
-  constexpr MacroMetadata(char const* source_location, char const* caller_function, char const* message_format, Tags const* tags, LogLevel log_level, Event event) noexcept
-    : _source_location(source_location),
-      _caller_function(caller_function),
-      _message_format(message_format),
-      _tags(tags),
-      _colon_separator_pos(_calc_colon_separator_pos()),
-      _file_name_pos(_calc_file_name_pos()),
-      _log_level(log_level),
-      _event(event)
-  {
-    _set_named_args_flag(_contains_named_args(message_format));
-  }
-
-  QUILL_NODISCARD char const* source_location() const noexcept { return _source_location; }
-
-  QUILL_NODISCARD char const* caller_function() const noexcept { return _caller_function; }
-
-  QUILL_NODISCARD char const* message_format() const noexcept
-  { return _message_format; }
-
-  QUILL_NODISCARD char const* line() const noexcept
-  {
-    return _source_location + _colon_separator_pos + 1;
-  }
-
-  QUILL_NODISCARD std::string_view full_path() const noexcept
-  {
-    return std::string_view{_source_location, _colon_separator_pos};
-  }
-
-  QUILL_NODISCARD std::string_view file_name() const noexcept
-  {
-    return std::string_view{_source_location + _file_name_pos,
-                            static_cast<size_t>(_colon_separator_pos - _file_name_pos)};
-  }
-
-  QUILL_NODISCARD char const* short_source_location() const noexcept
-  {
-    return _source_location + _file_name_pos;
-  }
-
-  QUILL_NODISCARD LogLevel log_level() const noexcept { return _log_level; }
-
-  QUILL_NODISCARD std::string_view log_level_string() const noexcept
-  {
-    return quill::loglevel_to_string(_log_level);
-  }
-
-  QUILL_NODISCARD std::string_view log_level_id() const noexcept
-  {
-    return quill::loglevel_to_string_id(_log_level);
-  }
-
-  QUILL_NODISCARD Tags const* tags() const noexcept { return _tags; }
-
-  QUILL_NODISCARD bool has_named_args() const noexcept {
-    return _format_flags & NAMED_ARGS_FLAG;
-  }
-
-  QUILL_NODISCARD Event event() const noexcept { return _event; }
-
-private:
-  /***/
-  QUILL_NODISCARD constexpr uint16_t _calc_file_name_pos() const noexcept
-  {
-    char const* source_location = _source_location;
-    char const* file = source_location;
-    while (*source_location)
-    {
-      char cur = *source_location++;
-      if (cur == '/' || cur == PATH_PREFERRED_SEPARATOR)
-      {
-        file = source_location;
-      }
-    }
-    return static_cast<uint16_t>(file - _source_location);
-  }
-
-  /***/
-  QUILL_NODISCARD constexpr uint16_t _calc_colon_separator_pos() const noexcept
-  {
-    std::string_view source_loc{_source_location};
-    auto const separator_index = source_loc.rfind(':');
-    return static_cast<uint16_t>(separator_index);
-  }
-
-  /***/
-  constexpr void _set_named_args_flag(bool value) noexcept
-  {
-    if (value)
-    {
-      _format_flags |= NAMED_ARGS_FLAG;
-    }
-    else
-    {
-      _format_flags &= static_cast<uint8_t>(~NAMED_ARGS_FLAG);
-    }
-  }
-
-  /***/
-  constexpr bool _contains_named_args(std::string_view fmt) noexcept
-  {
-    uint32_t pos{0};
-    bool found_named_arg{false};
-
-    // Iterates the format string and checks if any characters are contained inside `{}`
-    while (pos < fmt.length())
-    {
-      if (fmt[pos] == '{')
-      {
-        ++pos; // consume {
-        if (pos >= fmt.length())
-        {
-          break;
-        }
-
-        // first character after the {
-        auto const fc = fmt[pos];
-        if (fc == '{')
-        {
-          // this means first '{' was escaped, so we ignore both of them
-          ++pos;
-          continue;
-        }
-
-        // else look for the next '}'
-        uint32_t char_cnt{0};
-        while (pos < fmt.length())
-        {
-          if (fmt[pos] == '}')
-          {
-            ++pos; // consume }
-            if (pos >= fmt.length())
-            {
-              break;
-            }
-
-            if (fmt[pos] == '}')
-            {
-              // this means first '}', was escaped ignore it
-              ++pos;
-              ++char_cnt;
-              continue;
-            }
-
-            // we found '{' match, we can break
-            break;
-          }
-
-          ++pos;
-          ++char_cnt;
-        }
-
-        if ((char_cnt != 0) && ((fc >= 'a' && fc <= 'z') || (fc >= 'A' && fc <= 'Z')))
-        {
-          found_named_arg = true;
-        }
-      }
-      ++pos;
-    }
-
-    return found_named_arg;
-  }
-
-private:
-  // define our own PATH_PREFERRED_SEPARATOR to not include <filesystem>
-#if defined(_WIN32) && !defined(__CYGWIN__)
-  static constexpr wchar_t PATH_PREFERRED_SEPARATOR = L'\\';
-#else
-  static constexpr char PATH_PREFERRED_SEPARATOR = '/';
-#endif
-
-  static constexpr uint8_t NAMED_ARGS_FLAG = 0x01;
-
-  char const* _source_location;
-  char const* _caller_function;
-  char const* _message_format;
-  Tags const* _tags;
-  uint16_t _colon_separator_pos;
-  uint16_t _file_name_pos;
-  LogLevel _log_level;
-  Event _event;
-  uint8_t _format_flags{0};
-};
-
-static_assert(sizeof(MacroMetadata) <= detail::CACHE_LINE_SIZE,
-              "Size of MacroMetadata exceeds the cache line size");
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/MathUtils.h b/subprojects/quill-4.2.0/quill/include/quill/core/MathUtils.h
deleted file mode 100644
index bb1e057..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/MathUtils.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-
-#include <cassert>
-#include <cstdint>
-#include <limits>
-
-namespace quill::detail
-{
-/**
- * Check if a number is a power of 2
- * @param number the number to check against
- * @return true if the number is power of 2
- *         false otherwise
- */
-QUILL_NODISCARD constexpr bool is_power_of_two(uint64_t number) noexcept
-{
-  return (number != 0) && ((number & (number - 1)) == 0);
-}
-
-/**
- * Round up to the next power of 2
- * @param n input
- * @return the next power of 2
- */
-template <typename T>
-QUILL_NODISCARD T next_power_of_two(T n)
-{
-  constexpr T max_power_of_2 = (std::numeric_limits<T>::max() >> 1) + 1;
-
-  if (n >= max_power_of_2)
-  {
-    return max_power_of_2;
-  }
-
-  if (is_power_of_two(static_cast<uint64_t>(n)))
-  {
-    return n;
-  }
-
-  T result = 1;
-  while (result < n)
-  {
-    result <<= 1;
-  }
-
-  assert(is_power_of_two(static_cast<uint64_t>(result)) && "result is not a power of 2");
-
-  return result;
-}
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/QuillError.h b/subprojects/quill-4.2.0/quill/include/quill/core/QuillError.h
deleted file mode 100644
index ab77667..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/QuillError.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-
-#include <exception>
-#include <string>
-
-/**
- * Require check
- */
-#define QUILL_REQUIRE(expression, error)                                                           \
-  do                                                                                               \
-  {                                                                                                \
-    if (QUILL_UNLIKELY(!(expression)))                                                             \
-    {                                                                                              \
-      printf("Quill fatal error: %s (%s:%d)\n", error, __FILE__, __LINE__);                        \
-      std::abort();                                                                                \
-    }                                                                                              \
-  } while (0)
-
-#if defined(QUILL_NO_EXCEPTIONS)
-  #define QUILL_TRY if (true)
-  #define QUILL_THROW(ex) QUILL_REQUIRE(false, ex.what())
-  #define QUILL_CATCH(x) if (false)
-  #define QUILL_CATCH_ALL() if (false)
-#else
-  #define QUILL_TRY try
-  #define QUILL_THROW(ex) throw(ex)
-  #define QUILL_CATCH(x) catch (x)
-  #define QUILL_CATCH_ALL() catch (...)
-#endif
-
-namespace quill
-{
-/**
- * custom exception
- */
-class QuillError : public std::exception
-{
-public:
-  explicit QuillError(std::string s) : _error(static_cast<std::string&&>(s)) {}
-  explicit QuillError(char const* s) : _error(s) {}
-
-  QUILL_NODISCARD char const* what() const noexcept override { return _error.data(); }
-
-private:
-  std::string _error;
-};
-
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/Rdtsc.h b/subprojects/quill-4.2.0/quill/include/quill/core/Rdtsc.h
deleted file mode 100644
index 2a5203b..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/Rdtsc.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-
-#include <cstdint>
-
-#if defined(__aarch64__)
-  #include <chrono>
-  #include <cstdint>
-#elif defined(__ARM_ARCH)
-  #include <chrono>
-  #include <cstdint>
-#elif (defined(_M_ARM) || defined(_M_ARM64))
-  #include <chrono>
-  #include <cstdint>
-#elif (defined(__PPC64__))
-  #include <chrono>
-  #include <cstdint>
-#else
-  // assume x86-64 ..
-  #if defined(_WIN32)
-    #include <intrin.h>
-  #elif __has_include(<x86gprintrin.h>) && !defined(__INTEL_COMPILER)
-    #include <x86gprintrin.h>
-  #else
-    #include <x86intrin.h>
-  #endif
-#endif
-
-namespace quill::detail
-{
-#if defined(__aarch64__)
-// arm64
-QUILL_NODISCARD QUILL_ATTRIBUTE_HOT inline uint64_t rdtsc() noexcept
-{
-  // System timer of ARMv8 runs at a different frequency than the CPU's.
-  // The frequency is fixed, typically in the range 1-50MHz.  It can be
-  // read at CNTFRQ special register.  We assume the OS has set up the virtual timer properly.
-  int64_t virtual_timer_value;
-  __asm__ volatile("mrs %0, cntvct_el0" : "=r"(virtual_timer_value));
-  return static_cast<uint64_t>(virtual_timer_value);
-}
-#elif defined(__ARM_ARCH)
-QUILL_NODISCARD QUILL_ATTRIBUTE_HOT inline uint64_t rdtsc() noexcept
-{
-  #if (__ARM_ARCH >= 6)
-  // V6 is the earliest arch that has a standard cyclecount
-  uint32_t pmccntr;
-  uint32_t pmuseren;
-  uint32_t pmcntenset;
-
-  __asm__ volatile("mrc p15, 0, %0, c9, c14, 0" : "=r"(pmuseren));
-  if (pmuseren & 1)
-  {
-    __asm__ volatile("mrc p15, 0, %0, c9, c12, 1" : "=r"(pmcntenset));
-    if (pmcntenset & 0x80000000ul)
-    {
-      __asm__ volatile("mrc p15, 0, %0, c9, c13, 0" : "=r"(pmccntr));
-      return (static_cast<uint64_t>(pmccntr)) * 64u;
-    }
-  }
-  #endif
-
-  // soft failover
-  return static_cast<uint64_t>(std::chrono::system_clock::now().time_since_epoch().count());
-}
-#elif (defined(_M_ARM) || defined(_M_ARM64))
-QUILL_NODISCARD QUILL_ATTRIBUTE_HOT inline uint64_t rdtsc() noexcept
-{
-  // soft failover
-  return static_cast<uint64_t>(std::chrono::system_clock::now().time_since_epoch().count());
-}
-#elif (defined(__PPC64__))
-QUILL_NODISCARD QUILL_ATTRIBUTE_HOT inline uint64_t rdtsc() noexcept
-{
-  // soft failover
-  return static_cast<uint64_t>(std::chrono::system_clock::now().time_since_epoch().count());
-}
-#else
-/**
- * Get the TSC counter
- * @return rdtsc timestamp
- */
-QUILL_NODISCARD QUILL_ATTRIBUTE_HOT inline uint64_t rdtsc() noexcept { return __rdtsc(); }
-#endif
-
-} // namespace quill::detail
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/SinkManager.h b/subprojects/quill-4.2.0/quill/include/quill/core/SinkManager.h
deleted file mode 100644
index 20c4850..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/SinkManager.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/QuillError.h"
-
-#include <algorithm>
-#include <cstdint>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-namespace quill
-{
-/** Forward declarations **/
-class FileSink;
-class Sink;
-
-namespace detail
-{
-class SinkManager
-{
-private:
-  struct SinkInfo
-  {
-    explicit SinkInfo() = default;
-    SinkInfo(std::string sid, std::weak_ptr<Sink> sptr)
-      : sink_id(static_cast<std::string&&>(sid)), sink_ptr(static_cast<std::weak_ptr<Sink>&&>(sptr)){};
-
-    std::string sink_id;
-    std::weak_ptr<Sink> sink_ptr;
-  };
-
-public:
-  SinkManager(SinkManager const&) = delete;
-  SinkManager& operator=(SinkManager const&) = delete;
-
-  /***/
-  static SinkManager& instance() noexcept
-  {
-    static SinkManager instance;
-    return instance;
-  }
-
-  /***/
-  QUILL_NODISCARD std::shared_ptr<Sink> get_sink(std::string const& sink_name) const
-  {
-    // The sinks are used by the backend thread, so after their creation we want to avoid mutating their member variables.
-    std::lock_guard<std::mutex> const lock{_mutex};
-
-    std::shared_ptr<Sink> sink = _find_sink(sink_name);
-
-    if (QUILL_UNLIKELY(!sink))
-    {
-      QUILL_THROW(QuillError{"Sink with name \"" + sink_name + "\" does not exist"});
-    }
-
-    return sink;
-  }
-
-  /***/
-  template <typename TSink, typename... Args>
-  std::shared_ptr<Sink> create_or_get_sink(std::string const& sink_name, Args&&... args)
-  {
-    // The sinks are used by the backend thread, so after their creation we want to avoid mutating their member variables.
-    std::lock_guard<std::mutex> const lock{_mutex};
-
-    std::shared_ptr<Sink> sink = _find_sink(sink_name);
-
-    if (!sink)
-    {
-      if constexpr (std::disjunction_v<std::is_same<FileSink, TSink>, std::is_base_of<FileSink, TSink>>)
-      {
-        sink = std::make_shared<TSink>(sink_name, static_cast<Args&&>(args)...);
-      }
-      else
-      {
-        sink = std::make_shared<TSink>(static_cast<Args&&>(args)...);
-      }
-
-      _insert_sink(sink_name, sink);
-    }
-
-    return sink;
-  }
-
-  /***/
-  uint32_t cleanup_unused_sinks()
-  {
-    // this needs to take a lock each time. The backend logging thread should be carefully call
-    // it only when needed
-    std::lock_guard<std::mutex> const lock{_mutex};
-    uint32_t cnt{0};
-    for (auto it = _sinks.begin(); it != _sinks.end();)
-    {
-      if (it->sink_ptr.expired())
-      {
-        it = _sinks.erase(it);
-        ++cnt;
-      }
-      else
-      {
-        ++it;
-      }
-    }
-
-    return cnt;
-  }
-
-private:
-  SinkManager() = default;
-  ~SinkManager() = default;
-
-  /***/
-  void _insert_sink(std::string const& sink_name, std::shared_ptr<Sink> const& sink)
-  {
-    auto search_it =
-      std::lower_bound(_sinks.begin(), _sinks.end(), sink_name,
-                       [](SinkInfo const& elem, std::string const& b) { return elem.sink_id < b; });
-
-    _sinks.insert(search_it, SinkInfo{sink_name, sink});
-  }
-
-  /***/
-  QUILL_NODISCARD std::shared_ptr<Sink> _find_sink(std::string const& target) const noexcept
-  {
-    std::shared_ptr<Sink> sink;
-
-    auto search_it =
-      std::lower_bound(_sinks.begin(), _sinks.end(), target,
-                       [](SinkInfo const& elem, std::string const& b) { return elem.sink_id < b; });
-
-    if (search_it != std::end(_sinks) && search_it->sink_id == target)
-    {
-      sink = search_it->sink_ptr.lock();
-    }
-
-    return sink;
-  }
-
-private:
-  std::vector<SinkInfo> _sinks;
-  mutable std::mutex _mutex;
-};
-} // namespace detail
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/ThreadContextManager.h b/subprojects/quill-4.2.0/quill/include/quill/core/ThreadContextManager.h
deleted file mode 100644
index 3103e1e..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/ThreadContextManager.h
+++ /dev/null
@@ -1,386 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/BoundedSPSCQueue.h"
-#include "quill/core/Common.h"
-#include "quill/core/ThreadUtilities.h"
-#include "quill/core/UnboundedSPSCQueue.h"
-
-#include <atomic>
-#include <cassert>
-#include <cstdint>
-#include <cstdlib>
-#include <memory>
-#include <mutex>
-#include <new>
-#include <string>
-#include <string_view>
-#include <type_traits>
-#include <vector>
-
-namespace quill::detail
-{
-/** Forward Declarations **/
-class UnboundedTransitEventBuffer;
-class BackendWorker;
-
-class ThreadContext
-{
-private:
-  union SpscQueueUnion
-  {
-    UnboundedSPSCQueue unbounded_spsc_queue;
-    BoundedSPSCQueue bounded_spsc_queue;
-
-    SpscQueueUnion() {}
-    ~SpscQueueUnion() {}
-  };
-
-public:
-  /***/
-  ThreadContext(QueueType queue_type, uint32_t initial_spsc_queue_capacity, bool huges_pages_enabled)
-    : _queue_type(queue_type)
-  {
-    if (has_unbounded_queue_type())
-    {
-      new (&_spsc_queue_union.unbounded_spsc_queue)
-        UnboundedSPSCQueue{initial_spsc_queue_capacity, huges_pages_enabled};
-    }
-    else if (has_bounded_queue_type())
-    {
-      new (&_spsc_queue_union.bounded_spsc_queue)
-        BoundedSPSCQueue{initial_spsc_queue_capacity, huges_pages_enabled};
-    }
-
-    _conditional_arg_size_cache.reserve(8);
-  }
-
-  /***/
-  ThreadContext(ThreadContext const&) = delete;
-  ThreadContext& operator=(ThreadContext const&) = delete;
-
-  /***/
-  ~ThreadContext()
-  {
-    if (has_unbounded_queue_type())
-    {
-      _spsc_queue_union.unbounded_spsc_queue.~UnboundedSPSCQueue();
-    }
-    else if (has_bounded_queue_type())
-    {
-      _spsc_queue_union.bounded_spsc_queue.~BoundedSPSCQueue();
-    }
-  }
-
-  /***/
-  template <QueueType queue_type>
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT
-    std::conditional_t<(queue_type == QueueType::UnboundedBlocking) || (queue_type == QueueType::UnboundedUnlimited) ||
-                         (queue_type == QueueType::UnboundedDropping),
-                                                       UnboundedSPSCQueue, BoundedSPSCQueue>&
-  get_spsc_queue() noexcept
-  {
-    assert((_queue_type == queue_type) && "ThreadContext queue_type mismatch");
-
-    if constexpr ((queue_type == QueueType::UnboundedBlocking) ||
-                  (queue_type == QueueType::UnboundedUnlimited) || (queue_type == QueueType::UnboundedDropping))
-    {
-      return _spsc_queue_union.unbounded_spsc_queue;
-    }
-    else
-    {
-      return _spsc_queue_union.bounded_spsc_queue;
-    }
-  }
-
-  /***/
-  template <QueueType queue_type>
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT
-    std::conditional_t<(queue_type == QueueType::UnboundedBlocking) || (queue_type == QueueType::UnboundedUnlimited) ||
-                         (queue_type == QueueType::UnboundedDropping),
-                                                       UnboundedSPSCQueue, BoundedSPSCQueue> const&
-  get_spsc_queue() const noexcept
-  {
-    assert((_queue_type == queue_type) && "ThreadContext queue_type mismatch");
-
-    if constexpr ((queue_type == QueueType::UnboundedBlocking) ||
-                  (queue_type == QueueType::UnboundedUnlimited) || (queue_type == QueueType::UnboundedDropping))
-    {
-      return _spsc_queue_union.unbounded_spsc_queue;
-    }
-    else
-    {
-      return _spsc_queue_union.bounded_spsc_queue;
-    }
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT std::vector<size_t>& get_conditional_arg_size_cache() noexcept
-  {
-    return _conditional_arg_size_cache;
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT bool has_bounded_queue_type() const noexcept
-  {
-    return (_queue_type == QueueType::BoundedBlocking) || (_queue_type == QueueType::BoundedDropping);
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT bool has_unbounded_queue_type() const noexcept
-  {
-    return (_queue_type == QueueType::UnboundedBlocking) ||
-      (_queue_type == QueueType::UnboundedDropping) || (_queue_type == QueueType::UnboundedUnlimited);
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT bool has_dropping_queue() const noexcept
-  {
-    return (_queue_type == QueueType::UnboundedDropping) || (_queue_type == QueueType::BoundedDropping);
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT bool has_blocking_queue() const noexcept
-  {
-    return (_queue_type == QueueType::UnboundedBlocking) || (_queue_type == QueueType::BoundedBlocking);
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT SpscQueueUnion const& get_spsc_queue_union() const noexcept
-  {
-    return _spsc_queue_union;
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT SpscQueueUnion& get_spsc_queue_union() noexcept
-  {
-    return _spsc_queue_union;
-  }
-
-  /***/
-  QUILL_NODISCARD std::string_view thread_id() const noexcept { return _thread_id; }
-
-  /***/
-  QUILL_NODISCARD std::string_view thread_name() const noexcept { return _thread_name; }
-
-  /***/
-  void mark_invalid() noexcept { _valid.store(false, std::memory_order_relaxed); }
-
-  /***/
-  QUILL_NODISCARD bool is_valid_context() const noexcept
-  {
-    return _valid.load(std::memory_order_relaxed);
-  }
-
-  /***/
-  void increment_failure_counter() noexcept
-  {
-    _failure_counter.fetch_add(1, std::memory_order_relaxed);
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT size_t get_and_reset_failure_counter() noexcept
-  {
-    if (QUILL_LIKELY(_failure_counter.load(std::memory_order_relaxed) == 0))
-    {
-      return 0;
-    }
-    return _failure_counter.exchange(0, std::memory_order_relaxed);
-  }
-
-private:
-  friend class detail::BackendWorker;
-
-  SpscQueueUnion _spsc_queue_union;                /** queue for this thread */
-  std::vector<size_t> _conditional_arg_size_cache; /** used for storing sizes when necessary, such as when calling strn or when a loop is required for a specific type **/
-  std::string _thread_id = std::to_string(get_thread_id());           /**< cache this thread pid */
-  std::string _thread_name = get_thread_name();                       /**< cache this thread name */
-  std::shared_ptr<UnboundedTransitEventBuffer> _transit_event_buffer; /** backend thread buffer. this could be unique_ptr but it is shared_ptr because of the forward declaration */
-  QueueType _queue_type;
-  std::atomic<bool> _valid{true}; /**< is this context valid, set by the frontend, read by the backend thread */
-  alignas(CACHE_LINE_ALIGNED) std::atomic<size_t> _failure_counter{0};
-};
-
-class ThreadContextManager
-{
-public:
-  /***/
-  static ThreadContextManager& instance() noexcept
-  {
-    static ThreadContextManager instance;
-    return instance;
-  }
-
-  /***/
-  ThreadContextManager(ThreadContextManager const&) = delete;
-  ThreadContextManager& operator=(ThreadContextManager const&) = delete;
-
-  /***/
-  template <typename TCallback>
-  void for_each_thread_context(TCallback cb)
-  {
-    std::lock_guard<std::mutex> const lock{_mutex};
-
-    for (auto const& elem : _thread_contexts)
-    {
-      cb(elem.get());
-    }
-  }
-
-  /***/
-  void register_thread_context(std::shared_ptr<ThreadContext> const& thread_context)
-  {
-    _mutex.lock();
-    _thread_contexts.push_back(thread_context);
-    _mutex.unlock();
-    _new_thread_context_flag.store(true, std::memory_order_release);
-  }
-
-  /***/
-  void add_invalid_thread_context() noexcept
-  {
-    _invalid_thread_context_count.fetch_add(1, std::memory_order_relaxed);
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT bool has_invalid_thread_context() const noexcept
-  {
-    // Here we do relaxed because if the value is not zero we will look inside ThreadContext invalid
-    // flag that is also a relaxed atomic, and then we will look into the SPSC queue size that is
-    // also atomic Even if we don't read everything in order we will check again in the next circle
-    return _invalid_thread_context_count.load(std::memory_order_relaxed) != 0;
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT bool new_thread_context_flag() noexcept
-  {
-    // Again relaxed memory model as in case it is false we will acquire the lock
-    if (_new_thread_context_flag.load(std::memory_order_relaxed))
-    {
-      // if the variable was updated to true, set it to false,
-      // There should not be any race condition here as this is the only place _changed is set to
-      // false, and we will return true anyway
-      _new_thread_context_flag.store(false, std::memory_order_relaxed);
-      return true;
-    }
-    return false;
-  }
-
-  /***/
-  void remove_shared_invalidated_thread_context(ThreadContext const* thread_context)
-  {
-    std::lock_guard<std::mutex> const lock{_mutex};
-
-    // We could use std::find_if, but since this header is included in Logger.h, which is essential
-    // for logging purposes, we aim to minimize the number of includes in that path.
-    // Therefore, we implement our own find_if loop here.
-    auto thread_context_it = _thread_contexts.end();
-    for (auto it = _thread_contexts.begin(); it != _thread_contexts.end(); ++it)
-    {
-      if (it->get() == thread_context)
-      {
-        thread_context_it = it;
-        break;
-      }
-    }
-
-    assert(thread_context_it != _thread_contexts.end() &&
-           "Attempting to remove a non existent thread context");
-
-    assert(!thread_context_it->get()->is_valid_context() &&
-           "Attempting to remove a valid thread context");
-
-#ifndef NDEBUG
-    assert(thread_context->has_unbounded_queue_type() || thread_context->has_bounded_queue_type());
-
-    if (thread_context->has_unbounded_queue_type())
-    {
-      assert(thread_context->get_spsc_queue_union().unbounded_spsc_queue.empty() &&
-             "Attempting to remove a thread context with a non empty queue");
-    }
-    else if (thread_context->has_bounded_queue_type())
-    {
-      assert(thread_context->get_spsc_queue_union().bounded_spsc_queue.empty() &&
-             "Attempting to remove a thread context with a non empty queue");
-    }
-#endif
-
-    _thread_contexts.erase(thread_context_it);
-
-    // Decrement the counter since we found something to
-    _invalid_thread_context_count.fetch_sub(1, std::memory_order_relaxed);
-  }
-
-private:
-  ThreadContextManager() = default;
-  ~ThreadContextManager() = default;
-
-private:
-  std::mutex _mutex; /**< Protect access when register contexts or removing contexts */
-  std::vector<std::shared_ptr<ThreadContext>> _thread_contexts; /**< The registered contexts */
-
-  alignas(CACHE_LINE_ALIGNED) std::atomic<bool> _new_thread_context_flag{false};
-  alignas(CACHE_LINE_ALIGNED) std::atomic<uint8_t> _invalid_thread_context_count{0};
-};
-
-class ScopedThreadContext
-{
-public:
-  /***/
-  ScopedThreadContext(QueueType queue_type, uint32_t spsc_queue_capacity, bool huge_pages_enabled)
-    : _thread_context(std::make_shared<ThreadContext>(queue_type, spsc_queue_capacity, huge_pages_enabled))
-  {
-    ThreadContextManager::instance().register_thread_context(_thread_context);
-  }
-
-  /***/
-  ScopedThreadContext(ScopedThreadContext const&) = delete;
-  ScopedThreadContext& operator=(ScopedThreadContext const&) = delete;
-
-  /***/
-  ~ScopedThreadContext() noexcept
-  {
-    // This destructor will get called when the thread that created this wrapper stops
-    // we will only invalidate the thread context
-    // The backend thread will empty an invalidated ThreadContext and then remove_file it from
-    // the ThreadContextCollection
-    // There is only exception for the thread who owns the ThreadContextCollection the
-    // main thread. The thread context of the main thread can get deleted before getting invalidated
-    _thread_context->mark_invalid();
-
-    // Notify the backend thread that one context has been removed
-    ThreadContextManager::instance().add_invalid_thread_context();
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT ThreadContext*
-
-  get_thread_context() const noexcept
-  {
-    assert(_thread_context && "_thread_context can not be null");
-    return _thread_context.get();
-  }
-
-private:
-  /**<
-   * This could be unique_ptr but the thread context of main thread that owns
-   * ThreadContextCollection can be destructed last even after the logger singleton destruction
-   * so we use shared_ptr */
-  std::shared_ptr<ThreadContext> _thread_context;
-};
-
-/***/
-template <typename TFrontendOptions>
-QUILL_NODISCARD QUILL_ATTRIBUTE_HOT extern ThreadContext* get_local_thread_context() noexcept
-{
-  thread_local ScopedThreadContext scoped_thread_context{
-    TFrontendOptions::queue_type, TFrontendOptions::initial_queue_capacity, TFrontendOptions::huge_pages_enabled};
-
-  return scoped_thread_context.get_thread_context();
-}
-} // namespace quill::detail
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/ThreadUtilities.h b/subprojects/quill-4.2.0/quill/include/quill/core/ThreadUtilities.h
deleted file mode 100644
index b1eaffd..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/ThreadUtilities.h
+++ /dev/null
@@ -1,197 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/QuillError.h"
-
-#include <cstdint>
-#include <cstring>
-#include <string>
-
-#if defined(_WIN32)
-  #if !defined(WIN32_LEAN_AND_MEAN)
-    #define WIN32_LEAN_AND_MEAN
-  #endif
-
-  #if !defined(NOMINMAX)
-    // Mingw already defines this, so no need to redefine
-    #define NOMINMAX
-  #endif
-
-  #include <windows.h>
-
-  #include <codecvt>
-  #include <locale>
-#elif defined(__APPLE__)
-  #include <mach/thread_act.h>
-  #include <mach/thread_policy.h>
-  #include <pthread.h>
-#elif defined(__linux__)
-  #include <pthread.h>
-  #include <sys/syscall.h>
-  #include <unistd.h>
-#elif defined(__NetBSD__)
-  #include <lwp.h>
-  #include <unistd.h>
-#elif defined(__FreeBSD__)
-  #include <sys/thr.h>
-  #include <unistd.h>
-#elif defined(__DragonFly__)
-  #include <sys/lwp.h>
-  #include <unistd.h>
-#endif
-
-namespace quill::detail
-{
-#if defined(_WIN32)
-
-/**
- * Convert a string to wstring
- * @param str input string
- * @return the value of input string as wide string
- */
-QUILL_NODISCARD inline std::wstring s2ws(std::string const& str) noexcept
-{
-  #pragma warning(push)
-  #pragma warning(disable : 4996)
-
-  using convert_t = std::codecvt_utf8_utf16<wchar_t>;
-  std::wstring_convert<convert_t, wchar_t> converter;
-  return converter.from_bytes(str);
-
-  #pragma warning(pop)
-}
-
-/**
- * wstring to string
- * @param wstr input wide string
- * @return the value of input wide string as string
- */
-QUILL_NODISCARD inline std::string ws2s(std::wstring const& wstr) noexcept
-{
-  #pragma warning(push)
-  #pragma warning(disable : 4996)
-
-  using convert_t = std::codecvt_utf8_utf16<wchar_t>;
-  std::wstring_convert<convert_t, wchar_t> converter;
-  return converter.to_bytes(wstr);
-
-  #pragma warning(pop)
-}
-
-/***/
-template <typename ReturnT, typename Signature, typename... Args>
-ReturnT callRunTimeDynamicLinkedFunction(std::string const& dll_name,
-                                         std::string const& function_name, Args... args)
-{
-  // https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getthreaddescription
-  // Windows Server 2016, Windows 10 LTSB 2016 and Windows 10 version 1607: e.g. GetThreadDescription is only available by Run Time Dynamic Linking in KernelBase.dll.
-
-  #ifdef UNICODE
-  HINSTANCE const hinstLibrary = LoadLibraryW(s2ws(dll_name).c_str());
-  #else
-  HINSTANCE const hinstLibrary = LoadLibraryA(dll_name.c_str());
-  #endif
-
-  if (QUILL_UNLIKELY(hinstLibrary == nullptr))
-  {
-    QUILL_THROW(QuillError{std::string{"Failed to load library " + dll_name}});
-  }
-
-  auto const callable = reinterpret_cast<Signature>(GetProcAddress(hinstLibrary, function_name.c_str()));
-
-  if (QUILL_UNLIKELY(callable == nullptr))
-  {
-    FreeLibrary(hinstLibrary);
-    QUILL_THROW(QuillError{std::string{"Failed to call " + function_name + " " + dll_name}});
-  }
-
-  ReturnT const hr = callable(static_cast<Args&&>(args)...);
-  BOOL const fFreeResult = FreeLibrary(hinstLibrary);
-
-  if (QUILL_UNLIKELY(!fFreeResult))
-  {
-    QUILL_THROW(QuillError{std::string{"Failed to free library " + dll_name}});
-  }
-
-  return hr;
-}
-#endif
-
-/**
- * Returns the name of the thread. By default, each thread is unnamed.
- * If set_thread_name has not been used to set the name of the specified thread,
- * a null string is retrieved into name.
- * @return the thread name
- */
-QUILL_NODISCARD inline std::string get_thread_name()
-{
-#if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__MINGW64__) || defined(QUILL_NO_THREAD_NAME_SUPPORT)
-  // Disabled on MINGW / Cygwin.
-  return std::string{"ThreadNameDisabled"};
-#elif defined(_WIN32)
-  PWSTR data = nullptr;
-
-  typedef HRESULT(WINAPI * GetThreadDescriptionSignature)(HANDLE, PWSTR*);
-  HRESULT hr = callRunTimeDynamicLinkedFunction<HRESULT, GetThreadDescriptionSignature>(
-    "KernelBase.dll", "GetThreadDescription", GetCurrentThread(), &data);
-
-  if (FAILED(hr))
-  {
-    QUILL_THROW(QuillError{"Failed to get thread name"});
-  }
-
-  if (QUILL_UNLIKELY(data == nullptr))
-  {
-    QUILL_THROW(QuillError{"Failed to get thread name. Invalid data."});
-  }
-
-  const std::wstring tname{&data[0], wcslen(&data[0])};
-  LocalFree(data);
-  return ws2s(tname);
-#else
-  // Apple, linux
-  char thread_name[16] = {'\0'};
-  auto res = pthread_getname_np(pthread_self(), &thread_name[0], 16);
-  if (res != 0)
-  {
-    QUILL_THROW(QuillError{"Failed to get thread name. error: " + std::to_string(res)});
-  }
-  return std::string{&thread_name[0], strlen(&thread_name[0])};
-#endif
-}
-
-/**
- * Returns the os assigned ID of the thread
- * @return the thread ID of the calling thread
- */
-QUILL_NODISCARD inline uint32_t get_thread_id() noexcept
-{
-#if defined(__CYGWIN__)
-  // get thread id on cygwin not supported
-  return 0;
-#elif defined(_WIN32)
-  return static_cast<uint32_t>(GetCurrentThreadId());
-#elif defined(__linux__)
-  return static_cast<uint32_t>(::syscall(SYS_gettid));
-#elif defined(__APPLE__)
-  uint64_t tid64;
-  pthread_threadid_np(nullptr, &tid64);
-  return static_cast<uint32_t>(tid64);
-#elif defined(__NetBSD__)
-  return static_cast<uint32_t>(_lwp_self());
-#elif defined(__FreeBSD__)
-  long lwpid;
-  thr_self(&lwpid);
-  return static_cast<uint32_t>(lwpid);
-#elif defined(__DragonFly__)
-  return static_cast<uint32_t>(lwp_gettid());
-#else
-  return reinterpret_cast<uintptr_t>(pthread_self()); // (Ab)use pthread_self as a last resort option
-#endif
-}
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/TimeUtilities.h b/subprojects/quill-4.2.0/quill/include/quill/core/TimeUtilities.h
deleted file mode 100644
index ec13328..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/TimeUtilities.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/QuillError.h"
-
-#include <cerrno>
-#include <cstring>
-#include <ctime>
-#include <string>
-
-// Forward declaration
-struct tm;
-
-namespace quill::detail
-{
-/**
- * Portable gmtime_r or _s per operating system
- * @param timer to a time_t object to convert
- * @param buf to a struct tm object to store the result
- * @return copy of the buf pointer, or throws on error
- * @throws std::system_error
- */
-inline tm* gmtime_rs(time_t const* timer, tm* buf)
-{
-#if defined(_WIN32)
-  errno_t const res = gmtime_s(buf, timer);
-  if (res)
-  {
-    QUILL_THROW(QuillError{
-      std::string{"failed to call gmtime_rs, with error message errno: " + std::to_string(res)}});
-  }
-  return buf;
-#else
-  tm* res = gmtime_r(timer, buf);
-  if (QUILL_UNLIKELY(!res))
-  {
-    QUILL_THROW(QuillError{std::string{"failed to call gmtime_rs, with error message errno: " +
-                                       std::to_string(errno) + " error: " + strerror(errno)}});
-  }
-  return res;
-#endif
-}
-
-/**
- * Portable localtime_r or _s per operating system
- * @param timer to a time_t object to convert
- * @param buf to a struct tm object to store the result
- * @return copy of the buf pointer, or throws on error
- * @throws std::system_error
- */
-inline tm* localtime_rs(time_t const* timer, tm* buf)
-{
-#if defined(_WIN32)
-  auto const res = localtime_s(buf, timer);
-  if (res)
-  {
-    QUILL_THROW(QuillError{
-      std::string{"failed to call gmtime_rs, with error message errno: " + std::to_string(res)}});
-  }
-  return buf;
-#else
-  tm* res = localtime_r(timer, buf);
-  if (QUILL_UNLIKELY(!res))
-  {
-    QUILL_THROW(QuillError{std::string{"failed to call localtime_rs, with error message errno: " +
-                                       std::to_string(errno) + " error: " + strerror(errno)}});
-  }
-  return res;
-#endif
-}
-
-/**
- * inverses of gmtime
- * @param tm struct tm to convert
- * @throws on invalid input
- */
-inline time_t timegm(tm* tm)
-{
-#if defined(_WIN32)
-  time_t const ret_val = _mkgmtime(tm);
-
-  if (QUILL_UNLIKELY(ret_val == -1))
-  {
-    QUILL_THROW(QuillError{"_mkgmtime failed."});
-  }
-
-  return ret_val;
-#else
-  time_t const ret_val = ::timegm(tm);
-
-  if (QUILL_UNLIKELY(ret_val == (time_t)-1))
-  {
-    QUILL_THROW(QuillError{"timegm failed."});
-  }
-
-  return ret_val;
-#endif
-}
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/core/UnboundedSPSCQueue.h b/subprojects/quill-4.2.0/quill/include/quill/core/UnboundedSPSCQueue.h
deleted file mode 100644
index 963dcce..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/core/UnboundedSPSCQueue.h
+++ /dev/null
@@ -1,261 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/BoundedSPSCQueue.h"
-#include "quill/core/Common.h"
-#include "quill/core/QuillError.h"
-
-#include <atomic>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <limits>
-#include <string>
-
-namespace quill::detail
-{
-/**
- * A singe-producer single-consumer FIFO circular buffer
- *
- * The buffer allows producing and consuming objects
- *
- * Production is wait free.
- *
- * When the internal circular buffer becomes full a new one will be created and the production
- * will continue in the new buffer.
- *
- * Consumption is wait free. If not data is available a special value is returned. If a new
- * buffer is created from the producer the consumer first consumes everything in the old
- * buffer and then moves to the new buffer.
- */
-class UnboundedSPSCQueue
-{
-private:
-  /**
-   * A node has a buffer and a pointer to the next node
-   */
-  struct Node
-  {
-    /**
-     * Constructor
-     * @param bounded_queue_capacity the capacity of the fixed buffer
-     * @param huge_pages_enabled enables huge pages
-     */
-    explicit Node(uint32_t bounded_queue_capacity, bool huge_pages_enabled)
-      : bounded_queue(bounded_queue_capacity, huge_pages_enabled)
-    {
-    }
-
-    /** members */
-    std::atomic<Node*> next{nullptr};
-    BoundedSPSCQueue bounded_queue;
-  };
-
-public:
-  struct ReadResult
-  {
-    explicit ReadResult(std::byte* read_position) : read_pos(read_position) {}
-
-    std::byte* read_pos;
-    uint32_t previous_capacity;
-    uint32_t new_capacity;
-    bool allocation{false};
-  };
-
-  /**
-   * Constructor
-   */
-  explicit UnboundedSPSCQueue(uint32_t initial_bounded_queue_capacity, bool huges_pages_enabled = false)
-    : _producer(new Node(initial_bounded_queue_capacity, huges_pages_enabled)), _consumer(_producer)
-  {
-  }
-
-  /**
-   * Deleted
-   */
-  UnboundedSPSCQueue(UnboundedSPSCQueue const&) = delete;
-  UnboundedSPSCQueue& operator=(UnboundedSPSCQueue const&) = delete;
-
-  /**
-   * Destructor
-   */
-  ~UnboundedSPSCQueue()
-  {
-    // Get the current consumer node
-    Node const* current_node = _consumer;
-
-    // Look for extra nodes to delete
-    while (current_node != nullptr)
-    {
-      auto const to_delete = current_node;
-      current_node = current_node->next;
-      delete to_delete;
-    }
-  }
-
-  /**
-   * Reserve contiguous space for the producer without
-   * making it visible to the consumer.
-   * @return a valid point to the buffer
-   */
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT std::byte* prepare_write(uint32_t nbytes, QueueType queue_type)
-  {
-    // Try to reserve the bounded queue
-    std::byte* write_pos = _producer->bounded_queue.prepare_write(nbytes);
-
-    if (QUILL_LIKELY(write_pos != nullptr))
-    {
-      return write_pos;
-    }
-
-    // Then it means the queue doesn't have enough size
-    uint64_t capacity = static_cast<uint64_t>(_producer->bounded_queue.capacity()) * 2ull;
-    while (capacity < (nbytes + 1))
-    {
-      capacity = capacity * 2ull;
-    }
-
-    // bounded queue max power of 2 capacity since uint32_t type is used to hold the value 2147483648 bytes
-    uint64_t constexpr max_bounded_queue_capacity =
-      (std::numeric_limits<BoundedSPSCQueue::integer_type>::max() >> 1) + 1;
-
-    if (QUILL_UNLIKELY(capacity > max_bounded_queue_capacity))
-    {
-      if ((nbytes + 1) > max_bounded_queue_capacity)
-      {
-        QUILL_THROW(QuillError{
-          "logging single messages greater than 2 GB is not supported. nbytes: " + std::to_string(nbytes) +
-          " capacity: " + std::to_string(capacity) +
-          " max_bounded_queue_capacity: " + std::to_string(max_bounded_queue_capacity)});
-      }
-
-      if ((queue_type == QueueType::UnboundedBlocking) || (queue_type == QueueType::UnboundedDropping))
-      {
-        // we reached the unbounded queue limit of 2147483648 bytes (~2GB) we won't be allocating
-        // anymore and instead return nullptr to block or drop
-        return nullptr;
-      }
-
-      // else the UnboundedNonBlocking queue has no limits and will keep allocating additional 2GB queues
-      capacity = max_bounded_queue_capacity;
-    }
-
-    // commit previous write to the old queue before switching
-    _producer->bounded_queue.commit_write();
-
-    // We failed to reserve because the queue was full, create a new node with a new queue
-    auto const next_node =
-      new Node{static_cast<uint32_t>(capacity), _producer->bounded_queue.huge_pages_enabled()};
-
-    // store the new node pointer as next in the current node
-    _producer->next.store(next_node, std::memory_order_release);
-
-    // producer is now using the next node
-    _producer = next_node;
-
-    // reserve again, this time we know we will always succeed, cast to void* to ignore
-    write_pos = _producer->bounded_queue.prepare_write(nbytes);
-    assert(write_pos && "Already reserved a queue with that capacity");
-
-    return write_pos;
-  }
-
-  /**
-   * Complement to reserve producer space that makes nbytes starting
-   * from the return of reserve producer space visible to the consumer.
-   */
-  QUILL_ATTRIBUTE_HOT void finish_write(uint32_t nbytes)
-  {
-    _producer->bounded_queue.finish_write(nbytes);
-  }
-
-  /**
-   * Commit the write to notify the consumer bytes are ready to read
-   */
-  QUILL_ATTRIBUTE_HOT void commit_write() { _producer->bounded_queue.commit_write(); }
-
-  /**
-   * Prepare to read from the buffer
-   * @error_notifier a callback used for notifications to the user
-   * @return first: pointer to buffer or nullptr, second: a pair of new_capacity, previous_capacity if an allocation
-   */
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT ReadResult prepare_read()
-  {
-    ReadResult read_result = ReadResult{_consumer->bounded_queue.prepare_read()};
-
-    if (!read_result.read_pos)
-    {
-      // the buffer is empty check if another buffer exists
-      Node* const next_node = _consumer->next.load(std::memory_order_acquire);
-
-      if (QUILL_UNLIKELY(next_node != nullptr))
-      {
-        // a new buffer was added by the producer, this happens only when we have allocated a new queue
-
-        // try the existing buffer once more
-        read_result.read_pos = _consumer->bounded_queue.prepare_read();
-
-        if (!read_result.read_pos)
-        {
-          // commit the previous reads before deleting the queue
-          _consumer->bounded_queue.commit_read();
-
-          // switch to the new buffer, existing one is deleted
-          auto const previous_capacity = _consumer->bounded_queue.capacity();
-          delete _consumer;
-
-          _consumer = next_node;
-          read_result.read_pos = _consumer->bounded_queue.prepare_read();
-
-          // we switched to a new here, so we store the capacity info to return it
-          read_result.allocation = true;
-          read_result.new_capacity = _consumer->bounded_queue.capacity();
-          read_result.previous_capacity = previous_capacity;
-        }
-      }
-    }
-
-    return read_result;
-  }
-
-  /**
-   * Consumes the next nbytes in the buffer and frees it back
-   * for the producer to reuse.
-   */
-  QUILL_ATTRIBUTE_HOT void finish_read(uint32_t nbytes)
-  {
-    _consumer->bounded_queue.finish_read(nbytes);
-  }
-
-  /**
-   * Commit the read to indicate that the bytes are read and are now free to be reused
-   */
-  QUILL_ATTRIBUTE_HOT void commit_read() { _consumer->bounded_queue.commit_read(); }
-
-  /**
-   * Return the current buffer's capacity
-   * @return capacity
-   */
-  QUILL_NODISCARD uint32_t capacity() const noexcept { return _consumer->bounded_queue.capacity(); }
-
-  /**
-   * checks if the queue is empty
-   * @return true if empty, false otherwise
-   */
-  QUILL_NODISCARD bool empty() const noexcept
-  {
-    return _consumer->bounded_queue.empty() && (_consumer->next.load(std::memory_order_relaxed) == nullptr);
-  }
-
-private:
-  /** Modified by either the producer or consumer but never both */
-  alignas(CACHE_LINE_ALIGNED) Node* _producer{nullptr};
-  alignas(CACHE_LINE_ALIGNED) Node* _consumer{nullptr};
-};
-
-} // namespace quill::detail
diff --git a/subprojects/quill-4.2.0/quill/include/quill/filters/Filter.h b/subprojects/quill-4.2.0/quill/include/quill/filters/Filter.h
deleted file mode 100644
index b7feb17..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/filters/Filter.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/LogLevel.h"
-
-#include <cstdint>
-#include <string>
-#include <string_view>
-#include <utility>
-
-namespace quill
-{
-/** Forward Declaration **/
-class MacroMetadata;
-
-/**
- * Base filter class.
- * Filters can be added to Sinks
- */
-class Filter
-{
-public:
-  /**
-   * Constructor
-   * @param filter_name unique filter name
-   */
-  explicit Filter(std::string filter_name) : _filter_name(std::move(filter_name)) {}
-
-  /**
-   * Destructor
-   */
-  virtual ~Filter() = default;
-
-  /**
-   * @brief Filters a log message.
-   *
-   * @param log_metadata Pointer to the macro metadata.
-   * @param log_timestamp Timestamp of the log event.
-   * @param thread_id ID of the thread.
-   * @param thread_name Name of the thread.
-   * @param logger_name Name of the logger.
-   * @param log_level Log level of the message.
-   * @param log_message The log message.
-   *
-   * @return true if the log message should be written to the file, false otherwise
-   */
-  QUILL_NODISCARD virtual bool filter(MacroMetadata const* log_metadata, uint64_t log_timestamp,
-                                      std::string_view thread_id, std::string_view thread_name,
-                                      std::string_view logger_name, LogLevel log_level,
-                                      std::string_view log_message) noexcept = 0;
-
-  /**
-   * Gets the name of the filter. Only useful if an existing filter is needed to be looked up
-   * @return the name of the filter
-   */
-  QUILL_NODISCARD virtual std::string const& get_filter_name() const noexcept
-  {
-    return _filter_name;
-  }
-
-private:
-  std::string _filter_name;
-};
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/sinks/ConsoleSink.h b/subprojects/quill-4.2.0/quill/include/quill/sinks/ConsoleSink.h
deleted file mode 100644
index 6777e5a..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/sinks/ConsoleSink.h
+++ /dev/null
@@ -1,457 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/LogLevel.h"
-#include "quill/sinks/StreamSink.h"
-
-#include <array>
-#include <cassert>
-#include <cstdint>
-#include <cstdio>
-#include <cstring>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-#if defined(_WIN32)
-  #if !defined(WIN32_LEAN_AND_MEAN)
-    #define WIN32_LEAN_AND_MEAN
-  #endif
-
-  #if !defined(NOMINMAX)
-    // Mingw already defines this, so no need to redefine
-    #define NOMINMAX
-  #endif
-
-  #include <io.h>
-  #include <windows.h>
-#else
-  #include <cstdlib>
-  #include <unistd.h>
-#endif
-
-namespace quill
-{
-
-/** Forward Declaration **/
-class MacroMetadata;
-
-#if defined(_WIN32)
-/**
- * Represents console colours
- */
-class ConsoleColours
-{
-private:
-  // define our own to avoid including windows.h in the header..
-  using WORD = unsigned short;
-
-public:
-  ConsoleColours() { _colours.fill(white); }
-  ~ConsoleColours() = default;
-
-  /**
-   * Sets some default colours for terminal
-   */
-  void set_default_colours() noexcept
-  {
-    set_colour(LogLevel::TraceL3, white);
-    set_colour(LogLevel::TraceL2, white);
-    set_colour(LogLevel::TraceL1, white);
-    set_colour(LogLevel::Debug, cyan);
-    set_colour(LogLevel::Info, green);
-    set_colour(LogLevel::Warning, yellow | bold);
-    set_colour(LogLevel::Error, red | bold);
-    set_colour(LogLevel::Critical, on_red | bold | white); // white bold on red background
-    set_colour(LogLevel::Backtrace, magenta);
-  }
-
-  /**
-   * Sets a custom colour per log level
-   * @param log_level the log level
-   * @param colour the colour
-   */
-  void set_colour(LogLevel log_level, WORD colour) noexcept
-  {
-    auto const log_lvl = static_cast<uint32_t>(log_level);
-    _colours[log_lvl] = colour;
-    _using_colours = true;
-  }
-
-  /**
-   * @return true if we are in terminal and have also enabled colours
-   */
-  QUILL_NODISCARD bool can_use_colours() const noexcept
-  {
-    return _can_use_colours && _using_colours;
-  }
-
-  /**
-   * @return true if we have setup colours
-   */
-  QUILL_NODISCARD bool using_colours() const noexcept { return _using_colours; }
-
-  /**
-   * The colour for the given log level
-   * @param log_level the message log level
-   * @return the configured colour for this log level
-   */
-  QUILL_NODISCARD WORD colour_code(LogLevel log_level) const noexcept
-  {
-    auto const log_lvl = static_cast<uint32_t>(log_level);
-    return _colours[log_lvl];
-  }
-
-  static inline WORD const bold = FOREGROUND_INTENSITY;
-
-  static inline WORD const black = 0;
-  static inline WORD const red = FOREGROUND_RED;
-  static inline WORD const green = FOREGROUND_GREEN;
-  static inline WORD const yellow = FOREGROUND_RED | FOREGROUND_GREEN;
-  static inline WORD const blue = FOREGROUND_BLUE;
-  static inline WORD const magenta = FOREGROUND_RED | FOREGROUND_BLUE;
-  static inline WORD const cyan = FOREGROUND_GREEN | FOREGROUND_BLUE;
-  static inline WORD const white = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
-
-  static inline WORD const on_red = BACKGROUND_RED;
-  static inline WORD const on_green = BACKGROUND_GREEN;
-  static inline WORD const on_yellow = BACKGROUND_RED | BACKGROUND_GREEN;
-  static inline WORD const on_blue = BACKGROUND_BLUE;
-  static inline WORD const on_magenta = BACKGROUND_RED | BACKGROUND_BLUE;
-  static inline WORD const on_cyan = BACKGROUND_GREEN | BACKGROUND_BLUE;
-  static inline WORD const on_white = BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE;
-
-private:
-  friend class ConsoleSink;
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_COLD static bool _is_in_terminal(FILE* file) noexcept
-  {
-    bool const is_atty = _isatty(_fileno(file)) != 0;
-
-    // ::GetConsoleMode() should return 0 if file is redirected or does not point to the actual console
-    DWORD console_mode;
-    bool const is_console =
-      GetConsoleMode(reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(file))), &console_mode) != 0;
-
-    return is_atty && is_console;
-  }
-
-  void _set_can_use_colours(FILE* file) noexcept { _can_use_colours = _is_in_terminal(file); }
-
-private:
-  std::array<WORD, 10> _colours = {0}; /**< Colours per log level */
-  bool _using_colours{false};
-  bool _can_use_colours{false};
-};
-#else
-/**
- * Represents console colours
- */
-class ConsoleColours
-{
-public:
-  ConsoleColours() { _colours.fill(white); }
-
-  ~ConsoleColours() = default;
-
-  /**
-   * Sets some default colours for terminal
-   */
-  void set_default_colours() noexcept
-  {
-    set_colour(LogLevel::TraceL3, white);
-    set_colour(LogLevel::TraceL2, white);
-    set_colour(LogLevel::TraceL1, white);
-    set_colour(LogLevel::Debug, cyan);
-    set_colour(LogLevel::Info, green);
-    set_colour(LogLevel::Warning, yellow_bold);
-    set_colour(LogLevel::Error, red_bold);
-    set_colour(LogLevel::Critical, bold_on_red);
-    set_colour(LogLevel::Backtrace, magenta);
-  }
-
-  /**
-   * Sets a custom colour per log level
-   * @param log_level the log level
-   * @param colour the colour
-   */
-
-  void set_colour(LogLevel log_level, std::string const& colour) noexcept
-  {
-    auto const log_lvl = static_cast<uint32_t>(log_level);
-    _colours[log_lvl] = colour;
-    _using_colours = true;
-  }
-
-  /**
-   * @return true if we are in terminal and have also enabled colours
-   */
-  QUILL_NODISCARD bool can_use_colours() const noexcept
-  {
-    return _can_use_colours && _using_colours;
-  }
-
-  /**
-   * @return true if we have setup colours
-   */
-  QUILL_NODISCARD bool using_colours() const noexcept { return _using_colours; }
-
-  /**
-   * The colour for the given log level
-   * @param log_level the message log level
-   * @return the configured colour for this log level
-   */
-  QUILL_NODISCARD std::string const& colour_code(LogLevel log_level) const noexcept
-  {
-    auto const log_lvl = static_cast<uint32_t>(log_level);
-    return _colours[log_lvl];
-  }
-
-  // Formatting codes
-  static inline std::string const reset{"\033[0m"};
-  static inline std::string const bold{"\033[1m"};
-  static inline std::string const dark{"\033[2m"};
-  static inline std::string const underline{"\033[4m"};
-  static inline std::string const blink{"\033[5m"};
-  static inline std::string const reverse{"\033[7m"};
-  static inline std::string const concealed{"\033[8m"};
-  static inline std::string const clear_line{"\033[K"};
-
-  // Foreground colors
-  static inline std::string const black{"\033[30m"};
-  static inline std::string const red{"\033[31m"};
-  static inline std::string const green{"\033[32m"};
-  static inline std::string const yellow{"\033[33m"};
-  static inline std::string const blue{"\033[34m"};
-  static inline std::string const magenta{"\033[35m"};
-  static inline std::string const cyan{"\033[36m"};
-  static inline std::string const white{"\033[37m"};
-
-  /// Background colors
-  static inline std::string const on_black{"\033[40m"};
-  static inline std::string const on_red{"\033[41m"};
-  static inline std::string const on_green{"\033[42m"};
-  static inline std::string const on_yellow{"\033[43m"};
-  static inline std::string const on_blue{"\033[44m"};
-  static inline std::string const on_magenta{"\033[45m"};
-  static inline std::string const on_cyan{"\033[46m"};
-  static inline std::string const on_white{"\033[47m"};
-
-  /// Bold colors
-  static inline std::string const yellow_bold{"\033[33m\033[1m"};
-  static inline std::string const red_bold{"\033[31m\033[1m"};
-  static inline std::string const bold_on_red{"\033[1m\033[41m"};
-
-private:
-  friend class ConsoleSink;
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_COLD static bool _is_colour_terminal() noexcept
-  {
-    // Get term from env
-    auto* env_p = std::getenv("TERM");
-
-    if (env_p == nullptr)
-    {
-      return false;
-    }
-
-    static constexpr const char* terms[] = {"ansi",    "color",  "console", "cygwin", "gnome",
-                                            "konsole", "kterm",  "linux",   "msys",   "putty",
-                                            "rxvt",    "screen", "vt100",   "xterm",  "tmux"};
-
-    // Loop through each term and check if it's found in env_p
-    for (const char* term : terms)
-    {
-      if (std::strstr(env_p, term) != nullptr)
-      {
-        // term found
-        return true;
-      }
-    }
-
-    // none of the terms are found
-    return false;
-  }
-
-  /***/
-  QUILL_NODISCARD QUILL_ATTRIBUTE_COLD static bool _is_in_terminal(FILE* file) noexcept
-  {
-    return ::isatty(fileno(file)) != 0;
-  }
-
-  void _set_can_use_colours(FILE* file) noexcept
-  {
-    _can_use_colours = _is_in_terminal(file) && _is_colour_terminal();
-  }
-
-private:
-  std::array<std::string, 10> _colours; /**< Colours per log level */
-  bool _using_colours{false};
-  bool _can_use_colours{false};
-};
-#endif
-
-/***/
-class ConsoleSink : public StreamSink
-{
-public:
-  /**
-   * @brief Constructor
-   * @param console_colours console colours instance
-   * @param stream stream name can only be "stdout" or "stderr"
-   */
-  explicit ConsoleSink(ConsoleColours const& console_colours, std::string const& stream = "stdout")
-    : StreamSink{stream, nullptr}, _console_colours(console_colours)
-  {
-    assert((stream == "stdout") || (stream == "stderr"));
-
-    // In this ctor we take a full copy of console_colours and in our instance we modify it
-    _console_colours._set_can_use_colours(_file);
-  }
-
-  /**
-   * @brief Constructor
-   * @param enable_colours enable or disable console colours
-   * @param stream stream name can only be "stdout" or "stderr"
-   */
-  explicit ConsoleSink(bool enable_colours = true, std::string const& stream = "stdout")
-    : StreamSink{stream, nullptr}
-  {
-    assert((stream == "stdout") || (stream == "stderr"));
-
-    if (enable_colours)
-    {
-      _console_colours._set_can_use_colours(_file);
-      _console_colours.set_default_colours();
-    }
-  }
-
-  ~ConsoleSink() override = default;
-
-  /**
-   * @brief Write a formatted log message to the stream
-   * @param log_metadata log metadata
-   * @param log_timestamp log timestamp
-   * @param thread_id thread id
-   * @param thread_name thread name
-   * @param logger_name logger name
-   * @param log_level log level
-   * @param named_args vector of key-value pairs of named args
-   * @param log_message log message
-   */
-  QUILL_ATTRIBUTE_HOT void write_log_message(MacroMetadata const* log_metadata, uint64_t log_timestamp,
-                                             std::string_view thread_id, std::string_view thread_name,
-                                             std::string_view logger_name, LogLevel log_level,
-                                             std::vector<std::pair<std::string, std::string>> const* named_args,
-                                             std::string_view log_message) override
-  {
-#if defined(_WIN32)
-    if (_console_colours.using_colours())
-    {
-      WORD const colour_code = _console_colours.colour_code(log_level);
-
-      // Set foreground colour and store the original attributes
-      WORD const orig_attribs = _set_foreground_colour(colour_code);
-
-      auto out_handle = reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(_file)));
-
-      // Write to console
-      bool const write_to_console = WriteConsoleA(
-        out_handle, log_message.data(), static_cast<DWORD>(log_message.size()), nullptr, nullptr);
-
-      if (QUILL_UNLIKELY(!write_to_console))
-      {
-        auto const error = std::error_code(GetLastError(), std::system_category());
-        QUILL_THROW(QuillError{std::string{"WriteConsoleA failed. error: "} + error.message() +
-                               std::string{" errno: "} + std::to_string(error.value())});
-      }
-
-      // reset to orig colors
-      bool const set_text_attr = SetConsoleTextAttribute(out_handle, orig_attribs);
-      if (QUILL_UNLIKELY(!set_text_attr))
-      {
-        auto const error = std::error_code(GetLastError(), std::system_category());
-        QUILL_THROW(QuillError{std::string{"SetConsoleTextAttribute failed. error: "} + error.message() +
-                               std::string{" errno: "} + std::to_string(error.value())});
-      }
-    }
-    else
-    {
-      // Write record to file
-      StreamSink::write_log_message(log_metadata, log_timestamp, thread_id, thread_name,
-                                    logger_name, log_level, named_args, log_message);
-    }
-#else
-    if (_console_colours.can_use_colours())
-    {
-      // Write colour code
-      std::string const& colour_code = _console_colours.colour_code(log_level);
-      safe_fwrite(colour_code.data(), sizeof(char), colour_code.size(), _file);
-    }
-
-    // Write record to file
-    StreamSink::write_log_message(log_metadata, log_timestamp, thread_id, thread_name, logger_name,
-                                  log_level, named_args, log_message);
-
-    if (_console_colours.can_use_colours())
-    {
-      safe_fwrite(ConsoleColours::reset.data(), sizeof(char), ConsoleColours::reset.size(), _file);
-    }
-#endif
-  }
-
-  /**
-   * Used internally to enable the console colours on "stdout" sink
-   */
-  QUILL_ATTRIBUTE_COLD void enable_console_colours() noexcept
-  {
-    _console_colours.set_default_colours();
-  }
-
-private:
-#if defined(_WIN32)
-  QUILL_NODISCARD ConsoleColours::WORD _set_foreground_colour(ConsoleColours::WORD attributes)
-  {
-    CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info;
-    auto const out_handle = reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(_file)));
-
-    bool const screen_buffer_info = GetConsoleScreenBufferInfo(out_handle, &orig_buffer_info);
-    if (QUILL_UNLIKELY(!screen_buffer_info))
-    {
-      auto const error = std::error_code(GetLastError(), std::system_category());
-      QUILL_THROW(QuillError{std::string{"GetConsoleScreenBufferInfo failed. error: "} +
-                             error.message() + std::string{" errno: "} + std::to_string(error.value())});
-    }
-
-    WORD back_color = orig_buffer_info.wAttributes;
-
-    // retrieve the current background color
-    back_color &=
-      static_cast<WORD>(~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY));
-
-    // keep the background color unchanged
-    bool const console_text_attr = SetConsoleTextAttribute(out_handle, attributes | back_color);
-    if (QUILL_UNLIKELY(!console_text_attr))
-    {
-      auto const error = std::error_code(GetLastError(), std::system_category());
-      QUILL_THROW(QuillError{std::string{"SetConsoleTextAttribute failed. error: "} + error.message() +
-                             std::string{" errno: "} + std::to_string(error.value())});
-    }
-
-    return orig_buffer_info.wAttributes; // return orig attribs
-  }
-#endif
-
-protected:
-  // protected in case someone wants to derive from this class and create a custom one, e.g. for json logging to stdout
-  ConsoleColours _console_colours;
-};
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/sinks/FileSink.h b/subprojects/quill-4.2.0/quill/include/quill/sinks/FileSink.h
deleted file mode 100644
index c522486..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/sinks/FileSink.h
+++ /dev/null
@@ -1,370 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/Filesystem.h"
-#include "quill/core/QuillError.h"
-#include "quill/core/TimeUtilities.h"
-#include "quill/sinks/StreamSink.h"
-
-#include <cassert>
-#include <cerrno>
-#include <chrono>
-#include <cstdint>
-#include <cstdio>
-#include <cstring>
-#include <ctime>
-#include <string>
-#include <system_error>
-#include <utility>
-
-#if defined(_WIN32)
-  #if !defined(WIN32_LEAN_AND_MEAN)
-    #define WIN32_LEAN_AND_MEAN
-  #endif
-
-  #if !defined(NOMINMAX)
-    // Mingw already defines this, so no need to redefine
-    #define NOMINMAX
-  #endif
-
-  #include <io.h>
-  #include <windows.h>
-#elif defined(__APPLE__)
-  #include <unistd.h>
-#elif defined(__CYGWIN__)
-  #include <unistd.h>
-#elif defined(__linux__)
-  #include <unistd.h>
-#elif defined(__NetBSD__)
-  #include <unistd.h>
-#elif defined(__FreeBSD__)
-  #include <unistd.h>
-#elif defined(__DragonFly__)
-  #include <unistd.h>
-#else
-  #include <unistd.h>
-#endif
-
-namespace quill
-{
-
-enum class FilenameAppendOption : uint8_t
-{
-  StartDateTime,
-  StartDate,
-  None
-};
-
-/**
- * The FileSinkConfig class holds the configuration options for the FileSink
- */
-class FileSinkConfig
-{
-public:
-  /**
-   * @brief Sets the append type for the file name.
-   * Possible append types are: StartDate, StartDateTime or None.
-   * When this option is set, the file name will be appended with the start date or date and time
-   * timestamp of when the process started.
-   *
-   * For example:
-   * application.log -> application_20230101.log  (StartDate)
-   * application.log -> application_20230101_121020.log  (StartDateTime)
-   *
-   * @param value The append type to set. Valid options are Date and DateAndTime.
-   */
-  QUILL_ATTRIBUTE_COLD void set_filename_append_option(FilenameAppendOption value)
-  {
-    _filename_append_option = value;
-  }
-
-  /**
-   * @brief Sets the timezone to use for time-based operations e.g. when appending the date to the
-   * get_filename or when setting the logging pattern.
-   * Valid options for the timezone are 'LocalTime' or 'GmtTime'
-   * The default value is 'LocalTime'
-   * @param timezone The timezone to use for time-based operations.
-   */
-  QUILL_ATTRIBUTE_COLD void set_timezone(Timezone timezone) { _time_zone = timezone; }
-
-  /**
-   * @brief Sets whether fsync should be performed when flushing.
-   * The default value is false.
-   * @param value True to perform fsync, false otherwise.
-   */
-  QUILL_ATTRIBUTE_COLD void set_do_fsync(bool value) { _fsync_enabled = value; }
-
-  /**
-   * @brief Sets the open mode for the file.
-   * Valid options for the open mode are 'a' or 'w'. The default value is 'a'.
-   * @param open_mode open mode for the file.
-   */
-  QUILL_ATTRIBUTE_COLD void set_open_mode(char open_mode) { _open_mode = open_mode; }
-
-  /** Getters **/
-  QUILL_NODISCARD bool fsync_enabled() const noexcept { return _fsync_enabled; }
-  QUILL_NODISCARD Timezone timezone() const noexcept { return _time_zone; }
-  QUILL_NODISCARD FilenameAppendOption append_to_filename_option() const noexcept
-  {
-    return _filename_append_option;
-  }
-  QUILL_NODISCARD std::string const& open_mode() const noexcept { return _open_mode; }
-
-private:
-  std::string _open_mode{'w'};
-  Timezone _time_zone{Timezone::LocalTime};
-  FilenameAppendOption _filename_append_option{FilenameAppendOption::None};
-  bool _fsync_enabled{false};
-};
-
-/**
- * FileSink
- * Writes the log messages to a file
- */
-class FileSink : public StreamSink
-{
-public:
-  /**
-   * Construct a FileSink object.
-   * This constructor will always attempt to open the given file.
-   * @param filename Path to the file to be opened.
-   * @param config Configuration for the FileSink.
-   * @param file_event_notifier Notifies on file events.
-   * @param do_fopen If false, the file will not be opened.
-   */
-  explicit FileSink(fs::path const& filename, FileSinkConfig const& config = FileSinkConfig{},
-                    FileEventNotifier file_event_notifier = FileEventNotifier{}, bool do_fopen = true)
-    : StreamSink(_get_updated_filename_with_appended_datetime(
-                   filename, config.append_to_filename_option(), config.timezone()),
-                 nullptr, std::move(file_event_notifier)),
-      _config(config)
-  {
-    if (do_fopen)
-    {
-      open_file(_filename, _config.open_mode());
-    }
-  }
-
-  ~FileSink() override { close_file(); }
-
-  /**
-   * Flushes the stream and optionally fsyncs it.
-   */
-  QUILL_ATTRIBUTE_HOT void flush_sink() override
-  {
-    if (!_write_occurred || !_file)
-    {
-      // Check here because StreamSink::flush() will set _write_occurred to false
-      return;
-    }
-
-    StreamSink::flush_sink();
-
-    if (_config.fsync_enabled())
-    {
-      fsync_file(_file);
-    }
-
-    if (!fs::exists(_filename))
-    {
-      // after flushing the file we can check if the file still exists. If not we reopen it.
-      // This can happen if a user deletes a file while the application is running
-      close_file();
-
-      // now reopen the file for writing again, it will be a new file
-      open_file(_filename, "w");
-    }
-  }
-
-protected:
-  /**
-   * Format a datetime string.
-   * @param timestamp_ns Timestamp in nanoseconds.
-   * @param timezone Timezone to use.
-   * @param with_time Include time in the string if true.
-   * @return Formatted datetime string.
-   */
-  QUILL_NODISCARD static std::string format_datetime_string(uint64_t timestamp_ns, Timezone timezone, bool with_time)
-  {
-    // convert to seconds
-    auto const time_now = static_cast<time_t>(timestamp_ns / 1000000000);
-    tm now_tm;
-
-    if (timezone == Timezone::GmtTime)
-    {
-      detail::gmtime_rs(&time_now, &now_tm);
-    }
-    else
-    {
-      detail::localtime_rs(&time_now, &now_tm);
-    }
-
-    // Construct the string
-    char buffer[32];
-    if (with_time)
-    {
-      std::snprintf(buffer, sizeof(buffer), "%04d%02d%02d_%02d%02d%02d", now_tm.tm_year + 1900,
-                    now_tm.tm_mon + 1, now_tm.tm_mday, now_tm.tm_hour, now_tm.tm_min, now_tm.tm_sec);
-    }
-    else
-    {
-      std::snprintf(buffer, sizeof(buffer), "%04d%02d%02d", now_tm.tm_year + 1900,
-                    now_tm.tm_mon + 1, now_tm.tm_mday);
-    }
-
-    return std::string{buffer};
-  }
-
-  /**
-   * Extract stem and extension from a filename.
-   * @param filename Path to the file.
-   * @return Pair containing stem and extension.
-   */
-  QUILL_NODISCARD static std::pair<std::string, std::string> extract_stem_and_extension(fs::path const& filename) noexcept
-  {
-    // filename and extension
-    return std::make_pair((filename.parent_path() / filename.stem()).string(), filename.extension().string());
-  }
-
-  /**
-   * Append date and/or time to a filename.
-   * @param filename Path to the file.
-   * @param with_time Include time in the filename if true.
-   * @param timezone Timezone to use.
-   * @param timestamp Timestamp to use.
-   * @return Updated filename.
-   */
-  QUILL_NODISCARD static fs::path append_datetime_to_filename(
-    fs::path const& filename, bool with_time = false, Timezone timezone = Timezone::LocalTime,
-    std::chrono::system_clock::time_point timestamp = {}) noexcept
-  {
-    // Get base file and extension
-    auto const [stem, ext] = extract_stem_and_extension(filename);
-
-    // Get the time now as tm from user or default to now
-    std::chrono::system_clock::time_point const ts_now =
-      (timestamp == std::chrono::system_clock::time_point{}) ? std::chrono::system_clock::now() : timestamp;
-
-    uint64_t const timestamp_ns = static_cast<uint64_t>(
-      std::chrono::duration_cast<std::chrono::nanoseconds>(ts_now.time_since_epoch()).count());
-
-    // Construct a filename
-    return stem + "_" + format_datetime_string(timestamp_ns, timezone, with_time) + ext;
-  }
-
-  /**
-   * Open a file.
-   * @param filename Path to the file.
-   * @param mode File open mode.
-   */
-  void open_file(fs::path const& filename, std::string const& mode)
-  {
-    if (_file_event_notifier.before_open)
-    {
-      _file_event_notifier.before_open(filename);
-    }
-
-    if (!filename.parent_path().empty())
-    {
-      std::error_code ec;
-      fs::create_directories(filename.parent_path(), ec);
-      if (ec)
-      {
-        QUILL_THROW(QuillError{std::string{"create directories failed path: "} +
-                               filename.parent_path().string() + " error: " + ec.message()});
-      }
-    }
-
-    _file = fopen(filename.string().data(), mode.data());
-
-    if (!_file)
-    {
-      QUILL_THROW(QuillError{std::string{"fopen failed failed path: "} + filename.string() + " mode: " + mode +
-                             " errno: " + std::to_string(errno) + " error: " + strerror(errno)});
-    }
-
-    assert(_file && "open_file always returns a valid pointer or throws");
-
-    if (_file_event_notifier.after_open)
-    {
-      _file_event_notifier.after_open(filename, _file);
-    }
-  }
-
-  /**
-   * Close the file.
-   */
-  void close_file()
-  {
-    if (!_file)
-    {
-      return;
-    }
-
-    if (_file_event_notifier.before_close)
-    {
-      _file_event_notifier.before_close(_filename, _file);
-    }
-
-    fclose(_file);
-    _file = nullptr;
-
-    if (_file_event_notifier.after_close)
-    {
-      _file_event_notifier.after_close(_filename);
-    }
-  }
-
-  /**
-   * Fsync the file descriptor.
-   * @param fd File descriptor.
-   * @return True if successful, false otherwise.
-   */
-  static bool fsync_file(FILE* fd) noexcept
-  {
-#ifdef _WIN32
-    return FlushFileBuffers(reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(fd)))) != 0;
-#else
-    return ::fsync(fileno(fd)) == 0;
-#endif
-  }
-
-private:
-  /**
-   * Get the filename with appended date and/or time.
-   * @param filename Path to the file.
-   * @param append_to_filename_option Append option.
-   * @param timezone Timezone to use.
-   * @return Updated filename.
-   */
-  QUILL_NODISCARD quill::fs::path _get_updated_filename_with_appended_datetime(
-    quill::fs::path const& filename, quill::FilenameAppendOption append_to_filename_option, quill::Timezone timezone)
-  {
-    if ((append_to_filename_option == quill::FilenameAppendOption::None) || (filename == "/dev/null"))
-    {
-      return filename;
-    }
-
-    if (append_to_filename_option == quill::FilenameAppendOption::StartDate)
-    {
-      return append_datetime_to_filename(filename, false, timezone);
-    }
-
-    if (append_to_filename_option == quill::FilenameAppendOption::StartDateTime)
-    {
-      return append_datetime_to_filename(filename, true, timezone);
-    }
-
-    return quill::fs::path{};
-  }
-
-private:
-  FileSinkConfig _config;
-};
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/sinks/JsonConsoleSink.h b/subprojects/quill-4.2.0/quill/include/quill/sinks/JsonConsoleSink.h
deleted file mode 100644
index ec7d91c..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/sinks/JsonConsoleSink.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/FormatBuffer.h"
-#include "quill/core/LogLevel.h"
-#include "quill/core/MacroMetadata.h"
-#include "quill/sinks/StreamSink.h"
-
-#include <cstdint>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-namespace quill
-{
-class JsonConsoleSink : public StreamSink
-{
-public:
-  JsonConsoleSink() : StreamSink("stdout", nullptr) {}
-  ~JsonConsoleSink() override = default;
-
-  /**
-   * @brief Logs a formatted log message to the sink.
-   * @note Accessor for backend processing.
-   * @param log_metadata Pointer to the macro metadata.
-   * @param log_timestamp Timestamp of the log event.
-   * @param thread_id ID of the thread.
-   * @param thread_name Name of the thread.
-   * @param logger_name Name of the logger.
-   * @param log_level Log level of the message.
-   * @param named_args Vector of key-value pairs of named args
-   */
-  QUILL_ATTRIBUTE_HOT void write_log_message(MacroMetadata const* log_metadata, uint64_t log_timestamp,
-                                             std::string_view thread_id, std::string_view thread_name,
-                                             std::string_view logger_name, LogLevel log_level,
-                                             std::vector<std::pair<std::string, std::string>> const* named_args,
-                                             std::string_view) override
-  {
-    _json_message.clear();
-
-    _json_message.append(fmtquill::format(
-      R"({{"timestamp":"{}","file_name":"{}","line":"{}","thread_id":"{}","logger":"{}","log_level":"{}","message":"{}")",
-      std::to_string(log_timestamp), log_metadata->file_name(), log_metadata->line(), thread_id,
-      logger_name, loglevel_to_string(log_level), log_metadata->message_format()));
-
-    if (named_args)
-    {
-      for (auto const& [key, value] : *named_args)
-      {
-        _json_message.append(",\"");
-        _json_message.append(key);
-        _json_message.append("\":\"");
-        _json_message.append(value);
-        _json_message.append("\"");
-      }
-    }
-
-    _json_message.append("}\n");
-
-    StreamSink::write_log_message(log_metadata, log_timestamp, thread_id, thread_name, logger_name,
-                                  log_level, named_args,
-                                  std::string_view{_json_message.data(), _json_message.size()});
-  }
-
-private:
-  detail::FormatBuffer _json_message;
-};
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/sinks/JsonFileSink.h b/subprojects/quill-4.2.0/quill/include/quill/sinks/JsonFileSink.h
deleted file mode 100644
index cc67cce..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/sinks/JsonFileSink.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/Filesystem.h"
-#include "quill/core/FormatBuffer.h"
-#include "quill/core/LogLevel.h"
-#include "quill/core/MacroMetadata.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/sinks/StreamSink.h"
-
-#include <cstdint>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-namespace quill
-{
-/**
- * The JsonFileSinkConfig class holds the configuration options for the JsonFileSink
- */
-class JsonFileSinkConfig : public FileSinkConfig
-{
-public:
-  JsonFileSinkConfig() = default;
-};
-
-class JsonFileSink : public FileSink
-{
-public:
-  JsonFileSink(fs::path const& filename, JsonFileSinkConfig const& config, FileEventNotifier file_event_notifier)
-    : FileSink(filename, static_cast<FileSinkConfig const&>(config), std::move(file_event_notifier))
-  {
-  }
-
-  ~JsonFileSink() override = default;
-
-  /**
-   * @brief Logs a formatted log message to the sink.
-   * @note Accessor for backend processing.
-   * @param log_metadata Pointer to the macro metadata.
-   * @param log_timestamp Timestamp of the log event.
-   * @param thread_id ID of the thread.
-   * @param thread_name Name of the thread.
-   * @param logger_name Name of the logger.
-   * @param log_level Log level of the message.
-   * @param named_args Vector of key-value pairs of named args
-   */
-  QUILL_ATTRIBUTE_HOT void write_log_message(MacroMetadata const* log_metadata, uint64_t log_timestamp,
-                                             std::string_view thread_id, std::string_view thread_name,
-                                             std::string_view logger_name, LogLevel log_level,
-                                             std::vector<std::pair<std::string, std::string>> const* named_args,
-                                             std::string_view) override
-  {
-    _json_message.clear();
-
-    _json_message.append(fmtquill::format(
-      R"({{"timestamp":"{}","file_name":"{}","line":"{}","thread_id":"{}","logger":"{}","log_level":"{}","message":"{}")",
-      std::to_string(log_timestamp), log_metadata->file_name(), log_metadata->line(), thread_id,
-      logger_name, loglevel_to_string(log_level), log_metadata->message_format()));
-
-    if (named_args)
-    {
-      for (auto const& [key, value] : *named_args)
-      {
-        _json_message.append(",\"");
-        _json_message.append(key);
-        _json_message.append("\":\"");
-        _json_message.append(value);
-        _json_message.append("\"");
-      }
-    }
-
-    _json_message.append("}\n");
-
-    StreamSink::write_log_message(log_metadata, log_timestamp, thread_id, thread_name, logger_name,
-                                  log_level, named_args,
-                                  std::string_view{_json_message.data(), _json_message.size()});
-  }
-
-private:
-  detail::FormatBuffer _json_message;
-};
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/sinks/NullSink.h b/subprojects/quill-4.2.0/quill/include/quill/sinks/NullSink.h
deleted file mode 100644
index 5a75030..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/sinks/NullSink.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/LogLevel.h"
-#include "quill/sinks/Sink.h"
-
-#include <cstdint>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-namespace quill
-{
-/** Forward Declaration **/
-class MacroMetadata;
-
-class NullSink : public Sink
-{
-public:
-  QUILL_ATTRIBUTE_HOT void write_log_message(MacroMetadata const* log_metadata, uint64_t log_timestamp,
-                                             std::string_view thread_id, std::string_view thread_name,
-                                             std::string_view logger_name, LogLevel log_level,
-                                             std::vector<std::pair<std::string, std::string>> const* named_args,
-                                             std::string_view log_message) override
-  {
-  }
-
-  QUILL_ATTRIBUTE_HOT void flush_sink() override {}
-};
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/sinks/RotatingFileSink.h b/subprojects/quill-4.2.0/quill/include/quill/sinks/RotatingFileSink.h
deleted file mode 100644
index ad84182..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/sinks/RotatingFileSink.h
+++ /dev/null
@@ -1,796 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/Common.h"
-#include "quill/core/Filesystem.h"
-#include "quill/core/LogLevel.h"
-#include "quill/core/QuillError.h"
-#include "quill/core/TimeUtilities.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/sinks/StreamSink.h"
-
-#include <algorithm>
-#include <chrono>
-#include <cstdint>
-#include <ctime>
-#include <deque>
-#include <limits>
-#include <ratio>
-#include <string>
-#include <string_view>
-#include <system_error>
-#include <utility>
-#include <vector>
-
-namespace quill
-{
-/** Forward Declaration **/
-class MacroMetadata;
-
-/**
- * @brief The configuration options for the RotatingFileSink
- */
-class RotatingFileSinkConfig : public FileSinkConfig
-{
-public:
-  /**
-   * @brief The frequency of log file rotation
-   */
-  enum class RotationFrequency : uint8_t
-  {
-    Disabled,
-    Daily,
-    Hourly,
-    Minutely
-  };
-
-  /**
-   * @brief The naming scheme for rotated log files
-   */
-  enum class RotationNamingScheme : uint8_t
-  {
-    Index,
-    Date,
-    DateAndTime
-  };
-
-  /**
-   * @brief Constructs a new RotatingFileSinkConfig object.
-   */
-  RotatingFileSinkConfig() : _daily_rotation_time{_disabled_daily_rotation_time()} {}
-
-  /**
-   * @brief Sets the maximum file size for rotation.
-   * @param value The maximum file size in bytes per file
-   */
-  QUILL_ATTRIBUTE_COLD void set_rotation_max_file_size(size_t value)
-  {
-    if (value < 512)
-    {
-      QUILL_THROW(QuillError{"rotation_max_file_size must be greater than or equal to 512 bytes"});
-    }
-
-    _rotation_max_file_size = value;
-  }
-
-  /**
-   * @brief Sets the frequency and interval of file rotation.
-   * @param frequency The frequency of file rotation ('M' for minutes, 'H' for hours)
-   * @param interval The rotation interval
-   */
-  QUILL_ATTRIBUTE_COLD void set_rotation_frequency_and_interval(char frequency, uint32_t interval)
-  {
-    if (frequency == 'M' || frequency == 'm')
-    {
-      _rotation_frequency = RotationFrequency::Minutely;
-    }
-    else if (frequency == 'H' || frequency == 'h')
-    {
-      _rotation_frequency = RotationFrequency::Hourly;
-    }
-    else
-    {
-      QUILL_THROW(QuillError{
-        "Invalid frequency. Valid values are 'M' or 'm' for minutes or 'H' or 'h' for hours"});
-    }
-
-    if (interval == 0)
-    {
-      QUILL_THROW(QuillError{"interval must be set to a value greater than 0"});
-    }
-
-    _rotation_interval = interval;
-    _daily_rotation_time = _disabled_daily_rotation_time();
-  }
-
-  /**
-   * @brief Sets the time of day for daily log file rotation.
-   * @param daily_rotation_time_str The time of day for rotation (format: "HH:MM")
-   */
-  QUILL_ATTRIBUTE_COLD void set_rotation_time_daily(std::string const& daily_rotation_time_str)
-  {
-    _rotation_frequency = RotationFrequency::Daily;
-    _rotation_interval = 0;
-    _daily_rotation_time = _parse_daily_rotation_time(daily_rotation_time_str);
-  }
-
-  /**
-   * @brief Sets the maximum number of log files to keep.
-   * @param value The maximum number of log files
-   */
-  QUILL_ATTRIBUTE_COLD void set_max_backup_files(uint32_t value) { _max_backup_files = value; }
-
-  /**
-   * @brief Sets whether the oldest rolled logs should be overwritten when the maximum backup count
-   * is reached. If set to false, the oldest logs will not be overwritten when the maximum backup
-   * count is reached, and log file rotation will stop. The default value is true.
-   * @param value True to overwrite the oldest logs, false otherwise.
-   */
-  QUILL_ATTRIBUTE_COLD void set_overwrite_rolled_files(bool value)
-  {
-    _overwrite_rolled_files = value;
-  }
-
-  /**
-   * @brief Sets whether previous rotated log files should be removed on process start up.
-   * @note This option works only when using the mode="w"
-   * This is useful to avoid conflicting file names when the process restarts and
-   * FilenameAppend::DateTime was not set. The default value is true.
-   * @param value True to remove old log files, false otherwise.
-   */
-  QUILL_ATTRIBUTE_COLD void set_remove_old_files(bool value) { _remove_old_files = value; }
-
-  /**
-   * @brief Sets the naming scheme for the rotated files.
-   * The default value is 'Index'.
-   * @param value The naming scheme to set.
-   */
-  QUILL_ATTRIBUTE_COLD void set_rotation_naming_scheme(RotationNamingScheme value)
-  {
-    _rotation_naming_scheme = value;
-  }
-
-  /** Getter methods **/
-  QUILL_NODISCARD size_t rotation_max_file_size() const noexcept { return _rotation_max_file_size; }
-  QUILL_NODISCARD uint32_t max_backup_files() const noexcept { return _max_backup_files; }
-  QUILL_NODISCARD bool overwrite_rolled_files() const noexcept { return _overwrite_rolled_files; }
-  QUILL_NODISCARD bool remove_old_files() const noexcept { return _remove_old_files; }
-  QUILL_NODISCARD RotationFrequency rotation_frequency() const noexcept
-  {
-    return _rotation_frequency;
-  }
-  QUILL_NODISCARD uint32_t rotation_interval() const noexcept { return _rotation_interval; }
-  QUILL_NODISCARD std::pair<std::chrono::hours, std::chrono::minutes> daily_rotation_time() const noexcept
-  {
-    return _daily_rotation_time;
-  }
-  QUILL_NODISCARD RotationNamingScheme rotation_naming_scheme() const noexcept
-  {
-    return _rotation_naming_scheme;
-  }
-
-private:
-  /***/
-  std::pair<std::chrono::hours, std::chrono::minutes> _disabled_daily_rotation_time() noexcept
-  {
-    return std::make_pair(std::chrono::hours{std::numeric_limits<std::chrono::hours::rep>::max()},
-                          std::chrono::minutes{std::numeric_limits<std::chrono::hours::rep>::max()});
-  }
-
-  /***/
-  std::pair<std::chrono::hours, std::chrono::minutes> _parse_daily_rotation_time(std::string const& daily_rotation_time_str)
-  {
-    std::vector<std::string> tokens;
-    std::string token;
-    size_t start = 0, end = 0;
-
-    while ((end = daily_rotation_time_str.find(':', start)) != std::string::npos)
-    {
-      token = daily_rotation_time_str.substr(start, end - start);
-      tokens.push_back(token);
-      start = end + 1;
-    }
-
-    // Add the last token (or the only token if there's no delimiter)
-    token = daily_rotation_time_str.substr(start);
-    tokens.push_back(token);
-
-    if (tokens.size() != 2)
-    {
-      QUILL_THROW(
-        QuillError{"Invalid daily_rotation_time_str value format. The format should be `HH:MM`."});
-    }
-
-    for (auto const& parsed_token : tokens)
-    {
-      if (parsed_token.size() != 2)
-      {
-        QUILL_THROW(QuillError{
-          "Invalid daily_rotation_time_str value format. Each component of the time (HH and MM) "
-          "should be two digits."});
-      }
-    }
-
-    auto const daily_rotation_time_str_tp = std::make_pair(
-      std::chrono::hours{std::stoi(tokens[0])}, std::chrono::minutes{std::stoi(tokens[1])});
-
-    if ((daily_rotation_time_str_tp.first > std::chrono::hours{23}) ||
-        (daily_rotation_time_str_tp.second > std::chrono::minutes{59}))
-    {
-      QUILL_THROW(
-        QuillError("Invalid rotation values. The hour value should be between 00 and 23, and the "
-                   "minute value should be between 00 and 59."));
-    }
-
-    return daily_rotation_time_str_tp;
-  }
-
-private:
-  std::pair<std::chrono::hours, std::chrono::minutes> _daily_rotation_time;
-  size_t _rotation_max_file_size{0};                                // 0 means disabled
-  uint32_t _max_backup_files{std::numeric_limits<uint32_t>::max()}; // max means disabled
-  uint32_t _rotation_interval{0};                                   // 0 means disabled
-  RotationFrequency _rotation_frequency{RotationFrequency::Disabled};
-  RotationNamingScheme _rotation_naming_scheme{RotationNamingScheme::Index};
-  bool _overwrite_rolled_files{true};
-  bool _remove_old_files{true};
-};
-
-/**
- * @brief The RotatingFileSink class
- */
-class RotatingFileSink : public FileSink
-{
-public:
-  /**
-   * @brief Constructor.
-   *
-   * Creates a new instance of the RotatingFileSink class.
-   *
-   * @param filename The base file name to be used for logs.
-   * @param config The sink configuration.
-   * @param file_event_notifier file event notifier
-   * @param start_time start time
-   */
-  RotatingFileSink(fs::path const& filename, RotatingFileSinkConfig const& config,
-                   FileEventNotifier file_event_notifier = FileEventNotifier{},
-                   std::chrono::system_clock::time_point start_time = std::chrono::system_clock::now())
-    : FileSink(filename, static_cast<FileSinkConfig const&>(config), std::move(file_event_notifier), false),
-      _config(config)
-  {
-    uint64_t const today_timestamp_ns = static_cast<uint64_t>(
-      std::chrono::duration_cast<std::chrono::nanoseconds>(start_time.time_since_epoch()).count());
-
-    _clean_and_recover_files(filename, _config.open_mode(), today_timestamp_ns);
-
-    if (_config.rotation_frequency() != RotatingFileSinkConfig::RotationFrequency::Disabled)
-    {
-      // Calculate next rotation time
-      _next_rotation_time = _calculate_initial_rotation_tp(
-        static_cast<uint64_t>(
-          std::chrono::duration_cast<std::chrono::nanoseconds>(start_time.time_since_epoch()).count()),
-        config);
-    }
-
-    // Open file for logging
-    open_file(_filename, _config.open_mode());
-    _open_file_timestamp = static_cast<uint64_t>(
-      std::chrono::duration_cast<std::chrono::nanoseconds>(start_time.time_since_epoch()).count());
-
-    _created_files.emplace_front(_filename, 0, std::string{});
-
-    if (!is_null())
-    {
-      _file_size = _get_file_size(_filename);
-    }
-  }
-
-  ~RotatingFileSink() override = default;
-
-  /**
-   * @brief Writes a formatted log message to the stream
-   * @param log_metadata The metadata of the log message
-   * @param log_timestamp The timestamp of the log message
-   * @param thread_id The ID of the thread that generated the log message
-   * @param thread_name The name of the thread that generated the log message
-   * @param logger_name The name of the logger
-   * @param log_level The log level of the message
-   * @param named_args Structured key-value pairs associated with the log message
-   * @param log_message The log message to write
-   */
-  QUILL_ATTRIBUTE_HOT void write_log_message(MacroMetadata const* log_metadata, uint64_t log_timestamp,
-                                             std::string_view thread_id, std::string_view thread_name,
-                                             std::string_view logger_name, LogLevel log_level,
-                                             std::vector<std::pair<std::string, std::string>> const* named_args,
-                                             std::string_view log_message) override
-  {
-    if (is_null())
-    {
-      StreamSink::write_log_message(log_metadata, log_timestamp, thread_id, thread_name,
-                                    logger_name, log_level, named_args, log_message);
-      return;
-    }
-
-    bool time_rotation = false;
-
-    if (_config.rotation_frequency() != RotatingFileSinkConfig::RotationFrequency::Disabled)
-    {
-      // Check if we need to rotate based on time
-      time_rotation = _time_rotation(log_timestamp);
-    }
-
-    if (!time_rotation && _config.rotation_max_file_size() != 0)
-    {
-      // Check if we need to rotate based on size
-      _size_rotation(log_message.size(), log_timestamp);
-    }
-
-    // write to file
-    StreamSink::write_log_message(log_metadata, log_timestamp, thread_id, thread_name, logger_name,
-                                  log_level, named_args, log_message);
-
-    _file_size += log_message.size();
-  }
-
-private:
-  /***/
-  QUILL_NODISCARD bool _time_rotation(uint64_t record_timestamp_ns)
-  {
-    if (record_timestamp_ns >= _next_rotation_time)
-    {
-      _rotate_files(record_timestamp_ns);
-      _next_rotation_time = _calculate_rotation_tp(record_timestamp_ns, _config);
-      return true;
-    }
-
-    return false;
-  }
-
-  /***/
-  void _size_rotation(size_t log_msg_size, uint64_t record_timestamp_ns)
-  {
-    // Calculate the new size of the file
-    if (_file_size + log_msg_size > _config.rotation_max_file_size())
-    {
-      _rotate_files(record_timestamp_ns);
-    }
-  }
-
-  /***/
-  void _rotate_files(uint64_t record_timestamp_ns)
-  {
-    if ((_created_files.size() > _config.max_backup_files()) && !_config.overwrite_rolled_files())
-    {
-      // We have reached the max number of backup files, and we are not allowed to overwrite the
-      // oldest file. We will stop rotating
-      return;
-    }
-
-    // We need to flush and also fsync before actually getting the size of the file
-    FileSink::flush_sink();
-    FileSink::fsync_file(_file);
-
-    if (_get_file_size(_filename) <= 0)
-    {
-      // Also check the file size is > 0  to better deal with full disk
-      return;
-    }
-
-    close_file();
-
-    // datetime_suffix will be empty if we are using the default naming scheme
-    std::string datetime_suffix;
-    if (_config.rotation_naming_scheme() == RotatingFileSinkConfig::RotationNamingScheme::Date)
-    {
-      datetime_suffix = format_datetime_string(_open_file_timestamp, _config.timezone(), false);
-    }
-    else if (_config.rotation_naming_scheme() == RotatingFileSinkConfig::RotationNamingScheme::DateAndTime)
-    {
-      datetime_suffix = format_datetime_string(_open_file_timestamp, _config.timezone(), true);
-    }
-
-    // We need to rotate the files and rename them with an index
-    for (auto it = _created_files.rbegin(); it != _created_files.rend(); ++it)
-    {
-      // Create each existing filename on disk with the existing index.
-      // when the index is 0 we want to rename the latest file
-      fs::path existing_file;
-      fs::path renamed_file;
-
-      existing_file = _get_filename(it->base_filename, it->index, it->date_time);
-
-      // increment the index if needed and rename the file
-      uint32_t index_to_use = it->index;
-
-      if (_config.rotation_naming_scheme() == RotatingFileSinkConfig::RotationNamingScheme::Index ||
-          it->date_time == datetime_suffix)
-      {
-        // we are rotating and incrementing the index, or we have another file with the same date_time suffix
-        index_to_use += 1;
-
-        renamed_file = _get_filename(it->base_filename, index_to_use, datetime_suffix);
-
-        it->index = index_to_use;
-        it->date_time = datetime_suffix;
-
-        _rename_file(existing_file, renamed_file);
-      }
-      else if (it->date_time.empty())
-      {
-        // we are renaming the latest file
-        index_to_use = it->index;
-
-        renamed_file = _get_filename(it->base_filename, index_to_use, datetime_suffix);
-
-        it->index = index_to_use;
-        it->date_time = datetime_suffix;
-
-        _rename_file(existing_file, renamed_file);
-      }
-    }
-
-    // Check if we have too many files in the queue remove_file the oldest one
-    if (_created_files.size() > _config.max_backup_files())
-    {
-      // remove_file that file from the system and also pop it from the queue
-      fs::path const removed_file = _get_filename(
-        _created_files.back().base_filename, _created_files.back().index, _created_files.back().date_time);
-      _remove_file(removed_file);
-      _created_files.pop_back();
-    }
-
-    // add the current file back to the list with index 0
-    _created_files.emplace_front(_filename, 0, std::string{});
-
-    // Open file for logging
-    open_file(_filename, "w");
-    _open_file_timestamp = record_timestamp_ns;
-    _file_size = 0;
-  }
-
-  /***/
-  void _clean_and_recover_files(fs::path const& filename, std::string const& open_mode, uint64_t today_timestamp_ns)
-  {
-    if ((_config.rotation_naming_scheme() != RotatingFileSinkConfig::RotationNamingScheme::Index) &&
-        (_config.rotation_naming_scheme() != RotatingFileSinkConfig::RotationNamingScheme::Date))
-    {
-      // clean and recover is only supported for index and date naming scheme, when using
-      // DateAndTime there are no collisions in the filenames
-      return;
-    }
-
-    // if we are starting in "w" mode, then we also should clean all previous log files of the previous run
-    if (_config.remove_old_files() && (open_mode == "w"))
-    {
-      for (const auto& entry : fs::directory_iterator(fs::current_path() / filename.parent_path()))
-      {
-        if (entry.path().extension().string() != filename.extension().string())
-        {
-          // we only check for the files of the same extension to remove
-          continue;
-        }
-
-        // is_directory() does not exist in std::experimental::filesystem
-        if (entry.path().filename().string().find(filename.stem().string() + ".") != 0)
-        {
-          // expect to find filename.stem().string() exactly at the start of the filename
-          continue;
-        }
-
-        if (_config.rotation_naming_scheme() == RotatingFileSinkConfig::RotationNamingScheme::Index)
-        {
-          fs::remove(entry);
-        }
-        else if (_config.rotation_naming_scheme() == RotatingFileSinkConfig::RotationNamingScheme::Date)
-        {
-          // Find the first dot in the filename
-          // stem will be something like `logfile.1`
-          if (size_t const pos = entry.path().stem().string().find_last_of('.'); pos != std::string::npos)
-          {
-            // Get the today's date, we won't remove the files of the previous dates as they won't collide
-            std::string const today_date =
-              format_datetime_string(today_timestamp_ns, _config.timezone(), false);
-
-            if (std::string const index_or_date =
-                  entry.path().stem().string().substr(pos + 1, entry.path().stem().string().length());
-                (index_or_date.length() >= 8) && (index_or_date == today_date))
-            {
-              // assume it is a date, no need to find the index
-              if (index_or_date == today_date)
-              {
-                fs::remove(entry);
-              }
-            }
-            else
-            {
-              // assume it is an index
-              // Find the second last dot to get the date
-              std::string const filename_with_date = entry.path().filename().string().substr(0, pos);
-
-              if (size_t const second_last = filename_with_date.find_last_of('.'); second_last != std::string::npos)
-              {
-                if (std::string const date_part =
-                      filename_with_date.substr(second_last + 1, filename_with_date.length());
-                    date_part == today_date)
-                {
-                  fs::remove(entry);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    else if (open_mode == "a")
-    {
-      // we need to recover the index from the existing files
-      for (const auto& entry : fs::directory_iterator(fs::current_path() / filename.parent_path()))
-      {
-        // is_directory() does not exist in std::experimental::filesystem
-        if (entry.path().extension().string() != filename.extension().string())
-        {
-          // we only check for the files of the same extension to remove
-          continue;
-        }
-
-        // is_directory() does not exist in std::experimental::filesystem
-        if (entry.path().filename().string().find(filename.stem().string() + ".") != 0)
-        {
-          // expect to find filename.stem().string() exactly at the start of the filename
-          continue;
-        }
-
-        std::string const extension = entry.path().extension().string(); // e.g. ".log"
-
-        // stem will be something like `logfile.1`
-        if (size_t const pos = entry.path().stem().string().find_last_of('.'); pos != std::string::npos)
-        {
-          if (_config.rotation_naming_scheme() == RotatingFileSinkConfig::RotationNamingScheme::Index)
-          {
-            std::string const index =
-              entry.path().stem().string().substr(pos + 1, entry.path().stem().string().length());
-
-            std::string const current_filename = entry.path().filename().string().substr(0, pos) + extension;
-            fs::path current_file = entry.path().parent_path();
-            current_file.append(current_filename);
-
-            // Attempt to convert the index to a number
-            QUILL_TRY
-            {
-              _created_files.emplace_front(current_file, static_cast<uint32_t>(std::stoul(index)),
-                                           std::string{});
-            }
-            QUILL_CATCH_ALL() { continue; }
-          }
-          else if (_config.rotation_naming_scheme() == RotatingFileSinkConfig::RotationNamingScheme::Date)
-          {
-            // Get the today's date, we won't remove the files of the previous dates as they won't collide
-            std::string const today_date =
-              format_datetime_string(today_timestamp_ns, _config.timezone(), false);
-
-            if (std::string const index_or_date =
-                  entry.path().stem().string().substr(pos + 1, entry.path().stem().string().length());
-                (index_or_date.length() >= 8) && (index_or_date == today_date))
-            {
-              // assume it is a date, no need to find the index
-              std::string const current_filename = entry.path().filename().string().substr(0, pos) + extension;
-              fs::path current_file = entry.path().parent_path();
-              current_file.append(current_filename);
-
-              _created_files.emplace_front(current_file, 0, index_or_date);
-            }
-            else
-            {
-              // assume it is an index
-              // Find the second last dot to get the date
-              std::string const filename_with_date = entry.path().filename().string().substr(0, pos);
-
-              if (size_t const second_last = filename_with_date.find_last_of('.'); second_last != std::string::npos)
-              {
-                if (std::string const date_part =
-                      filename_with_date.substr(second_last + 1, filename_with_date.length());
-                    date_part == today_date)
-                {
-                  std::string const current_filename = filename_with_date.substr(0, second_last) + extension;
-                  fs::path current_file = entry.path().parent_path();
-                  current_file.append(current_filename);
-
-                  // Attempt to convert the index to a number
-                  QUILL_TRY
-                  {
-                    _created_files.emplace_front(
-                      current_file, static_cast<uint32_t>(std::stoul(index_or_date)), date_part);
-                  }
-                  QUILL_CATCH_ALL() { continue; }
-                }
-              }
-            }
-          }
-        }
-      }
-
-      // finally we need to sort the deque
-      std::sort(_created_files.begin(), _created_files.end(),
-                [](FileInfo const& a, FileInfo const& b) { return a.index < b.index; });
-    }
-  }
-
-  /***/
-  QUILL_NODISCARD static size_t _get_file_size(fs::path const& filename)
-  {
-    return static_cast<size_t>(fs::file_size(filename));
-  }
-
-  /***/
-  static bool _remove_file(fs::path const& filename) noexcept
-  {
-    std::error_code ec;
-    fs::remove(filename, ec);
-
-    if (ec)
-    {
-      return false;
-    }
-
-    return true;
-  }
-
-  /***/
-  bool static _rename_file(fs::path const& previous_file, fs::path const& new_file) noexcept
-  {
-    std::error_code ec;
-    fs::rename(previous_file, new_file, ec);
-
-    if (ec)
-    {
-      return false;
-    }
-
-    return true;
-  }
-
-  /***/
-  QUILL_NODISCARD static fs::path _append_index_to_filename(fs::path const& filename, uint32_t index) noexcept
-  {
-    if (index == 0u)
-    {
-      return filename;
-    }
-
-    // Get base file and extension
-    auto const [stem, ext] = extract_stem_and_extension(filename);
-    return fs::path{stem + "." + std::to_string(index) + ext};
-  }
-
-  /***/
-  QUILL_NODISCARD static fs::path _append_string_to_filename(fs::path const& filename, std::string const& text) noexcept
-  {
-    if (text.empty())
-    {
-      return filename;
-    }
-
-    // Get base file and extension
-    auto const [stem, ext] = extract_stem_and_extension(filename);
-    return fs::path{stem + "." + text + ext};
-  }
-
-  /***/
-  static uint64_t _calculate_initial_rotation_tp(uint64_t start_time_ns, RotatingFileSinkConfig const& config)
-  {
-    time_t const time_now = static_cast<time_t>(start_time_ns) / 1000000000;
-    tm date;
-
-    // here we do this because of `daily_rotation_time_str` that might have specified the time in UTC
-    if (config.timezone() == Timezone::GmtTime)
-    {
-      detail::gmtime_rs(&time_now, &date);
-    }
-    else
-    {
-      detail::localtime_rs(&time_now, &date);
-    }
-
-    // update to the desired date
-    if (config.rotation_frequency() == RotatingFileSinkConfig::RotationFrequency::Minutely)
-    {
-      date.tm_min += 1;
-      date.tm_sec = 0;
-    }
-    else if (config.rotation_frequency() == RotatingFileSinkConfig::RotationFrequency::Hourly)
-    {
-      date.tm_hour += 1;
-      date.tm_min = 0;
-      date.tm_sec = 0;
-    }
-    else if (config.rotation_frequency() == RotatingFileSinkConfig::RotationFrequency::Daily)
-    {
-      date.tm_hour = static_cast<decltype(date.tm_hour)>(config.daily_rotation_time().first.count());
-      date.tm_min = static_cast<decltype(date.tm_min)>(config.daily_rotation_time().second.count());
-      date.tm_sec = 0;
-    }
-    else
-    {
-      QUILL_THROW(QuillError{"Invalid rotation frequency"});
-    }
-
-    // convert back to timestamp
-    time_t const rotation_time =
-      (config.timezone() == Timezone::GmtTime) ? detail::timegm(&date) : std::mktime(&date);
-
-    uint64_t const rotation_time_seconds = (rotation_time > time_now)
-      ? static_cast<uint64_t>(rotation_time)
-      : static_cast<uint64_t>(rotation_time + std::chrono::seconds{std::chrono::hours{24}}.count());
-
-    return static_cast<uint64_t>(
-      std::chrono::nanoseconds{std::chrono::seconds{rotation_time_seconds}}.count());
-  }
-
-  /***/
-  static uint64_t _calculate_rotation_tp(uint64_t rotation_timestamp_ns, RotatingFileSinkConfig const& config)
-  {
-    if (config.rotation_frequency() == RotatingFileSinkConfig::RotationFrequency::Minutely)
-    {
-      return rotation_timestamp_ns +
-        static_cast<uint64_t>(
-               std::chrono::nanoseconds{std::chrono::minutes{config.rotation_interval()}}.count());
-    }
-
-    if (config.rotation_frequency() == RotatingFileSinkConfig::RotationFrequency::Hourly)
-    {
-      return rotation_timestamp_ns +
-        static_cast<uint64_t>(
-               std::chrono::nanoseconds{std::chrono::hours{config.rotation_interval()}}.count());
-    }
-
-    if (config.rotation_frequency() == RotatingFileSinkConfig::RotationFrequency::Daily)
-    {
-      return rotation_timestamp_ns + std::chrono::nanoseconds{std::chrono::hours{24}}.count();
-    }
-
-    QUILL_THROW(QuillError{"Invalid rotation frequency"});
-  }
-
-  /***/
-  static fs::path _get_filename(fs::path filename, uint32_t index, std::string const& date_time)
-  {
-    if (!date_time.empty())
-    {
-      filename = _append_string_to_filename(filename, date_time);
-    }
-
-    if (index > 0)
-    {
-      filename = _append_index_to_filename(filename, index);
-    }
-
-    return filename;
-  }
-
-private:
-  struct FileInfo
-  {
-    FileInfo(fs::path base_filename, uint32_t index, std::string date_time)
-      : base_filename{std::move(base_filename)}, date_time{std::move(date_time)}, index{index}
-    {
-    }
-
-    fs::path base_filename;
-    std::string date_time;
-    uint32_t index;
-  };
-
-  FileEventNotifier _file_event_notifier;
-  std::deque<FileInfo> _created_files; /**< We store in a queue the filenames we created, first: index, second: date/datetime, third: base_filename */
-  uint64_t _next_rotation_time;        /**< The next rotation time point */
-  uint64_t _open_file_timestamp{0};    /**< The timestamp of the currently open file */
-  size_t _file_size{0};                /**< The current file size */
-  RotatingFileSinkConfig _config;
-};
-
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/sinks/Sink.h b/subprojects/quill-4.2.0/quill/include/quill/sinks/Sink.h
deleted file mode 100644
index 5bbe496..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/sinks/Sink.h
+++ /dev/null
@@ -1,192 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/LogLevel.h"
-#include "quill/core/QuillError.h"
-#include "quill/filters/Filter.h"
-
-#include <algorithm>
-#include <atomic>
-#include <cstdint>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-namespace quill
-{
-/** Forward Declaration **/
-class MacroMetadata;
-
-/**
- * Base class for sinks
- */
-class Sink
-{
-public:
-  /**
-   * Constructor
-   * Uses the default pattern formatter
-   */
-  Sink() = default;
-
-  /**
-   * Destructor
-   */
-  virtual ~Sink() = default;
-
-  Sink(Sink const&) = delete;
-  Sink& operator=(Sink const&) = delete;
-
-  /**
-   * @brief Logs a formatted log message to the sink.
-   * @note Accessor for backend processing.
-   * @param log_metadata Pointer to the macro metadata.
-   * @param log_timestamp Timestamp of the log event.
-   * @param thread_id ID of the thread.
-   * @param thread_name Name of the thread.
-   * @param logger_name Name of the logger.
-   * @param log_level Log level of the message.
-   * @param named_args Vector of key-value pairs of named args
-   * @param log_message The log message.
-   */
-  QUILL_ATTRIBUTE_HOT virtual void write_log_message(
-    MacroMetadata const* log_metadata, uint64_t log_timestamp, std::string_view thread_id,
-    std::string_view thread_name, std::string_view logger_name, LogLevel log_level,
-    std::vector<std::pair<std::string, std::string>> const* named_args, std::string_view log_message) = 0;
-
-  /**
-   * @brief Flushes the sink, synchronizing the associated sink with its controlled output sequence.
-   */
-  QUILL_ATTRIBUTE_HOT virtual void flush_sink() = 0;
-
-  /**
-   * @brief Executes periodic tasks by the backend thread, providing an opportunity for the user
-   * to perform custom tasks. For example, batch committing to a database, or any other
-   * desired periodic operations.
-   * @note It is recommended to avoid heavy operations within this function as it may affect performance of the backend thread.
-   */
-  QUILL_ATTRIBUTE_HOT virtual void run_periodic_tasks() noexcept {}
-
-  /**
-   * @brief Sets a log level filter on the sink.
-   * @note Thread safe.
-   * @param log_level The log level severity.
-   */
-  void set_log_level_filter(LogLevel log_level)
-  {
-    _log_level.store(log_level, std::memory_order_relaxed);
-  }
-
-  /**
-   * @brief Returns the current log level filter set on the sink.
-   * @note Thread safe.
-   * @return The current log level filter.
-   */
-  QUILL_NODISCARD LogLevel get_log_level_filter() const noexcept
-  {
-    return _log_level.load(std::memory_order_relaxed);
-  }
-
-  /**
-   * @brief Adds a new filter to the sink.
-   * @note Thread safe.
-   * @param filter Unique pointer to the filter instance.
-   */
-  void add_filter(std::unique_ptr<Filter> filter)
-  {
-    // Lock and add this filter to our global collection
-    std::lock_guard<std::recursive_mutex> const lock{_global_filters_lock};
-
-    // Check if the same filter already exists
-    auto const search_filter_it =
-      std::find_if(_global_filters.cbegin(), _global_filters.cend(), [&filter](std::unique_ptr<Filter> const& elem_filter)
-      { return elem_filter->get_filter_name() == filter->get_filter_name(); });
-
-    if (QUILL_UNLIKELY(search_filter_it != _global_filters.cend()))
-    {
-      QUILL_THROW(QuillError{"Filter with the same name already exists"});
-    }
-
-    _global_filters.push_back(std::move(filter));
-
-    // Indicate a new filter was added - here relaxed is okay as the spinlock will do acq-rel on destruction
-    _new_filter.store(true, std::memory_order_relaxed);
-  }
-
-  /**
-   * @brief Applies all registered filters to the log record.
-   * @note Called internally by the backend worker thread.
-   * @param log_metadata Pointer to the macro metadata.
-   * @param log_timestamp Timestamp of the log event.
-   * @param thread_id ID of the thread.
-   * @param thread_name Name of the thread.
-   * @param logger_name Name of the logger.
-   * @param log_level Log level of the message.
-   * @param log_message The log message.
-   * @return True if the log record passes all filters, false otherwise.
-   */
-  QUILL_NODISCARD bool apply_all_filters(MacroMetadata const* log_metadata, uint64_t log_timestamp,
-                                         std::string_view thread_id, std::string_view thread_name,
-                                         std::string_view logger_name, LogLevel log_level,
-                                         std::string_view log_message)
-  {
-    if (log_level < _log_level.load(std::memory_order_relaxed))
-    {
-      return false;
-    }
-
-    // Update our local collection of the filters
-    if (QUILL_UNLIKELY(_new_filter.load(std::memory_order_relaxed)))
-    {
-      // if there is a new filter we have to update
-      _local_filters.clear();
-
-      std::lock_guard<std::recursive_mutex> const lock{_global_filters_lock};
-      for (auto const& filter : _global_filters)
-      {
-        _local_filters.push_back(filter.get());
-      }
-
-      // all filters loaded so change to false
-      _new_filter.store(false, std::memory_order_relaxed);
-    }
-
-    if (_local_filters.empty())
-    {
-      return true;
-    }
-    else
-    {
-      return std::all_of(_local_filters.begin(), _local_filters.end(),
-                         [log_metadata, log_timestamp, thread_id, thread_name, logger_name,
-                          log_level, log_message](Filter* filter_elem)
-                         {
-                           return filter_elem->filter(log_metadata, log_timestamp, thread_id,
-                                                      thread_name, logger_name, log_level, log_message);
-                         });
-    }
-  }
-
-private:
-  /** Local Filters for this sink **/
-  std::vector<Filter*> _local_filters;
-
-  /** Global filter for this sink **/
-  std::vector<std::unique_ptr<Filter>> _global_filters;
-  std::recursive_mutex _global_filters_lock;
-
-  std::atomic<LogLevel> _log_level{LogLevel::TraceL3};
-
-  /** Indicator that a new filter was added **/
-  std::atomic<bool> _new_filter{false};
-};
-
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/sinks/StreamSink.h b/subprojects/quill-4.2.0/quill/include/quill/sinks/StreamSink.h
deleted file mode 100644
index 1f498e1..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/sinks/StreamSink.h
+++ /dev/null
@@ -1,195 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Attributes.h"
-#include "quill/core/Filesystem.h"
-#include "quill/core/LogLevel.h"
-#include "quill/core/QuillError.h"
-#include "quill/sinks/Sink.h"
-
-#include <cerrno>
-#include <cstdint>
-#include <cstdio>
-#include <cstring>
-#include <functional>
-#include <string>
-#include <string_view>
-#include <system_error>
-#include <utility>
-#include <vector>
-
-namespace quill
-{
-/** Forward Declaration **/
-class MacroMetadata;
-
-/**
- * @brief Notifies on file events by calling the appropriate callback, the callback is executed on
- * the backend worker thread
- */
-struct FileEventNotifier
-{
-  std::function<void(fs::path const& filename)> before_open;
-  std::function<void(fs::path const& filename, FILE* f)> after_open;
-  std::function<void(fs::path const& filename, FILE* f)> before_close;
-  std::function<void(fs::path const& filename)> after_close;
-  std::function<std::string(std::string_view message)> before_write;
-};
-
-/**
- * @brief StreamSink class for handling log messages
- */
-class StreamSink : public Sink
-{
-public:
-  /**
-   * @brief Constructor for StreamSink
-   * @param stream The stream type (stdout, stderr, or file)
-   * @param file File pointer for file-based stream
-   * @param file_event_notifier Notifies on file events
-   * @throws QuillError if an invalid parameter is provided
-   */
-  explicit StreamSink(fs::path stream, FILE* file = nullptr,
-                      FileEventNotifier file_event_notifier = FileEventNotifier{})
-    : _filename(std::move(stream)), _file(file), _file_event_notifier(std::move(file_event_notifier))
-  {
-    // reserve stdout and stderr as filenames
-    if (_filename == std::string{"stdout"})
-    {
-      _file = stdout;
-    }
-    else if (_filename == std::string{"stderr"})
-    {
-      _file = stderr;
-    }
-    else if (_filename == std::string{"/dev/null"})
-    {
-      _is_null = true;
-    }
-    else
-    {
-      // first attempt to create any non-existing directories
-      std::error_code ec;
-      fs::path parent_path;
-
-      if (!_filename.parent_path().empty())
-      {
-        parent_path = _filename.parent_path();
-        fs::create_directories(parent_path, ec);
-        if (ec)
-        {
-          // use .string() to also support experimental fs
-          QUILL_THROW(QuillError{std::string{"cannot create directories for path "} +
-                                 parent_path.string() + std::string{" - error: "} + ec.message()});
-        }
-      }
-      else
-      {
-        parent_path = fs::current_path();
-      }
-
-      // convert the parent path to an absolute path
-      fs::path const canonical_path = fs::canonical(parent_path, ec);
-
-      if (ec)
-      {
-        // use .string() to also support experimental fs
-        QUILL_THROW(QuillError{std::string{"cannot create canonical path for path "} +
-                               parent_path.string() + std::string{" - error: "} + ec.message()});
-      }
-
-      // finally replace the given filename's parent_path with the equivalent canonical path
-      _filename = canonical_path / _filename.filename();
-    }
-  }
-
-  ~StreamSink() override = default;
-
-  /**
-   * @brief Writes a formatted log message to the stream
-   * @param log_message The log message to write
-   */
-  QUILL_ATTRIBUTE_HOT void write_log_message(MacroMetadata const* /* log_metadata */,
-                                             uint64_t /* log_timestamp */, std::string_view /* thread_id */,
-                                             std::string_view /* thread_name */,
-                                             std::string_view /* logger_name */, LogLevel /* log_level */,
-                                             std::vector<std::pair<std::string, std::string>> const* /* named_args */,
-                                             std::string_view log_message) override
-  {
-    if (QUILL_UNLIKELY(!_file))
-    {
-      // FileSink::flush() tries to re-open a deleted file and if it fails _file can be null
-      return;
-    }
-
-    if (_file_event_notifier.before_write)
-    {
-      std::string const user_log_message = _file_event_notifier.before_write(log_message);
-
-      safe_fwrite(user_log_message.data(), sizeof(char), user_log_message.size(), _file);
-    }
-    else
-    {
-      safe_fwrite(log_message.data(), sizeof(char), log_message.size(), _file);
-    }
-
-    _write_occurred = true;
-  }
-
-  /**
-   * Flushes the stream
-   */
-  QUILL_ATTRIBUTE_HOT void flush_sink() override
-  {
-    if (!_write_occurred || !_file)
-    {
-      return;
-    }
-
-    _write_occurred = false;
-    fflush(_file);
-  }
-
-  /**
-   * @brief Returns the name of the file
-   * @return The name of the file
-   */
-  QUILL_NODISCARD virtual fs::path const& get_filename() const noexcept { return _filename; }
-
-  /**
-   * @brief Checks if the stream is null
-   * @return True if the stream is null, false otherwise
-   */
-  QUILL_NODISCARD bool is_null() const noexcept { return _is_null; }
-
-protected:
-  /**
-   * @brief Writes data safely to the stream
-   * @param ptr Pointer to the data to be written
-   * @param size Size of each element to be written
-   * @param count Number of elements to write
-   * @param stream The stream to write to
-   */
-  QUILL_ATTRIBUTE_HOT static void safe_fwrite(void const* ptr, size_t size, size_t count, FILE* stream)
-  {
-    size_t const written = std::fwrite(ptr, size, count, stream);
-
-    if (QUILL_UNLIKELY(written < count))
-    {
-      QUILL_THROW(QuillError{std::string{"fwrite failed errno: "} + std::to_string(errno) +
-                             " error: " + strerror(errno)});
-    }
-  }
-
-protected:
-  fs::path _filename;
-  FILE* _file{nullptr};
-  FileEventNotifier _file_event_notifier;
-  bool _is_null{false};
-  bool _write_occurred{false};
-};
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/include/quill/std/Array.h b/subprojects/quill-4.2.0/quill/include/quill/std/Array.h
deleted file mode 100644
index bf7c108..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/std/Array.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/ranges.h"
-
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <type_traits>
-#include <vector>
-
-#if defined(_WIN32)
-  #include <string>
-#endif
-
-namespace quill::detail
-{
-/***/
-template <typename T, size_t N>
-struct ArgSizeCalculator<std::array<T, N>>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache, std::array<T, N> const& arg) noexcept
-  {
-    if constexpr (std::disjunction_v<std::is_arithmetic<T>, std::is_enum<T>>)
-    {
-      // For built-in types, such as arithmetic or enum types, iteration is unnecessary
-      return sizeof(T) * N;
-    }
-    else
-    {
-      // For other complex types it's essential to determine the exact size of each element.
-      // For instance, in the case of a collection of std::string, we need to know the exact size
-      // of each string as we will be copying them directly to our queue buffer.
-      size_t total_size{0};
-
-      for (auto const& elem : arg)
-      {
-        total_size += ArgSizeCalculator<T>::calculate(conditional_arg_size_cache, elem);
-      }
-
-      return total_size;
-    }
-  }
-};
-
-/***/
-template <typename T, size_t N>
-struct Encoder<std::array<T, N>>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index, std::array<T, N> const& arg) noexcept
-  {
-    for (auto const& elem : arg)
-    {
-      Encoder<T>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, elem);
-    }
-  }
-};
-
-/***/
-template <typename T, size_t N>
-#if defined(_WIN32)
-struct Decoder<std::array<T, N>,
-               std::enable_if_t<std::negation_v<std::disjunction<std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                                                 std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>>
-#else
-struct Decoder<std::array<T, N>>
-#endif
-{
-  static std::array<T, N> decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    std::array<T, N> arg;
-
-    for (size_t i = 0; i < N; ++i)
-    {
-      arg[i] = Decoder<T>::decode(buffer, nullptr);
-    }
-
-    if (args_store)
-    {
-      args_store->push_back(arg);
-    }
-
-    return arg;
-  }
-};
-
-#if defined(_WIN32)
-/***/
-template <typename T, size_t N>
-struct Decoder<std::array<T, N>,
-               std::enable_if_t<std::disjunction_v<std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                                   std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>
-{
-  /**
-   * Chaining stl types not supported for wstrings so we do not return anything
-   */
-  static void decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    if (args_store)
-    {
-      std::vector<std::string> encoded_values;
-      encoded_values.reserve(N);
-
-      for (size_t i = 0; i < N; ++i)
-      {
-        std::wstring_view v = Decoder<T>::decode(buffer, nullptr);
-        encoded_values.emplace_back(utf8_encode(v));
-      }
-
-      args_store->push_back(encoded_values);
-    }
-  }
-};
-#endif
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/std/Deque.h b/subprojects/quill-4.2.0/quill/include/quill/std/Deque.h
deleted file mode 100644
index f3e4013..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/std/Deque.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/ranges.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <deque>
-#include <type_traits>
-#include <vector>
-
-#if defined(_WIN32)
-  #include <string>
-#endif
-
-namespace quill::detail
-{
-/***/
-template <typename T, typename Allocator>
-struct ArgSizeCalculator<std::deque<T, Allocator>>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache, std::deque<T, Allocator> const& arg) noexcept
-  {
-    // We need to store the size of the deque in the buffer, so we reserve space for it.
-    // We add sizeof(size_t) bytes to accommodate the size information.
-    size_t total_size{sizeof(size_t)};
-
-    if constexpr (std::disjunction_v<std::is_arithmetic<T>, std::is_enum<T>>)
-    {
-      // For built-in types, such as arithmetic or enum types, iteration is unnecessary
-      total_size += sizeof(T) * arg.size();
-    }
-    else
-    {
-      // For other complex types it's essential to determine the exact size of each element.
-      // For instance, in the case of a collection of std::string, we need to know the exact size
-      // of each string as we will be copying them directly to our queue buffer.
-      for (auto const& elem : arg)
-      {
-        total_size += ArgSizeCalculator<T>::calculate(conditional_arg_size_cache, elem);
-      }
-    }
-
-    return total_size;
-  }
-};
-
-/***/
-template <typename T, typename Allocator>
-struct Encoder<std::deque<T, Allocator>>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index, std::deque<T, Allocator> const& arg) noexcept
-  {
-    Encoder<size_t>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index,
-                            arg.size());
-
-    for (auto const& elem : arg)
-    {
-      Encoder<T>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, elem);
-    }
-  }
-};
-
-/***/
-template <typename T, typename Allocator>
-#if defined(_WIN32)
-struct Decoder<std::deque<T, Allocator>,
-               std::enable_if_t<std::negation_v<std::disjunction<std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                                                 std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>>
-#else
-struct Decoder<std::deque<T, Allocator>>
-#endif
-{
-  static std::deque<T, Allocator> decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    std::deque<T, Allocator> arg;
-
-    // Read the size of the deque
-    size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-    arg.resize(number_of_elements);
-
-    for (size_t i = 0; i < number_of_elements; ++i)
-    {
-      arg[i] = Decoder<T>::decode(buffer, nullptr);
-    }
-
-    if (args_store)
-    {
-      args_store->push_back(arg);
-    }
-
-    return arg;
-  }
-};
-
-#if defined(_WIN32)
-/***/
-template <typename T, typename Allocator>
-struct Decoder<std::deque<T, Allocator>,
-               std::enable_if_t<std::disjunction_v<std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                                   std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>
-{
-  /**
-   * Chaining stl types not supported for wstrings so we do not return anything
-   */
-  static void decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    if (args_store)
-    {
-      // Read the size of the vector
-      size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-
-      std::vector<std::string> encoded_values;
-      encoded_values.reserve(number_of_elements);
-
-      for (size_t i = 0; i < number_of_elements; ++i)
-      {
-        std::wstring_view v = Decoder<T>::decode(buffer, nullptr);
-        encoded_values.emplace_back(utf8_encode(v));
-      }
-
-      args_store->push_back(encoded_values);
-    }
-  }
-};
-#endif
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/std/FilesystemPath.h b/subprojects/quill-4.2.0/quill/include/quill/std/FilesystemPath.h
deleted file mode 100644
index 2b014a1..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/std/FilesystemPath.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-#include "quill/core/Filesystem.h"
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/std.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <string>
-#include <type_traits>
-
-namespace quill::detail
-{
-/***/
-template <>
-struct ArgSizeCalculator<fs::path>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache, fs::path const& arg) noexcept
-  {
-    if constexpr (std::is_same_v<fs::path::string_type, std::string>)
-    {
-      return ArgSizeCalculator<std::string>::calculate(conditional_arg_size_cache, arg.string());
-    }
-#if defined(_WIN32)
-    else if constexpr (std::is_same_v<fs::path::string_type, std::wstring>)
-    {
-      return ArgSizeCalculator<std::wstring>::calculate(conditional_arg_size_cache, arg.wstring());
-    }
-#endif
-  }
-};
-
-/***/
-template <>
-struct Encoder<fs::path>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index, fs::path const& arg) noexcept
-  {
-    if constexpr (std::is_same_v<fs::path::string_type, std::string>)
-    {
-      Encoder<std::string>::encode(buffer, conditional_arg_size_cache,
-                                   conditional_arg_size_cache_index, arg.string());
-    }
-#if defined(_WIN32)
-    else if constexpr (std::is_same_v<fs::path::string_type, std::wstring>)
-    {
-      Encoder<std::wstring>::encode(buffer, conditional_arg_size_cache,
-                                    conditional_arg_size_cache_index, arg.wstring());
-    }
-#endif
-  }
-};
-
-/***/
-template <>
-struct Decoder<fs::path>
-{
-  static fs::path decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    fs::path arg;
-
-    if constexpr (std::is_same_v<fs::path::string_type, std::string>)
-    {
-      arg = Decoder<std::string_view>::decode(buffer, nullptr);
-    }
-#if defined(_WIN32)
-    else if constexpr (std::is_same_v<fs::path::string_type, std::wstring>)
-    {
-      arg = Decoder<std::wstring_view>::decode(buffer, nullptr);
-    }
-#endif
-
-    if (args_store)
-    {
-      args_store->push_back(arg);
-    }
-
-    return arg;
-  }
-};
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/std/ForwardList.h b/subprojects/quill-4.2.0/quill/include/quill/std/ForwardList.h
deleted file mode 100644
index 69b258f..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/std/ForwardList.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/ranges.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <forward_list>
-#include <vector>
-
-#if defined(_WIN32)
-  #include <string>
-#endif
-
-namespace quill::detail
-{
-/***/
-template <typename T, typename Allocator>
-struct ArgSizeCalculator<std::forward_list<T, Allocator>>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache,
-                          std::forward_list<T, Allocator> const& arg) noexcept
-  {
-    // We need to store the size of the forward_list in the buffer, so we reserve space for it.
-    // We add sizeof(size_t) bytes to accommodate the size information.
-    size_t total_size{sizeof(size_t)};
-
-    // Cache the number of elements of the forward list to avoid iterating again when
-    // encoding. This information is inserted first to maintain sequence in the cache.
-    // It will be replaced with the actual count after calculating the size of elements.
-    size_t number_of_elements{0};
-    conditional_arg_size_cache.push_back(number_of_elements);
-    size_t const index = conditional_arg_size_cache.size() - 1u;
-
-    for (auto const& elem : arg)
-    {
-      total_size += ArgSizeCalculator<T>::calculate(conditional_arg_size_cache, elem);
-      ++number_of_elements;
-    }
-
-    conditional_arg_size_cache[index] = number_of_elements;
-    return total_size;
-  }
-};
-
-/***/
-template <typename T, typename Allocator>
-struct Encoder<std::forward_list<T, Allocator>>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index, std::forward_list<T, Allocator> const& arg) noexcept
-  {
-    // First encode the number of elements of the forward list
-    size_t const elems_num = conditional_arg_size_cache[conditional_arg_size_cache_index++];
-    Encoder<size_t>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, elems_num);
-
-    for (auto const& elem : arg)
-    {
-      Encoder<T>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, elem);
-    }
-  }
-};
-
-/***/
-template <typename T, typename Allocator>
-#if defined(_WIN32)
-struct Decoder<std::forward_list<T, Allocator>,
-               std::enable_if_t<std::negation_v<std::disjunction<std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                                                 std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>>
-#else
-struct Decoder<std::forward_list<T, Allocator>>
-#endif
-{
-  static std::forward_list<T, Allocator> decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    std::forward_list<T, Allocator> arg;
-
-    // Read the size
-    size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-
-    if (number_of_elements > 0)
-    {
-      arg.emplace_front(Decoder<T>::decode(buffer, nullptr));
-    }
-
-    for (size_t i = 1; i < number_of_elements; ++i)
-    {
-      auto it = arg.before_begin();
-      for (auto curr = arg.begin(); curr != arg.end(); ++it, ++curr)
-      {
-        // iterate
-      }
-
-      // Insert after the last element
-      arg.emplace_after(it, Decoder<T>::decode(buffer, nullptr));
-    }
-
-    if (args_store)
-    {
-      args_store->push_back(arg);
-    }
-
-    return arg;
-  }
-};
-
-#if defined(_WIN32)
-/***/
-template <typename T, typename Allocator>
-struct Decoder<std::forward_list<T, Allocator>,
-               std::enable_if_t<std::disjunction_v<std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                                   std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>
-{
-  /**
-   * Chaining stl types not supported for wstrings so we do not return anything
-   */
-  static void decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    if (args_store)
-    {
-      // Read the size of the vector
-      size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-
-      std::vector<std::string> encoded_values;
-      encoded_values.reserve(number_of_elements);
-
-      for (size_t i = 0; i < number_of_elements; ++i)
-      {
-        std::wstring_view v = Decoder<T>::decode(buffer, nullptr);
-        encoded_values.emplace_back(utf8_encode(v));
-      }
-
-      args_store->push_back(encoded_values);
-    }
-  }
-};
-#endif
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/std/List.h b/subprojects/quill-4.2.0/quill/include/quill/std/List.h
deleted file mode 100644
index a68a4cb..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/std/List.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/ranges.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <list>
-#include <type_traits>
-#include <vector>
-
-#if defined(_WIN32)
-  #include <string>
-#endif
-
-namespace quill::detail
-{
-/***/
-template <typename T, typename Allocator>
-struct ArgSizeCalculator<std::list<T, Allocator>>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache, std::list<T, Allocator> const& arg) noexcept
-  {
-    // We need to store the size of the list in the buffer, so we reserve space for it.
-    // We add sizeof(size_t) bytes to accommodate the size information.
-    size_t total_size{sizeof(size_t)};
-
-    if constexpr (std::disjunction_v<std::is_arithmetic<T>, std::is_enum<T>>)
-    {
-      // For built-in types, such as arithmetic or enum types, iteration is unnecessary
-      total_size += sizeof(T) * arg.size();
-    }
-    else
-    {
-      // For other complex types it's essential to determine the exact size of each element.
-      // For instance, in the case of a collection of std::string, we need to know the exact size
-      // of each string as we will be copying them directly to our queue buffer.
-      for (auto const& elem : arg)
-      {
-        total_size += ArgSizeCalculator<T>::calculate(conditional_arg_size_cache, elem);
-      }
-    }
-
-    return total_size;
-  }
-};
-
-/***/
-template <typename T, typename Allocator>
-struct Encoder<std::list<T, Allocator>>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index, std::list<T, Allocator> const& arg) noexcept
-  {
-    Encoder<size_t>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index,
-                            arg.size());
-
-    for (auto const& elem : arg)
-    {
-      Encoder<T>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, elem);
-    }
-  }
-};
-
-/***/
-template <typename T, typename Allocator>
-#if defined(_WIN32)
-struct Decoder<std::list<T, Allocator>,
-               std::enable_if_t<std::negation_v<std::disjunction<std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                                                 std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>>
-#else
-struct Decoder<std::list<T, Allocator>>
-#endif
-{
-  static std::list<T, Allocator> decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    std::list<T, Allocator> arg;
-
-    // Read the size of the list
-    size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-
-    for (size_t i = 0; i < number_of_elements; ++i)
-    {
-      arg.emplace_back(Decoder<T>::decode(buffer, nullptr));
-    }
-
-    if (args_store)
-    {
-      args_store->push_back(arg);
-    }
-
-    return arg;
-  }
-};
-
-#if defined(_WIN32)
-/***/
-template <typename T, typename Allocator>
-struct Decoder<std::list<T, Allocator>,
-               std::enable_if_t<std::disjunction_v<std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                                   std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>
-{
-  /**
-   * Chaining stl types not supported for wstrings so we do not return anything
-   */
-  static void decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    if (args_store)
-    {
-      // Read the size of the vector
-      size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-
-      std::vector<std::string> encoded_values;
-      encoded_values.reserve(number_of_elements);
-
-      for (size_t i = 0; i < number_of_elements; ++i)
-      {
-        std::wstring_view v = Decoder<T>::decode(buffer, nullptr);
-        encoded_values.emplace_back(utf8_encode(v));
-      }
-
-      args_store->push_back(encoded_values);
-    }
-  }
-};
-#endif
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/std/Map.h b/subprojects/quill-4.2.0/quill/include/quill/std/Map.h
deleted file mode 100644
index 988466c..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/std/Map.h
+++ /dev/null
@@ -1,195 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-#include "quill/std/Pair.h"
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/ranges.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <map>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-namespace quill::detail
-{
-/***/
-template <template <typename...> class MapType, typename Key, typename T, typename Compare, typename Allocator>
-struct ArgSizeCalculator<
-  MapType<Key, T, Compare, Allocator>,
-  std::enable_if_t<std::disjunction_v<std::is_same<MapType<Key, T, Compare, Allocator>, std::map<Key, T, Compare, Allocator>>,
-                                      std::is_same<MapType<Key, T, Compare, Allocator>, std::multimap<Key, T, Compare, Allocator>>>>>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache,
-                          MapType<Key, T, Compare, Allocator> const& arg) noexcept
-  {
-    // We need to store the size of the set in the buffer, so we reserve space for it.
-    // We add sizeof(size_t) bytes to accommodate the size information.
-    size_t total_size{sizeof(size_t)};
-
-    if constexpr (std::conjunction_v<std::disjunction<std::is_arithmetic<Key>, std::is_enum<Key>>,
-                                     std::disjunction<std::is_arithmetic<T>, std::is_enum<T>>>)
-    {
-      // For built-in types, such as arithmetic or enum types, iteration is unnecessary
-      total_size += (sizeof(Key) + sizeof(T)) * arg.size();
-    }
-    else
-    {
-      // For other complex types it's essential to determine the exact size of each element.
-      // For instance, in the case of a collection of std::string, we need to know the exact size
-      // of each string as we will be copying them directly to our queue buffer.
-      for (auto const& elem : arg)
-      {
-        total_size += ArgSizeCalculator<std::pair<Key, T>>::calculate(conditional_arg_size_cache, elem);
-      }
-    }
-
-    return total_size;
-  }
-};
-
-/***/
-template <template <typename...> class MapType, typename Key, typename T, typename Compare, typename Allocator>
-struct Encoder<MapType<Key, T, Compare, Allocator>,
-               std::enable_if_t<std::disjunction_v<std::is_same<MapType<Key, T, Compare, Allocator>, std::map<Key, T, Compare, Allocator>>,
-                                                   std::is_same<MapType<Key, T, Compare, Allocator>, std::multimap<Key, T, Compare, Allocator>>>>>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index,
-                     MapType<Key, T, Compare, Allocator> const& arg) noexcept
-  {
-    Encoder<size_t>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index,
-                            arg.size());
-
-    for (auto const& elem : arg)
-    {
-      Encoder<std::pair<Key, T>>::encode(buffer, conditional_arg_size_cache,
-                                         conditional_arg_size_cache_index, elem);
-    }
-  }
-};
-
-/***/
-template <template <typename...> class MapType, typename Key, typename T, typename Compare, typename Allocator>
-#if defined(_WIN32)
-struct Decoder<
-  MapType<Key, T, Compare, Allocator>,
-  std::enable_if_t<std::conjunction_v<
-    std::disjunction<std::is_same<MapType<Key, T, Compare, Allocator>, std::map<Key, T, Compare, Allocator>>,
-                     std::is_same<MapType<Key, T, Compare, Allocator>, std::multimap<Key, T, Compare, Allocator>>>,
-    std::negation<std::disjunction<std::is_same<Key, wchar_t*>, std::is_same<Key, wchar_t const*>, std::is_same<Key, std::wstring>,
-                                   std::is_same<Key, std::wstring_view>, std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                   std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>>>
-#else
-struct Decoder<MapType<Key, T, Compare, Allocator>,
-               std::enable_if_t<std::disjunction_v<std::is_same<MapType<Key, T, Compare, Allocator>, std::map<Key, T, Compare, Allocator>>,
-                                                   std::is_same<MapType<Key, T, Compare, Allocator>, std::multimap<Key, T, Compare, Allocator>>>>>
-#endif
-{
-  static MapType<Key, T, Compare, Allocator> decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    MapType<Key, T, Compare, Allocator> arg;
-
-    // Read the size of the set
-    size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-
-    for (size_t i = 0; i < number_of_elements; ++i)
-    {
-      arg.insert(Decoder<std::pair<Key, T>>::decode(buffer, nullptr));
-    }
-
-    if (args_store)
-    {
-      args_store->push_back(arg);
-    }
-
-    return arg;
-  }
-};
-
-#if defined(_WIN32)
-/***/
-template <template <typename...> class MapType, typename Key, typename T, typename Compare, typename Allocator>
-struct Decoder<
-  MapType<Key, T, Compare, Allocator>,
-  std::enable_if_t<std::conjunction_v<
-    std::disjunction<std::is_same<MapType<Key, T, Compare, Allocator>, std::map<Key, T, Compare, Allocator>>,
-                     std::is_same<MapType<Key, T, Compare, Allocator>, std::multimap<Key, T, Compare, Allocator>>>,
-    std::disjunction<std::is_same<Key, wchar_t*>, std::is_same<Key, wchar_t const*>, std::is_same<Key, std::wstring>, std::is_same<Key, std::wstring_view>,
-                     std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>, std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>>
-{
-  static void decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    if (args_store)
-    {
-      // Read the size of the vector
-      size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-
-      constexpr bool wide_key_t = std::is_same_v<Key, wchar_t*> || std::is_same_v<Key, wchar_t const*> ||
-        std::is_same_v<Key, std::wstring> || std::is_same_v<Key, std::wstring_view>;
-
-      constexpr bool wide_value_t = std::is_same_v<T, wchar_t*> || std::is_same_v<T, wchar_t const*> ||
-        std::is_same_v<T, std::wstring> || std::is_same_v<T, std::wstring_view>;
-
-      if constexpr (wide_key_t && !wide_value_t)
-      {
-        std::vector<std::pair<std::string, T>> encoded_values;
-        encoded_values.reserve(number_of_elements);
-
-        for (size_t i = 0; i < number_of_elements; ++i)
-        {
-          std::pair<std::string, T> elem;
-          std::wstring_view v = Decoder<Key>::decode(buffer, nullptr);
-          elem.first = utf8_encode(v);
-          elem.second = Decoder<T>::decode(buffer, nullptr);
-          encoded_values.emplace_back(elem);
-        }
-
-        args_store->push_back(encoded_values);
-      }
-      else if constexpr (!wide_key_t && wide_value_t)
-      {
-        std::vector<std::pair<Key, std::string>> encoded_values;
-        encoded_values.reserve(number_of_elements);
-
-        for (size_t i = 0; i < number_of_elements; ++i)
-        {
-          std::pair<Key, std::string> elem;
-          elem.first = Decoder<Key>::decode(buffer, nullptr);
-          std::wstring_view v = Decoder<T>::decode(buffer, nullptr);
-          elem.second = utf8_encode(v);
-          encoded_values.emplace_back(elem);
-        }
-
-        args_store->push_back(encoded_values);
-      }
-      else
-      {
-        std::vector<std::pair<std::string, std::string>> encoded_values;
-        encoded_values.reserve(number_of_elements);
-
-        for (size_t i = 0; i < number_of_elements; ++i)
-        {
-          std::pair<std::string, std::string> elem;
-          std::wstring_view v1 = Decoder<Key>::decode(buffer, nullptr);
-          elem.first = utf8_encode(v1);
-          std::wstring_view v2 = Decoder<T>::decode(buffer, nullptr);
-          elem.second = utf8_encode(v2);
-          encoded_values.emplace_back(elem);
-        }
-
-        args_store->push_back(encoded_values);
-      }
-    }
-  }
-};
-#endif
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/std/Optional.h b/subprojects/quill-4.2.0/quill/include/quill/std/Optional.h
deleted file mode 100644
index 9d75013..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/std/Optional.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/std.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <optional>
-#include <vector>
-
-#if defined(_WIN32)
-  #include <string>
-#endif
-
-namespace quill::detail
-{
-/***/
-template <typename T>
-struct ArgSizeCalculator<std::optional<T>>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache, std::optional<T> const& arg) noexcept
-  {
-    // We need to store the size of the vector in the buffer, so we reserve space for it.
-    // We add sizeof(bool) bytes to accommodate the size information.
-    size_t total_size{sizeof(bool)};
-
-    if (arg.has_value())
-    {
-      total_size += ArgSizeCalculator<T>::calculate(conditional_arg_size_cache, *arg);
-    }
-
-    return total_size;
-  }
-};
-
-/***/
-template <typename T>
-struct Encoder<std::optional<T>>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index, std::optional<T> const& arg) noexcept
-  {
-    Encoder<bool>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, arg.has_value());
-
-    if (arg.has_value())
-    {
-      Encoder<T>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, *arg);
-    }
-  }
-};
-
-/***/
-template <typename T>
-#if defined(_WIN32)
-struct Decoder<std::optional<T>,
-               std::enable_if_t<std::negation_v<std::disjunction<std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                                                 std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>>
-#else
-struct Decoder<std::optional<T>>
-#endif
-{
-  static std::optional<T> decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    std::optional<T> arg{std::nullopt};
-
-    bool const has_value = Decoder<bool>::decode(buffer, nullptr);
-    if (has_value)
-    {
-      arg = Decoder<T>::decode(buffer, nullptr);
-    }
-
-    if (args_store)
-    {
-      args_store->push_back(arg);
-    }
-
-    return arg;
-  }
-};
-
-#if defined(_WIN32)
-/***/
-template <typename T>
-struct Decoder<std::optional<T>,
-               std::enable_if_t<std::disjunction_v<std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                                   std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>
-{
-  /**
-   * Chaining stl types not supported for wstrings so we do not return anything
-   */
-  static void decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    if (args_store)
-    {
-      std::string encoded_value{"none"};
-
-      bool const has_value = Decoder<bool>::decode(buffer, nullptr);
-      if (has_value)
-      {
-        std::wstring_view arg = Decoder<T>::decode(buffer, nullptr);
-        encoded_value = "optional(\"";
-        encoded_value += utf8_encode(arg);
-        encoded_value += "\")";
-      }
-
-      args_store->push_back(encoded_value);
-    }
-  }
-};
-#endif
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/std/Pair.h b/subprojects/quill-4.2.0/quill/include/quill/std/Pair.h
deleted file mode 100644
index 2cddba1..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/std/Pair.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/ranges.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <utility>
-
-namespace quill::detail
-{
-/***/
-template <typename T1, typename T2>
-struct ArgSizeCalculator<std::pair<T1, T2>>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache, std::pair<T1, T2> const& arg) noexcept
-  {
-    return ArgSizeCalculator<T1>::calculate(conditional_arg_size_cache, arg.first) +
-      ArgSizeCalculator<T2>::calculate(conditional_arg_size_cache, arg.second);
-  }
-};
-
-/***/
-template <typename T1, typename T2>
-struct Encoder<std::pair<T1, T2>>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index, std::pair<T1, T2> const& arg) noexcept
-  {
-    Encoder<T1>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, arg.first);
-    Encoder<T2>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, arg.second);
-  }
-};
-
-/***/
-template <typename T1, typename T2>
-#if defined(_WIN32)
-struct Decoder<
-  std::pair<T1, T2>,
-  std::enable_if_t<std::negation_v<std::disjunction<
-    std::is_same<T1, wchar_t*>, std::is_same<T1, wchar_t const*>, std::is_same<T1, std::wstring>, std::is_same<T1, std::wstring_view>,
-    std::is_same<T2, wchar_t*>, std::is_same<T2, wchar_t const*>, std::is_same<T2, std::wstring>, std::is_same<T2, std::wstring_view>>>>>
-#else
-struct Decoder<std::pair<T1, T2>>
-#endif
-{
-  static std::pair<T1, T2> decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    std::pair<T1, T2> arg;
-
-    arg.first = Decoder<T1>::decode(buffer, nullptr);
-    arg.second = Decoder<T2>::decode(buffer, nullptr);
-
-    if (args_store)
-    {
-      args_store->push_back(arg);
-    }
-
-    return arg;
-  }
-};
-
-#if defined(_WIN32)
-template <typename T1, typename T2>
-struct Decoder<
-  std::pair<T1, T2>,
-  std::enable_if_t<std::disjunction_v<std::is_same<T1, wchar_t*>, std::is_same<T1, wchar_t const*>, std::is_same<T1, std::wstring>,
-                                      std::is_same<T1, std::wstring_view>, std::is_same<T2, wchar_t*>, std::is_same<T2, wchar_t const*>,
-                                      std::is_same<T2, std::wstring>, std::is_same<T2, std::wstring_view>>>>
-{
-  /**
-   * Chaining stl types not supported for wstrings so we do not return anything
-   */
-  static void decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    constexpr bool wide_t1 = std::is_same_v<T1, wchar_t*> || std::is_same_v<T1, wchar_t const*> ||
-      std::is_same_v<T1, std::wstring> || std::is_same_v<T1, std::wstring_view>;
-
-    constexpr bool wide_t2 = std::is_same_v<T2, wchar_t*> || std::is_same_v<T2, wchar_t const*> ||
-      std::is_same_v<T2, std::wstring> || std::is_same_v<T2, std::wstring_view>;
-
-    if (args_store)
-    {
-      if constexpr (wide_t1 && !wide_t2)
-      {
-        std::pair<std::string, T2> arg;
-
-        std::wstring_view v = Decoder<T1>::decode(buffer, nullptr);
-        arg.first = utf8_encode(v);
-
-        arg.second = Decoder<T2>::decode(buffer, nullptr);
-
-        args_store->push_back(arg);
-      }
-      else if constexpr (!wide_t1 && wide_t2)
-      {
-        std::pair<T1, std::string> arg;
-
-        arg.first = Decoder<T1>::decode(buffer, nullptr);
-
-        std::wstring_view v = Decoder<T2>::decode(buffer, nullptr);
-        arg.second = utf8_encode(v);
-
-        args_store->push_back(arg);
-      }
-      else
-      {
-        std::wstring_view v1 = Decoder<T1>::decode(buffer, nullptr);
-        std::wstring_view v2 = Decoder<T2>::decode(buffer, nullptr);
-        args_store->push_back(std::pair<std::string, std::string>{utf8_encode(v1), utf8_encode(v2)});
-      }
-    }
-  }
-};
-#endif
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/std/Set.h b/subprojects/quill-4.2.0/quill/include/quill/std/Set.h
deleted file mode 100644
index 7f14818..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/std/Set.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/ranges.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <set>
-#include <type_traits>
-#include <vector>
-
-namespace quill::detail
-{
-/***/
-template <template <typename...> class SetType, typename Key, typename Compare, typename Allocator>
-struct ArgSizeCalculator<
-  SetType<Key, Compare, Allocator>,
-  std::enable_if_t<std::disjunction_v<std::is_same<SetType<Key, Compare, Allocator>, std::set<Key, Compare, Allocator>>,
-                                      std::is_same<SetType<Key, Compare, Allocator>, std::multiset<Key, Compare, Allocator>>>>>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache,
-                          SetType<Key, Compare, Allocator> const& arg) noexcept
-  {
-    // We need to store the size of the set in the buffer, so we reserve space for it.
-    // We add sizeof(size_t) bytes to accommodate the size information.
-    size_t total_size{sizeof(size_t)};
-
-    if constexpr (std::disjunction_v<std::is_arithmetic<Key>, std::is_enum<Key>>)
-    {
-      // For built-in types, such as arithmetic or enum types, iteration is unnecessary
-      total_size += sizeof(Key) * arg.size();
-    }
-    else
-    {
-      // For other complex types it's essential to determine the exact size of each element.
-      // For instance, in the case of a collection of std::string, we need to know the exact size
-      // of each string as we will be copying them directly to our queue buffer.
-      for (auto const& elem : arg)
-      {
-        total_size += ArgSizeCalculator<Key>::calculate(conditional_arg_size_cache, elem);
-      }
-    }
-
-    return total_size;
-  }
-};
-
-/***/
-template <template <typename...> class SetType, typename Key, typename Compare, typename Allocator>
-struct Encoder<SetType<Key, Compare, Allocator>,
-               std::enable_if_t<std::disjunction_v<std::is_same<SetType<Key, Compare, Allocator>, std::set<Key, Compare, Allocator>>,
-                                                   std::is_same<SetType<Key, Compare, Allocator>, std::multiset<Key, Compare, Allocator>>>>>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index,
-                     SetType<Key, Compare, Allocator> const& arg) noexcept
-  {
-    Encoder<size_t>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index,
-                            arg.size());
-
-    for (auto const& elem : arg)
-    {
-      Encoder<Key>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, elem);
-    }
-  }
-};
-
-/***/
-template <template <typename...> class SetType, typename Key, typename Compare, typename Allocator>
-#if defined(_WIN32)
-struct Decoder<
-  SetType<Key, Compare, Allocator>,
-  std::enable_if_t<std::conjunction_v<
-    std::disjunction<std::is_same<SetType<Key, Compare, Allocator>, std::set<Key, Compare, Allocator>>,
-                     std::is_same<SetType<Key, Compare, Allocator>, std::multiset<Key, Compare, Allocator>>>,
-    std::negation<std::disjunction<std::is_same<Key, wchar_t*>, std::is_same<Key, wchar_t const*>, std::is_same<Key, std::wstring>, std::is_same<Key, std::wstring_view>>>>>>
-#else
-struct Decoder<SetType<Key, Compare, Allocator>,
-               std::enable_if_t<std::disjunction_v<std::is_same<SetType<Key, Compare, Allocator>, std::set<Key, Compare, Allocator>>,
-                                                   std::is_same<SetType<Key, Compare, Allocator>, std::multiset<Key, Compare, Allocator>>>>>
-#endif
-{
-  static SetType<Key, Compare, Allocator> decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    SetType<Key, Compare, Allocator> arg;
-
-    // Read the size of the set
-    size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-
-    for (size_t i = 0; i < number_of_elements; ++i)
-    {
-      arg.emplace(Decoder<Key>::decode(buffer, nullptr));
-    }
-
-    if (args_store)
-    {
-      args_store->push_back(arg);
-    }
-
-    return arg;
-  }
-};
-
-#if defined(_WIN32)
-/***/
-template <template <typename...> class SetType, typename Key, typename Compare, typename Allocator>
-struct Decoder<
-  SetType<Key, Compare, Allocator>,
-  std::enable_if_t<std::conjunction_v<
-    std::disjunction<std::is_same<SetType<Key, Compare, Allocator>, std::set<Key, Compare, Allocator>>,
-                     std::is_same<SetType<Key, Compare, Allocator>, std::multiset<Key, Compare, Allocator>>>,
-    std::disjunction<std::is_same<Key, wchar_t*>, std::is_same<Key, wchar_t const*>, std::is_same<Key, std::wstring>, std::is_same<Key, std::wstring_view>>>>>
-{
-  /**
-   * Chaining stl types not supported for wstrings so we do not return anything
-   */
-  static void decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    if (args_store)
-    {
-      // Read the size of the vector
-      size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-
-      std::vector<std::string> encoded_values;
-      encoded_values.reserve(number_of_elements);
-
-      for (size_t i = 0; i < number_of_elements; ++i)
-      {
-        std::wstring_view v = Decoder<Key>::decode(buffer, nullptr);
-        encoded_values.emplace_back(utf8_encode(v));
-      }
-
-      args_store->push_back(encoded_values);
-    }
-  }
-};
-#endif
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/std/Tuple.h b/subprojects/quill-4.2.0/quill/include/quill/std/Tuple.h
deleted file mode 100644
index e24ee32..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/std/Tuple.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/ranges.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <tuple>
-#include <vector>
-
-namespace quill::detail
-{
-/***/
-template <typename... Types>
-struct ArgSizeCalculator<std::tuple<Types...>>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache, std::tuple<Types...> const& arg) noexcept
-  {
-    size_t total_size{0};
-
-    std::apply(
-      [&total_size, &conditional_arg_size_cache](auto const&... elems)
-      {
-        ((total_size += ArgSizeCalculator<std::decay_t<decltype(elems)>>::calculate(conditional_arg_size_cache, elems)),
-         ...);
-      },
-      arg);
-
-    return total_size;
-  }
-};
-
-/***/
-template <typename... Types>
-struct Encoder<std::tuple<Types...>>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index, std::tuple<Types...> const& arg) noexcept
-  {
-    std::apply(
-      [&conditional_arg_size_cache, &conditional_arg_size_cache_index, &buffer](auto const&... elems)
-      {
-        ((Encoder<std::decay_t<decltype(elems)>>::encode(buffer, conditional_arg_size_cache,
-                                                         conditional_arg_size_cache_index, elems)),
-         ...);
-      },
-      arg);
-  }
-};
-
-/***/
-template <typename... Types>
-struct Decoder<std::tuple<Types...>>
-{
-  static auto decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    std::tuple<Types...> arg{};
-
-    std::apply([&buffer](auto&... elems)
-               { ((elems = Decoder<std::decay_t<decltype(elems)>>::decode(buffer, nullptr)), ...); }, arg);
-
-    if (args_store)
-    {
-      args_store->push_back(arg);
-    }
-
-    return arg;
-  }
-};
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/std/UnorderedMap.h b/subprojects/quill-4.2.0/quill/include/quill/std/UnorderedMap.h
deleted file mode 100644
index 839d500..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/std/UnorderedMap.h
+++ /dev/null
@@ -1,203 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-#include "quill/std/Pair.h"
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/ranges.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <type_traits>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-namespace quill::detail
-{
-/***/
-template <template <typename...> class UnorderedMapType, typename Key, typename T, typename Hash, typename KeyEqual, typename Allocator>
-struct ArgSizeCalculator<
-  UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>,
-  std::enable_if_t<std::disjunction_v<
-    std::is_same<UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>, std::unordered_map<Key, T, Hash, KeyEqual, Allocator>>,
-    std::is_same<UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>, std::unordered_multimap<Key, T, Hash, KeyEqual, Allocator>>>>>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache,
-                          UnorderedMapType<Key, T, Hash, KeyEqual, Allocator> const& arg) noexcept
-  {
-    // We need to store the size of the set in the buffer, so we reserve space for it.
-    // We add sizeof(size_t) bytes to accommodate the size information.
-    size_t total_size{sizeof(size_t)};
-
-    if constexpr (std::conjunction_v<std::disjunction<std::is_arithmetic<Key>, std::is_enum<Key>>,
-                                     std::disjunction<std::is_arithmetic<T>, std::is_enum<T>>>)
-    {
-      // For built-in types, such as arithmetic or enum types, iteration is unnecessary
-      total_size += (sizeof(Key) + sizeof(T)) * arg.size();
-    }
-    else
-    {
-      // For other complex types it's essential to determine the exact size of each element.
-      // For instance, in the case of a collection of std::string, we need to know the exact size
-      // of each string as we will be copying them directly to our queue buffer.
-      for (auto const& elem : arg)
-      {
-        total_size += ArgSizeCalculator<std::pair<Key, T>>::calculate(conditional_arg_size_cache, elem);
-      }
-    }
-
-    return total_size;
-  }
-};
-
-/***/
-template <template <typename...> class UnorderedMapType, typename Key, typename T, typename Hash, typename KeyEqual, typename Allocator>
-struct Encoder<UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>,
-               std::enable_if_t<std::disjunction_v<
-                 std::is_same<UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>, std::unordered_map<Key, T, Hash, KeyEqual, Allocator>>,
-                 std::is_same<UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>, std::unordered_multimap<Key, T, Hash, KeyEqual, Allocator>>>>>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index,
-                     UnorderedMapType<Key, T, Hash, KeyEqual, Allocator> const& arg) noexcept
-  {
-    Encoder<size_t>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index,
-                            arg.size());
-
-    for (auto const& elem : arg)
-    {
-      Encoder<std::pair<Key, T>>::encode(buffer, conditional_arg_size_cache,
-                                         conditional_arg_size_cache_index, elem);
-    }
-  }
-};
-
-/***/
-template <template <typename...> class UnorderedMapType, typename Key, typename T, typename Hash, typename KeyEqual, typename Allocator>
-#if defined(_WIN32)
-struct Decoder<
-  UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>,
-  std::enable_if_t<std::conjunction_v<
-    std::disjunction<std::is_same<UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>, std::unordered_map<Key, T, Hash, KeyEqual, Allocator>>,
-                     std::is_same<UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>, std::unordered_multimap<Key, T, Hash, KeyEqual, Allocator>>>,
-    std::negation<std::disjunction<std::is_same<Key, wchar_t*>, std::is_same<Key, wchar_t const*>, std::is_same<Key, std::wstring>,
-                                   std::is_same<Key, std::wstring_view>, std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                   std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>>>
-#else
-struct Decoder<UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>,
-               std::enable_if_t<std::disjunction_v<
-                 std::is_same<UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>, std::unordered_map<Key, T, Hash, KeyEqual, Allocator>>,
-                 std::is_same<UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>, std::unordered_multimap<Key, T, Hash, KeyEqual, Allocator>>>>>
-#endif
-{
-  static UnorderedMapType<Key, T, Hash, KeyEqual, Allocator> decode(std::byte*& buffer,
-                                                                    DynamicFormatArgStore* args_store)
-  {
-    UnorderedMapType<Key, T, Hash, KeyEqual, Allocator> arg;
-
-    // Read the size of the set
-    size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-    arg.reserve(number_of_elements);
-
-    for (size_t i = 0; i < number_of_elements; ++i)
-    {
-      arg.insert(Decoder<std::pair<Key, T>>::decode(buffer, nullptr));
-    }
-
-    if (args_store)
-    {
-      args_store->push_back(arg);
-    }
-
-    return arg;
-  }
-};
-
-#if defined(_WIN32)
-/***/
-template <template <typename...> class UnorderedMapType, typename Key, typename T, typename Hash, typename KeyEqual, typename Allocator>
-struct Decoder<
-  UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>,
-  std::enable_if_t<std::conjunction_v<
-    std::disjunction<std::is_same<UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>, std::unordered_map<Key, T, Hash, KeyEqual, Allocator>>,
-                     std::is_same<UnorderedMapType<Key, T, Hash, KeyEqual, Allocator>, std::unordered_multimap<Key, T, Hash, KeyEqual, Allocator>>>,
-    std::disjunction<std::is_same<Key, wchar_t*>, std::is_same<Key, wchar_t const*>, std::is_same<Key, std::wstring>, std::is_same<Key, std::wstring_view>,
-                     std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>, std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>>
-{
-  /**
-   * Chaining stl types not supported for wstrings so we do not return anything
-   */
-  static void decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    if (args_store)
-    {
-      // Read the size of the vector
-      size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-
-      constexpr bool wide_key_t = std::is_same_v<Key, wchar_t*> || std::is_same_v<Key, wchar_t const*> ||
-        std::is_same_v<Key, std::wstring> || std::is_same_v<Key, std::wstring_view>;
-
-      constexpr bool wide_value_t = std::is_same_v<T, wchar_t*> || std::is_same_v<T, wchar_t const*> ||
-        std::is_same_v<T, std::wstring> || std::is_same_v<T, std::wstring_view>;
-
-      if constexpr (wide_key_t && !wide_value_t)
-      {
-        std::vector<std::pair<std::string, T>> encoded_values;
-        encoded_values.reserve(number_of_elements);
-
-        for (size_t i = 0; i < number_of_elements; ++i)
-        {
-          std::pair<std::string, T> elem;
-          std::wstring_view v = Decoder<Key>::decode(buffer, nullptr);
-          elem.first = utf8_encode(v);
-          elem.second = Decoder<T>::decode(buffer, nullptr);
-          encoded_values.emplace_back(elem);
-        }
-
-        args_store->push_back(encoded_values);
-      }
-      else if constexpr (!wide_key_t && wide_value_t)
-      {
-        std::vector<std::pair<Key, std::string>> encoded_values;
-        encoded_values.reserve(number_of_elements);
-
-        for (size_t i = 0; i < number_of_elements; ++i)
-        {
-          std::pair<Key, std::string> elem;
-          elem.first = Decoder<Key>::decode(buffer, nullptr);
-          std::wstring_view v = Decoder<T>::decode(buffer, nullptr);
-          elem.second = utf8_encode(v);
-          encoded_values.emplace_back(elem);
-        }
-
-        args_store->push_back(encoded_values);
-      }
-      else
-      {
-        std::vector<std::pair<std::string, std::string>> encoded_values;
-        encoded_values.reserve(number_of_elements);
-
-        for (size_t i = 0; i < number_of_elements; ++i)
-        {
-          std::pair<std::string, std::string> elem;
-          std::wstring_view v1 = Decoder<Key>::decode(buffer, nullptr);
-          elem.first = utf8_encode(v1);
-          std::wstring_view v2 = Decoder<T>::decode(buffer, nullptr);
-          elem.second = utf8_encode(v2);
-          encoded_values.emplace_back(elem);
-        }
-
-        args_store->push_back(encoded_values);
-      }
-    }
-  }
-};
-#endif
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/std/UnorderedSet.h b/subprojects/quill-4.2.0/quill/include/quill/std/UnorderedSet.h
deleted file mode 100644
index 46331aa..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/std/UnorderedSet.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/ranges.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <type_traits>
-#include <unordered_set>
-#include <vector>
-
-namespace quill::detail
-{
-/***/
-template <template <typename...> class UnorderedSetType, typename Key, typename Hash, typename KeyEqual, typename Allocator>
-struct ArgSizeCalculator<
-  UnorderedSetType<Key, Hash, KeyEqual, Allocator>,
-  std::enable_if_t<std::disjunction_v<std::is_same<UnorderedSetType<Key, Hash, KeyEqual, Allocator>, std::unordered_set<Key, Hash, KeyEqual, Allocator>>,
-                                      std::is_same<UnorderedSetType<Key, Hash, KeyEqual, Allocator>, std::unordered_multiset<Key, Hash, KeyEqual, Allocator>>>>>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache,
-                          UnorderedSetType<Key, Hash, KeyEqual, Allocator> const& arg) noexcept
-  {
-    // We need to store the size of the set in the buffer, so we reserve space for it.
-    // We add sizeof(size_t) bytes to accommodate the size information.
-    size_t total_size{sizeof(size_t)};
-
-    if constexpr (std::disjunction_v<std::is_arithmetic<Key>, std::is_enum<Key>>)
-    {
-      // For built-in types, such as arithmetic or enum types, iteration is unnecessary
-      total_size += sizeof(Key) * arg.size();
-    }
-    else
-    {
-      // For other complex types it's essential to determine the exact size of each element.
-      // For instance, in the case of a collection of std::string, we need to know the exact size
-      // of each string as we will be copying them directly to our queue buffer.
-      for (auto const& elem : arg)
-      {
-        total_size += ArgSizeCalculator<Key>::calculate(conditional_arg_size_cache, elem);
-      }
-    }
-
-    return total_size;
-  }
-};
-
-/***/
-template <template <typename...> class UnorderedSetType, typename Key, typename Hash, typename KeyEqual, typename Allocator>
-struct Encoder<UnorderedSetType<Key, Hash, KeyEqual, Allocator>,
-               std::enable_if_t<std::disjunction_v<
-                 std::is_same<UnorderedSetType<Key, Hash, KeyEqual, Allocator>, std::unordered_set<Key, Hash, KeyEqual, Allocator>>,
-                 std::is_same<UnorderedSetType<Key, Hash, KeyEqual, Allocator>, std::unordered_multiset<Key, Hash, KeyEqual, Allocator>>>>>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index,
-                     UnorderedSetType<Key, Hash, KeyEqual, Allocator> const& arg) noexcept
-  {
-    Encoder<size_t>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index,
-                            arg.size());
-
-    for (auto const& elem : arg)
-    {
-      Encoder<Key>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, elem);
-    }
-  }
-};
-
-/***/
-template <template <typename...> class UnorderedSetType, typename Key, typename Hash, typename KeyEqual, typename Allocator>
-#if defined(_WIN32)
-struct Decoder<
-  UnorderedSetType<Key, Hash, KeyEqual, Allocator>,
-  std::enable_if_t<std::conjunction_v<
-    std::disjunction<std::is_same<UnorderedSetType<Key, Hash, KeyEqual, Allocator>, std::unordered_set<Key, Hash, KeyEqual, Allocator>>,
-                     std::is_same<UnorderedSetType<Key, Hash, KeyEqual, Allocator>, std::unordered_multiset<Key, Hash, KeyEqual, Allocator>>>,
-    std::negation<std::disjunction<std::is_same<Key, wchar_t*>, std::is_same<Key, wchar_t const*>, std::is_same<Key, std::wstring>, std::is_same<Key, std::wstring_view>>>>>>
-#else
-struct Decoder<UnorderedSetType<Key, Hash, KeyEqual, Allocator>,
-               std::enable_if_t<std::disjunction_v<
-                 std::is_same<UnorderedSetType<Key, Hash, KeyEqual, Allocator>, std::unordered_set<Key, Hash, KeyEqual, Allocator>>,
-                 std::is_same<UnorderedSetType<Key, Hash, KeyEqual, Allocator>, std::unordered_multiset<Key, Hash, KeyEqual, Allocator>>>>>
-#endif
-{
-  static UnorderedSetType<Key, Hash, KeyEqual, Allocator> decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    UnorderedSetType<Key, Hash, KeyEqual, Allocator> arg;
-
-    // Read the size of the set
-    size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-    arg.reserve(number_of_elements);
-
-    for (size_t i = 0; i < number_of_elements; ++i)
-    {
-      arg.emplace(Decoder<Key>::decode(buffer, nullptr));
-    }
-
-    if (args_store)
-    {
-      args_store->push_back(arg);
-    }
-
-    return arg;
-  }
-};
-
-#if defined(_WIN32)
-/***/
-template <template <typename...> class UnorderedSetType, typename Key, typename Hash, typename KeyEqual, typename Allocator>
-struct Decoder<
-  UnorderedSetType<Key, Hash, KeyEqual, Allocator>,
-  std::enable_if_t<std::conjunction_v<
-    std::disjunction<std::is_same<UnorderedSetType<Key, Hash, KeyEqual, Allocator>, std::unordered_set<Key, Hash, KeyEqual, Allocator>>,
-                     std::is_same<UnorderedSetType<Key, Hash, KeyEqual, Allocator>, std::unordered_multiset<Key, Hash, KeyEqual, Allocator>>>,
-    std::disjunction<std::is_same<Key, wchar_t*>, std::is_same<Key, wchar_t const*>, std::is_same<Key, std::wstring>, std::is_same<Key, std::wstring_view>>>>>
-{
-  /**
-   * Chaining stl types not supported for wstrings so we do not return anything
-   */
-  static auto decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    if (args_store)
-    {
-      // Read the size of the vector
-      size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-
-      std::vector<std::string> encoded_values;
-      encoded_values.reserve(number_of_elements);
-
-      for (size_t i = 0; i < number_of_elements; ++i)
-      {
-        std::wstring_view v = Decoder<Key>::decode(buffer, nullptr);
-        encoded_values.emplace_back(utf8_encode(v));
-      }
-
-      args_store->push_back(encoded_values);
-    }
-  }
-};
-#endif
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/include/quill/std/Vector.h b/subprojects/quill-4.2.0/quill/include/quill/std/Vector.h
deleted file mode 100644
index b107894..0000000
--- a/subprojects/quill-4.2.0/quill/include/quill/std/Vector.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/**
- * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
- * Distributed under the MIT License (http://opensource.org/licenses/MIT)
- */
-
-#pragma once
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-
-#include "quill/bundled/fmt/core.h"
-#include "quill/bundled/fmt/ranges.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <type_traits>
-#include <vector>
-
-namespace quill::detail
-{
-/***/
-template <typename T, typename Allocator>
-struct ArgSizeCalculator<std::vector<T, Allocator>>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache,
-                          std::vector<T, Allocator> const& arg) noexcept
-  {
-    // We need to store the size of the vector in the buffer, so we reserve space for it.
-    // We add sizeof(size_t) bytes to accommodate the size information.
-    size_t total_size{sizeof(size_t)};
-
-    if constexpr (std::disjunction_v<std::is_arithmetic<T>, std::is_enum<T>>)
-    {
-      // For built-in types, such as arithmetic or enum types, iteration is unnecessary
-      total_size += sizeof(T) * arg.size();
-    }
-    else
-    {
-      // For other complex types it's essential to determine the exact size of each element.
-      // For instance, in the case of a collection of std::string, we need to know the exact size
-      // of each string as we will be copying them directly to our queue buffer.
-      for (auto const& elem : arg)
-      {
-        total_size += ArgSizeCalculator<T>::calculate(conditional_arg_size_cache, elem);
-      }
-    }
-
-    return total_size;
-  }
-};
-
-/***/
-template <typename T, typename Allocator>
-struct Encoder<std::vector<T, Allocator>>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index, std::vector<T, Allocator> const& arg) noexcept
-  {
-    Encoder<size_t>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index,
-                            arg.size());
-
-    for (auto const& elem : arg)
-    {
-      Encoder<T>::encode(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index, elem);
-    }
-  }
-};
-
-/***/
-template <typename T, typename Allocator>
-#if defined(_WIN32)
-struct Decoder<std::vector<T, Allocator>,
-               std::enable_if_t<std::negation_v<std::disjunction<std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                                                 std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>>
-#else
-struct Decoder<std::vector<T, Allocator>>
-#endif
-{
-  static std::vector<T, Allocator> decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    std::vector<T, Allocator> arg;
-
-    // Read the size of the vector
-    size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-    arg.reserve(number_of_elements);
-
-    for (size_t i = 0; i < number_of_elements; ++i)
-    {
-      arg.emplace_back(Decoder<T>::decode(buffer, nullptr));
-    }
-
-    if (args_store)
-    {
-      args_store->push_back(arg);
-    }
-
-    return arg;
-  }
-};
-
-#if defined(_WIN32)
-/***/
-template <typename T, typename Allocator>
-struct Decoder<std::vector<T, Allocator>,
-               std::enable_if_t<std::disjunction_v<std::is_same<T, wchar_t*>, std::is_same<T, wchar_t const*>,
-                                                   std::is_same<T, std::wstring>, std::is_same<T, std::wstring_view>>>>
-{
-  /**
-   * Chaining stl types not supported for wstrings so we do not return anything
-   */
-  static void decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    if (args_store)
-    {
-      // Read the size of the vector
-      size_t const number_of_elements = Decoder<size_t>::decode(buffer, nullptr);
-
-      std::vector<std::string> encoded_values;
-      encoded_values.reserve(number_of_elements);
-
-      for (size_t i = 0; i < number_of_elements; ++i)
-      {
-        std::wstring_view v = Decoder<T>::decode(buffer, nullptr);
-        encoded_values.emplace_back(utf8_encode(v));
-      }
-
-      args_store->push_back(encoded_values);
-    }
-  }
-};
-#endif
-
-} // namespace quill::detail
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/CMakeLists.txt b/subprojects/quill-4.2.0/quill/test/CMakeLists.txt
deleted file mode 100644
index a025041..0000000
--- a/subprojects/quill-4.2.0/quill/test/CMakeLists.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-add_subdirectory(unit_tests)
-add_subdirectory(integration_tests)
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/bundled/doctest/LICENSE.txt b/subprojects/quill-4.2.0/quill/test/bundled/doctest/LICENSE.txt
deleted file mode 100644
index a204721..0000000
--- a/subprojects/quill-4.2.0/quill/test/bundled/doctest/LICENSE.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016-2019 Viktor Kirilov
-
-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.
diff --git a/subprojects/quill-4.2.0/quill/test/bundled/doctest/doctest.h b/subprojects/quill-4.2.0/quill/test/bundled/doctest/doctest.h
deleted file mode 100644
index a980196..0000000
--- a/subprojects/quill-4.2.0/quill/test/bundled/doctest/doctest.h
+++ /dev/null
@@ -1,7106 +0,0 @@
-// ====================================================================== lgtm [cpp/missing-header-guard]
-// == DO NOT MODIFY THIS FILE BY HAND - IT IS AUTO GENERATED BY CMAKE! ==
-// ======================================================================
-//
-// doctest.h - the lightest feature-rich C++ single-header testing framework for unit tests and TDD
-//
-// Copyright (c) 2016-2023 Viktor Kirilov
-//
-// Distributed under the MIT Software License
-// See accompanying file LICENSE.txt or copy at
-// https://opensource.org/licenses/MIT
-//
-// The documentation can be found at the library's page:
-// https://github.com/doctest/doctest/blob/master/doc/markdown/readme.md
-//
-// =================================================================================================
-// =================================================================================================
-// =================================================================================================
-//
-// The library is heavily influenced by Catch - https://github.com/catchorg/Catch2
-// which uses the Boost Software License - Version 1.0
-// see here - https://github.com/catchorg/Catch2/blob/master/LICENSE.txt
-//
-// The concept of subcases (sections in Catch) and expression decomposition are from there.
-// Some parts of the code are taken directly:
-// - stringification - the detection of "ostream& operator<<(ostream&, const T&)" and StringMaker<>
-// - the Approx() helper class for floating point comparison
-// - colors in the console
-// - breaking into a debugger
-// - signal / SEH handling
-// - timer
-// - XmlWriter class - thanks to Phil Nash for allowing the direct reuse (AKA copy/paste)
-//
-// The expression decomposing templates are taken from lest - https://github.com/martinmoene/lest
-// which uses the Boost Software License - Version 1.0
-// see here - https://github.com/martinmoene/lest/blob/master/LICENSE.txt
-//
-// =================================================================================================
-// =================================================================================================
-// =================================================================================================
-
-#ifndef DOCTEST_LIBRARY_INCLUDED
-#define DOCTEST_LIBRARY_INCLUDED
-
-// =================================================================================================
-// == VERSION ======================================================================================
-// =================================================================================================
-
-#define DOCTEST_VERSION_MAJOR 2
-#define DOCTEST_VERSION_MINOR 4
-#define DOCTEST_VERSION_PATCH 11
-
-// util we need here
-#define DOCTEST_TOSTR_IMPL(x) #x
-#define DOCTEST_TOSTR(x) DOCTEST_TOSTR_IMPL(x)
-
-#define DOCTEST_VERSION_STR                                                                        \
-    DOCTEST_TOSTR(DOCTEST_VERSION_MAJOR) "."                                                       \
-    DOCTEST_TOSTR(DOCTEST_VERSION_MINOR) "."                                                       \
-    DOCTEST_TOSTR(DOCTEST_VERSION_PATCH)
-
-#define DOCTEST_VERSION                                                                            \
-    (DOCTEST_VERSION_MAJOR * 10000 + DOCTEST_VERSION_MINOR * 100 + DOCTEST_VERSION_PATCH)
-
-// =================================================================================================
-// == COMPILER VERSION =============================================================================
-// =================================================================================================
-
-// ideas for the version stuff are taken from here: https://github.com/cxxstuff/cxx_detect
-
-#ifdef _MSC_VER
-#define DOCTEST_CPLUSPLUS _MSVC_LANG
-#else
-#define DOCTEST_CPLUSPLUS __cplusplus
-#endif
-
-#define DOCTEST_COMPILER(MAJOR, MINOR, PATCH) ((MAJOR)*10000000 + (MINOR)*100000 + (PATCH))
-
-// GCC/Clang and GCC/MSVC are mutually exclusive, but Clang/MSVC are not because of clang-cl...
-#if defined(_MSC_VER) && defined(_MSC_FULL_VER)
-#if _MSC_VER == _MSC_FULL_VER / 10000
-#define DOCTEST_MSVC DOCTEST_COMPILER(_MSC_VER / 100, _MSC_VER % 100, _MSC_FULL_VER % 10000)
-#else // MSVC
-#define DOCTEST_MSVC                                                                               \
-    DOCTEST_COMPILER(_MSC_VER / 100, (_MSC_FULL_VER / 100000) % 100, _MSC_FULL_VER % 100000)
-#endif // MSVC
-#endif // MSVC
-#if defined(__clang__) && defined(__clang_minor__) && defined(__clang_patchlevel__)
-#define DOCTEST_CLANG DOCTEST_COMPILER(__clang_major__, __clang_minor__, __clang_patchlevel__)
-#elif defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) &&              \
-        !defined(__INTEL_COMPILER)
-#define DOCTEST_GCC DOCTEST_COMPILER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
-#endif // GCC
-#if defined(__INTEL_COMPILER)
-#define DOCTEST_ICC DOCTEST_COMPILER(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
-#endif // ICC
-
-#ifndef DOCTEST_MSVC
-#define DOCTEST_MSVC 0
-#endif // DOCTEST_MSVC
-#ifndef DOCTEST_CLANG
-#define DOCTEST_CLANG 0
-#endif // DOCTEST_CLANG
-#ifndef DOCTEST_GCC
-#define DOCTEST_GCC 0
-#endif // DOCTEST_GCC
-#ifndef DOCTEST_ICC
-#define DOCTEST_ICC 0
-#endif // DOCTEST_ICC
-
-// =================================================================================================
-// == COMPILER WARNINGS HELPERS ====================================================================
-// =================================================================================================
-
-#if DOCTEST_CLANG && !DOCTEST_ICC
-#define DOCTEST_PRAGMA_TO_STR(x) _Pragma(#x)
-#define DOCTEST_CLANG_SUPPRESS_WARNING_PUSH _Pragma("clang diagnostic push")
-#define DOCTEST_CLANG_SUPPRESS_WARNING(w) DOCTEST_PRAGMA_TO_STR(clang diagnostic ignored w)
-#define DOCTEST_CLANG_SUPPRESS_WARNING_POP _Pragma("clang diagnostic pop")
-#define DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH(w)                                                \
-    DOCTEST_CLANG_SUPPRESS_WARNING_PUSH DOCTEST_CLANG_SUPPRESS_WARNING(w)
-#else // DOCTEST_CLANG
-#define DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
-#define DOCTEST_CLANG_SUPPRESS_WARNING(w)
-#define DOCTEST_CLANG_SUPPRESS_WARNING_POP
-#define DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH(w)
-#endif // DOCTEST_CLANG
-
-#if DOCTEST_GCC
-#define DOCTEST_PRAGMA_TO_STR(x) _Pragma(#x)
-#define DOCTEST_GCC_SUPPRESS_WARNING_PUSH _Pragma("GCC diagnostic push")
-#define DOCTEST_GCC_SUPPRESS_WARNING(w) DOCTEST_PRAGMA_TO_STR(GCC diagnostic ignored w)
-#define DOCTEST_GCC_SUPPRESS_WARNING_POP _Pragma("GCC diagnostic pop")
-#define DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH(w)                                                  \
-    DOCTEST_GCC_SUPPRESS_WARNING_PUSH DOCTEST_GCC_SUPPRESS_WARNING(w)
-#else // DOCTEST_GCC
-#define DOCTEST_GCC_SUPPRESS_WARNING_PUSH
-#define DOCTEST_GCC_SUPPRESS_WARNING(w)
-#define DOCTEST_GCC_SUPPRESS_WARNING_POP
-#define DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH(w)
-#endif // DOCTEST_GCC
-
-#if DOCTEST_MSVC
-#define DOCTEST_MSVC_SUPPRESS_WARNING_PUSH __pragma(warning(push))
-#define DOCTEST_MSVC_SUPPRESS_WARNING(w) __pragma(warning(disable : w))
-#define DOCTEST_MSVC_SUPPRESS_WARNING_POP __pragma(warning(pop))
-#define DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(w)                                                 \
-    DOCTEST_MSVC_SUPPRESS_WARNING_PUSH DOCTEST_MSVC_SUPPRESS_WARNING(w)
-#else // DOCTEST_MSVC
-#define DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
-#define DOCTEST_MSVC_SUPPRESS_WARNING(w)
-#define DOCTEST_MSVC_SUPPRESS_WARNING_POP
-#define DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(w)
-#endif // DOCTEST_MSVC
-
-// =================================================================================================
-// == COMPILER WARNINGS ============================================================================
-// =================================================================================================
-
-// both the header and the implementation suppress all of these,
-// so it only makes sense to aggregate them like so
-#define DOCTEST_SUPPRESS_COMMON_WARNINGS_PUSH                                                      \
-    DOCTEST_CLANG_SUPPRESS_WARNING_PUSH                                                            \
-    DOCTEST_CLANG_SUPPRESS_WARNING("-Wunknown-pragmas")                                            \
-    DOCTEST_CLANG_SUPPRESS_WARNING("-Wweak-vtables")                                               \
-    DOCTEST_CLANG_SUPPRESS_WARNING("-Wpadded")                                                     \
-    DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-prototypes")                                         \
-    DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat")                                               \
-    DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat-pedantic")                                      \
-                                                                                                   \
-    DOCTEST_GCC_SUPPRESS_WARNING_PUSH                                                              \
-    DOCTEST_GCC_SUPPRESS_WARNING("-Wunknown-pragmas")                                              \
-    DOCTEST_GCC_SUPPRESS_WARNING("-Wpragmas")                                                      \
-    DOCTEST_GCC_SUPPRESS_WARNING("-Weffc++")                                                       \
-    DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-overflow")                                              \
-    DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-aliasing")                                              \
-    DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-declarations")                                         \
-    DOCTEST_GCC_SUPPRESS_WARNING("-Wuseless-cast")                                                 \
-    DOCTEST_GCC_SUPPRESS_WARNING("-Wnoexcept")                                                     \
-                                                                                                   \
-    DOCTEST_MSVC_SUPPRESS_WARNING_PUSH                                                             \
-    /* these 4 also disabled globally via cmake: */                                                \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4514) /* unreferenced inline function has been removed */        \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4571) /* SEH related */                                          \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4710) /* function not inlined */                                 \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4711) /* function selected for inline expansion*/                \
-    /* common ones */                                                                              \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4616) /* invalid compiler warning */                             \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4619) /* invalid compiler warning */                             \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4996) /* The compiler encountered a deprecated declaration */    \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4706) /* assignment within conditional expression */             \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4512) /* 'class' : assignment operator could not be generated */ \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4127) /* conditional expression is constant */                   \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4820) /* padding */                                              \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4625) /* copy constructor was implicitly deleted */              \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4626) /* assignment operator was implicitly deleted */           \
-    DOCTEST_MSVC_SUPPRESS_WARNING(5027) /* move assignment operator implicitly deleted */          \
-    DOCTEST_MSVC_SUPPRESS_WARNING(5026) /* move constructor was implicitly deleted */              \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4640) /* construction of local static object not thread-safe */  \
-    DOCTEST_MSVC_SUPPRESS_WARNING(5045) /* Spectre mitigation for memory load */                   \
-    DOCTEST_MSVC_SUPPRESS_WARNING(5264) /* 'variable-name': 'const' variable is not used */        \
-    /* static analysis */                                                                          \
-    DOCTEST_MSVC_SUPPRESS_WARNING(26439) /* Function may not throw. Declare it 'noexcept' */       \
-    DOCTEST_MSVC_SUPPRESS_WARNING(26495) /* Always initialize a member variable */                 \
-    DOCTEST_MSVC_SUPPRESS_WARNING(26451) /* Arithmetic overflow ... */                             \
-    DOCTEST_MSVC_SUPPRESS_WARNING(26444) /* Avoid unnamed objects with custom ctor and dtor... */  \
-    DOCTEST_MSVC_SUPPRESS_WARNING(26812) /* Prefer 'enum class' over 'enum' */
-
-#define DOCTEST_SUPPRESS_COMMON_WARNINGS_POP                                                       \
-    DOCTEST_CLANG_SUPPRESS_WARNING_POP                                                             \
-    DOCTEST_GCC_SUPPRESS_WARNING_POP                                                               \
-    DOCTEST_MSVC_SUPPRESS_WARNING_POP
-
-DOCTEST_SUPPRESS_COMMON_WARNINGS_PUSH
-
-DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wnon-virtual-dtor")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wdeprecated")
-
-DOCTEST_GCC_SUPPRESS_WARNING_PUSH
-DOCTEST_GCC_SUPPRESS_WARNING("-Wctor-dtor-privacy")
-DOCTEST_GCC_SUPPRESS_WARNING("-Wnon-virtual-dtor")
-DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-promo")
-
-DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
-DOCTEST_MSVC_SUPPRESS_WARNING(4623) // default constructor was implicitly defined as deleted
-
-#define DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_BEGIN                                 \
-    DOCTEST_MSVC_SUPPRESS_WARNING_PUSH                                                             \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4548) /* before comma no effect; expected side - effect */       \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4265) /* virtual functions, but destructor is not virtual */     \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4986) /* exception specification does not match previous */      \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4350) /* 'member1' called instead of 'member2' */                \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4668) /* not defined as a preprocessor macro */                  \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4365) /* signed/unsigned mismatch */                             \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4774) /* format string not a string literal */                   \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4820) /* padding */                                              \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4625) /* copy constructor was implicitly deleted */              \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4626) /* assignment operator was implicitly deleted */           \
-    DOCTEST_MSVC_SUPPRESS_WARNING(5027) /* move assignment operator implicitly deleted */          \
-    DOCTEST_MSVC_SUPPRESS_WARNING(5026) /* move constructor was implicitly deleted */              \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4623) /* default constructor was implicitly deleted */           \
-    DOCTEST_MSVC_SUPPRESS_WARNING(5039) /* pointer to pot. throwing function passed to extern C */ \
-    DOCTEST_MSVC_SUPPRESS_WARNING(5045) /* Spectre mitigation for memory load */                   \
-    DOCTEST_MSVC_SUPPRESS_WARNING(5105) /* macro producing 'defined' has undefined behavior */     \
-    DOCTEST_MSVC_SUPPRESS_WARNING(4738) /* storing float result in memory, loss of performance */  \
-    DOCTEST_MSVC_SUPPRESS_WARNING(5262) /* implicit fall-through */
-
-#define DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END DOCTEST_MSVC_SUPPRESS_WARNING_POP
-
-// =================================================================================================
-// == FEATURE DETECTION ============================================================================
-// =================================================================================================
-
-// general compiler feature support table: https://en.cppreference.com/w/cpp/compiler_support
-// MSVC C++11 feature support table: https://msdn.microsoft.com/en-us/library/hh567368.aspx
-// GCC C++11 feature support table: https://gcc.gnu.org/projects/cxx-status.html
-// MSVC version table:
-// https://en.wikipedia.org/wiki/Microsoft_Visual_C%2B%2B#Internal_version_numbering
-// MSVC++ 14.3 (17) _MSC_VER == 1930 (Visual Studio 2022)
-// MSVC++ 14.2 (16) _MSC_VER == 1920 (Visual Studio 2019)
-// MSVC++ 14.1 (15) _MSC_VER == 1910 (Visual Studio 2017)
-// MSVC++ 14.0      _MSC_VER == 1900 (Visual Studio 2015)
-// MSVC++ 12.0      _MSC_VER == 1800 (Visual Studio 2013)
-// MSVC++ 11.0      _MSC_VER == 1700 (Visual Studio 2012)
-// MSVC++ 10.0      _MSC_VER == 1600 (Visual Studio 2010)
-// MSVC++ 9.0       _MSC_VER == 1500 (Visual Studio 2008)
-// MSVC++ 8.0       _MSC_VER == 1400 (Visual Studio 2005)
-
-// Universal Windows Platform support
-#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
-#define DOCTEST_CONFIG_NO_WINDOWS_SEH
-#endif // WINAPI_FAMILY
-#if DOCTEST_MSVC && !defined(DOCTEST_CONFIG_WINDOWS_SEH)
-#define DOCTEST_CONFIG_WINDOWS_SEH
-#endif // MSVC
-#if defined(DOCTEST_CONFIG_NO_WINDOWS_SEH) && defined(DOCTEST_CONFIG_WINDOWS_SEH)
-#undef DOCTEST_CONFIG_WINDOWS_SEH
-#endif // DOCTEST_CONFIG_NO_WINDOWS_SEH
-
-#if !defined(_WIN32) && !defined(__QNX__) && !defined(DOCTEST_CONFIG_POSIX_SIGNALS) &&             \
-        !defined(__EMSCRIPTEN__) && !defined(__wasi__)
-#define DOCTEST_CONFIG_POSIX_SIGNALS
-#endif // _WIN32
-#if defined(DOCTEST_CONFIG_NO_POSIX_SIGNALS) && defined(DOCTEST_CONFIG_POSIX_SIGNALS)
-#undef DOCTEST_CONFIG_POSIX_SIGNALS
-#endif // DOCTEST_CONFIG_NO_POSIX_SIGNALS
-
-#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
-#if !defined(__cpp_exceptions) && !defined(__EXCEPTIONS) && !defined(_CPPUNWIND)                   \
-        || defined(__wasi__)
-#define DOCTEST_CONFIG_NO_EXCEPTIONS
-#endif // no exceptions
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
-
-#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
-#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
-#define DOCTEST_CONFIG_NO_EXCEPTIONS
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
-
-#if defined(DOCTEST_CONFIG_NO_EXCEPTIONS) && !defined(DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS)
-#define DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS && !DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
-
-#ifdef __wasi__
-#define DOCTEST_CONFIG_NO_MULTITHREADING
-#endif
-
-#if defined(DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN) && !defined(DOCTEST_CONFIG_IMPLEMENT)
-#define DOCTEST_CONFIG_IMPLEMENT
-#endif // DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
-
-#if defined(_WIN32) || defined(__CYGWIN__)
-#if DOCTEST_MSVC
-#define DOCTEST_SYMBOL_EXPORT __declspec(dllexport)
-#define DOCTEST_SYMBOL_IMPORT __declspec(dllimport)
-#else // MSVC
-#define DOCTEST_SYMBOL_EXPORT __attribute__((dllexport))
-#define DOCTEST_SYMBOL_IMPORT __attribute__((dllimport))
-#endif // MSVC
-#else  // _WIN32
-#define DOCTEST_SYMBOL_EXPORT __attribute__((visibility("default")))
-#define DOCTEST_SYMBOL_IMPORT
-#endif // _WIN32
-
-#ifdef DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL
-#ifdef DOCTEST_CONFIG_IMPLEMENT
-#define DOCTEST_INTERFACE DOCTEST_SYMBOL_EXPORT
-#else // DOCTEST_CONFIG_IMPLEMENT
-#define DOCTEST_INTERFACE DOCTEST_SYMBOL_IMPORT
-#endif // DOCTEST_CONFIG_IMPLEMENT
-#else  // DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL
-#define DOCTEST_INTERFACE
-#endif // DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL
-
-// needed for extern template instantiations
-// see https://github.com/fmtlib/fmt/issues/2228
-#if DOCTEST_MSVC
-#define DOCTEST_INTERFACE_DECL
-#define DOCTEST_INTERFACE_DEF DOCTEST_INTERFACE
-#else // DOCTEST_MSVC
-#define DOCTEST_INTERFACE_DECL DOCTEST_INTERFACE
-#define DOCTEST_INTERFACE_DEF
-#endif // DOCTEST_MSVC
-
-#define DOCTEST_EMPTY
-
-#if DOCTEST_MSVC
-#define DOCTEST_NOINLINE __declspec(noinline)
-#define DOCTEST_UNUSED
-#define DOCTEST_ALIGNMENT(x)
-#elif DOCTEST_CLANG && DOCTEST_CLANG < DOCTEST_COMPILER(3, 5, 0)
-#define DOCTEST_NOINLINE
-#define DOCTEST_UNUSED
-#define DOCTEST_ALIGNMENT(x)
-#else
-#define DOCTEST_NOINLINE __attribute__((noinline))
-#define DOCTEST_UNUSED __attribute__((unused))
-#define DOCTEST_ALIGNMENT(x) __attribute__((aligned(x)))
-#endif
-
-#ifdef DOCTEST_CONFIG_NO_CONTRADICTING_INLINE
-#define DOCTEST_INLINE_NOINLINE inline
-#else
-#define DOCTEST_INLINE_NOINLINE inline DOCTEST_NOINLINE
-#endif
-
-#ifndef DOCTEST_NORETURN
-#if DOCTEST_MSVC && (DOCTEST_MSVC < DOCTEST_COMPILER(19, 0, 0))
-#define DOCTEST_NORETURN
-#else // DOCTEST_MSVC
-#define DOCTEST_NORETURN [[noreturn]]
-#endif // DOCTEST_MSVC
-#endif // DOCTEST_NORETURN
-
-#ifndef DOCTEST_NOEXCEPT
-#if DOCTEST_MSVC && (DOCTEST_MSVC < DOCTEST_COMPILER(19, 0, 0))
-#define DOCTEST_NOEXCEPT
-#else // DOCTEST_MSVC
-#define DOCTEST_NOEXCEPT noexcept
-#endif // DOCTEST_MSVC
-#endif // DOCTEST_NOEXCEPT
-
-#ifndef DOCTEST_CONSTEXPR
-#if DOCTEST_MSVC && (DOCTEST_MSVC < DOCTEST_COMPILER(19, 0, 0))
-#define DOCTEST_CONSTEXPR const
-#define DOCTEST_CONSTEXPR_FUNC inline
-#else // DOCTEST_MSVC
-#define DOCTEST_CONSTEXPR constexpr
-#define DOCTEST_CONSTEXPR_FUNC constexpr
-#endif // DOCTEST_MSVC
-#endif // DOCTEST_CONSTEXPR
-
-#ifndef DOCTEST_NO_SANITIZE_INTEGER
-#if DOCTEST_CLANG >= DOCTEST_COMPILER(3, 7, 0)
-#define DOCTEST_NO_SANITIZE_INTEGER __attribute__((no_sanitize("integer")))
-#else
-#define DOCTEST_NO_SANITIZE_INTEGER
-#endif
-#endif // DOCTEST_NO_SANITIZE_INTEGER
-
-// =================================================================================================
-// == FEATURE DETECTION END ========================================================================
-// =================================================================================================
-
-#define DOCTEST_DECLARE_INTERFACE(name)                                                            \
-    virtual ~name();                                                                               \
-    name() = default;                                                                              \
-    name(const name&) = delete;                                                                    \
-    name(name&&) = delete;                                                                         \
-    name& operator=(const name&) = delete;                                                         \
-    name& operator=(name&&) = delete;
-
-#define DOCTEST_DEFINE_INTERFACE(name)                                                             \
-    name::~name() = default;
-
-// internal macros for string concatenation and anonymous variable name generation
-#define DOCTEST_CAT_IMPL(s1, s2) s1##s2
-#define DOCTEST_CAT(s1, s2) DOCTEST_CAT_IMPL(s1, s2)
-#ifdef __COUNTER__ // not standard and may be missing for some compilers
-#define DOCTEST_ANONYMOUS(x) DOCTEST_CAT(x, __COUNTER__)
-#else // __COUNTER__
-#define DOCTEST_ANONYMOUS(x) DOCTEST_CAT(x, __LINE__)
-#endif // __COUNTER__
-
-#ifndef DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE
-#define DOCTEST_REF_WRAP(x) x&
-#else // DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE
-#define DOCTEST_REF_WRAP(x) x
-#endif // DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE
-
-// not using __APPLE__ because... this is how Catch does it
-#ifdef __MAC_OS_X_VERSION_MIN_REQUIRED
-#define DOCTEST_PLATFORM_MAC
-#elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
-#define DOCTEST_PLATFORM_IPHONE
-#elif defined(_WIN32)
-#define DOCTEST_PLATFORM_WINDOWS
-#elif defined(__wasi__)
-#define DOCTEST_PLATFORM_WASI
-#else // DOCTEST_PLATFORM
-#define DOCTEST_PLATFORM_LINUX
-#endif // DOCTEST_PLATFORM
-
-namespace doctest { namespace detail {
-        static DOCTEST_CONSTEXPR int consume(const int*, int) noexcept { return 0; }
-    }}
-
-#define DOCTEST_GLOBAL_NO_WARNINGS(var, ...)                                                         \
-    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wglobal-constructors")                                \
-    static const int var = doctest::detail::consume(&var, __VA_ARGS__);                              \
-    DOCTEST_CLANG_SUPPRESS_WARNING_POP
-
-#ifndef DOCTEST_BREAK_INTO_DEBUGGER
-// should probably take a look at https://github.com/scottt/debugbreak
-#ifdef DOCTEST_PLATFORM_LINUX
-#if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
-// Break at the location of the failing check if possible
-#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("int $3\n" : :) // NOLINT(hicpp-no-assembler)
-#else
-#include <signal.h>
-#define DOCTEST_BREAK_INTO_DEBUGGER() raise(SIGTRAP)
-#endif
-#elif defined(DOCTEST_PLATFORM_MAC)
-#if defined(__x86_64) || defined(__x86_64__) || defined(__amd64__) || defined(__i386)
-#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("int $3\n" : :) // NOLINT(hicpp-no-assembler)
-#elif defined(__ppc__) || defined(__ppc64__)
-// https://www.cocoawithlove.com/2008/03/break-into-debugger.html
-#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n": : : "memory","r0","r3","r4") // NOLINT(hicpp-no-assembler)
-#else
-#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("brk #0"); // NOLINT(hicpp-no-assembler)
-#endif
-#elif DOCTEST_MSVC
-#define DOCTEST_BREAK_INTO_DEBUGGER() __debugbreak()
-#elif defined(__MINGW32__)
-DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wredundant-decls")
-extern "C" __declspec(dllimport) void __stdcall DebugBreak();
-DOCTEST_GCC_SUPPRESS_WARNING_POP
-#define DOCTEST_BREAK_INTO_DEBUGGER() ::DebugBreak()
-#else // linux
-#define DOCTEST_BREAK_INTO_DEBUGGER() (static_cast<void>(0))
-#endif // linux
-#endif // DOCTEST_BREAK_INTO_DEBUGGER
-
-// this is kept here for backwards compatibility since the config option was changed
-#ifdef DOCTEST_CONFIG_USE_IOSFWD
-#ifndef DOCTEST_CONFIG_USE_STD_HEADERS
-#define DOCTEST_CONFIG_USE_STD_HEADERS
-#endif
-#endif // DOCTEST_CONFIG_USE_IOSFWD
-
-// for clang - always include ciso646 (which drags some std stuff) because
-// we want to check if we are using libc++ with the _LIBCPP_VERSION macro in
-// which case we don't want to forward declare stuff from std - for reference:
-// https://github.com/doctest/doctest/issues/126
-// https://github.com/doctest/doctest/issues/356
-#if DOCTEST_CLANG
-#include <ciso646>
-#endif // clang
-
-#ifdef _LIBCPP_VERSION
-#ifndef DOCTEST_CONFIG_USE_STD_HEADERS
-#define DOCTEST_CONFIG_USE_STD_HEADERS
-#endif
-#endif // _LIBCPP_VERSION
-
-#ifdef DOCTEST_CONFIG_USE_STD_HEADERS
-#ifndef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-#define DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_BEGIN
-#include <cstddef>
-#include <ostream>
-#include <istream>
-DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END
-#else // DOCTEST_CONFIG_USE_STD_HEADERS
-
-// Forward declaring 'X' in namespace std is not permitted by the C++ Standard.
-DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4643)
-
-namespace std { // NOLINT(cert-dcl58-cpp)
-    typedef decltype(nullptr) nullptr_t; // NOLINT(modernize-use-using)
-    typedef decltype(sizeof(void*)) size_t; // NOLINT(modernize-use-using)
-    template <class charT>
-    struct char_traits;
-    template <>
-    struct char_traits<char>;
-    template <class charT, class traits>
-    class basic_ostream; // NOLINT(fuchsia-virtual-inheritance)
-    typedef basic_ostream<char, char_traits<char>> ostream; // NOLINT(modernize-use-using)
-    template<class traits>
-// NOLINTNEXTLINE
-    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char*);
-    template <class charT, class traits>
-    class basic_istream;
-    typedef basic_istream<char, char_traits<char>> istream; // NOLINT(modernize-use-using)
-    template <class... Types>
-    class tuple;
-#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0)
-// see this issue on why this is needed: https://github.com/doctest/doctest/issues/183
-    template <class Ty>
-    class allocator;
-    template <class Elem, class Traits, class Alloc>
-    class basic_string;
-    using string = basic_string<char, char_traits<char>, allocator<char>>;
-#endif // VS 2019
-} // namespace std
-
-DOCTEST_MSVC_SUPPRESS_WARNING_POP
-
-#endif // DOCTEST_CONFIG_USE_STD_HEADERS
-
-#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-#include <type_traits>
-#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-
-namespace doctest {
-
-    using std::size_t;
-
-    DOCTEST_INTERFACE extern bool is_running_in_test;
-
-#ifndef DOCTEST_CONFIG_STRING_SIZE_TYPE
-#define DOCTEST_CONFIG_STRING_SIZE_TYPE unsigned
-#endif
-
-// A 24 byte string class (can be as small as 17 for x64 and 13 for x86) that can hold strings with length
-// of up to 23 chars on the stack before going on the heap - the last byte of the buffer is used for:
-// - "is small" bit - the highest bit - if "0" then it is small - otherwise its "1" (128)
-// - if small - capacity left before going on the heap - using the lowest 5 bits
-// - if small - 2 bits are left unused - the second and third highest ones
-// - if small - acts as a null terminator if strlen() is 23 (24 including the null terminator)
-//              and the "is small" bit remains "0" ("as well as the capacity left") so its OK
-// Idea taken from this lecture about the string implementation of facebook/folly - fbstring
-// https://www.youtube.com/watch?v=kPR8h4-qZdk
-// TODO:
-// - optimizations - like not deleting memory unnecessarily in operator= and etc.
-// - resize/reserve/clear
-// - replace
-// - back/front
-// - iterator stuff
-// - find & friends
-// - push_back/pop_back
-// - assign/insert/erase
-// - relational operators as free functions - taking const char* as one of the params
-    class DOCTEST_INTERFACE String
-    {
-    public:
-        using size_type = DOCTEST_CONFIG_STRING_SIZE_TYPE;
-
-    private:
-        static DOCTEST_CONSTEXPR size_type len  = 24;      //!OCLINT avoid private static members
-        static DOCTEST_CONSTEXPR size_type last = len - 1; //!OCLINT avoid private static members
-
-        struct view // len should be more than sizeof(view) - because of the final byte for flags
-        {
-            char*    ptr;
-            size_type size;
-            size_type capacity;
-        };
-
-        union
-        {
-            char buf[len]; // NOLINT(*-avoid-c-arrays)
-            view data;
-        };
-
-        char* allocate(size_type sz);
-
-        bool isOnStack() const noexcept { return (buf[last] & 128) == 0; }
-        void setOnHeap() noexcept;
-        void setLast(size_type in = last) noexcept;
-        void setSize(size_type sz) noexcept;
-
-        void copy(const String& other);
-
-    public:
-        static DOCTEST_CONSTEXPR size_type npos = static_cast<size_type>(-1);
-
-        String() noexcept;
-        ~String();
-
-        // cppcheck-suppress noExplicitConstructor
-        String(const char* in);
-        String(const char* in, size_type in_size);
-
-        String(std::istream& in, size_type in_size);
-
-        String(const String& other);
-        String& operator=(const String& other);
-
-        String& operator+=(const String& other);
-
-        String(String&& other) noexcept;
-        String& operator=(String&& other) noexcept;
-
-        char  operator[](size_type i) const;
-        char& operator[](size_type i);
-
-        // the only functions I'm willing to leave in the interface - available for inlining
-        const char* c_str() const { return const_cast<String*>(this)->c_str(); } // NOLINT
-        char*       c_str() {
-            if (isOnStack()) {
-                return reinterpret_cast<char*>(buf);
-            }
-            return data.ptr;
-        }
-
-        size_type size() const;
-        size_type capacity() const;
-
-        String substr(size_type pos, size_type cnt = npos) &&;
-        String substr(size_type pos, size_type cnt = npos) const &;
-
-        size_type find(char ch, size_type pos = 0) const;
-        size_type rfind(char ch, size_type pos = npos) const;
-
-        int compare(const char* other, bool no_case = false) const;
-        int compare(const String& other, bool no_case = false) const;
-
-        friend DOCTEST_INTERFACE std::ostream& operator<<(std::ostream& s, const String& in);
-    };
-
-    DOCTEST_INTERFACE String operator+(const String& lhs, const String& rhs);
-
-    DOCTEST_INTERFACE bool operator==(const String& lhs, const String& rhs);
-    DOCTEST_INTERFACE bool operator!=(const String& lhs, const String& rhs);
-    DOCTEST_INTERFACE bool operator<(const String& lhs, const String& rhs);
-    DOCTEST_INTERFACE bool operator>(const String& lhs, const String& rhs);
-    DOCTEST_INTERFACE bool operator<=(const String& lhs, const String& rhs);
-    DOCTEST_INTERFACE bool operator>=(const String& lhs, const String& rhs);
-
-    class DOCTEST_INTERFACE Contains {
-    public:
-        explicit Contains(const String& string);
-
-        bool checkWith(const String& other) const;
-
-        String string;
-    };
-
-    DOCTEST_INTERFACE String toString(const Contains& in);
-
-    DOCTEST_INTERFACE bool operator==(const String& lhs, const Contains& rhs);
-    DOCTEST_INTERFACE bool operator==(const Contains& lhs, const String& rhs);
-    DOCTEST_INTERFACE bool operator!=(const String& lhs, const Contains& rhs);
-    DOCTEST_INTERFACE bool operator!=(const Contains& lhs, const String& rhs);
-
-    namespace Color {
-        enum Enum
-        {
-            None = 0,
-            White,
-            Red,
-            Green,
-            Blue,
-            Cyan,
-            Yellow,
-            Grey,
-
-            Bright = 0x10,
-
-            BrightRed   = Bright | Red,
-            BrightGreen = Bright | Green,
-            LightGrey   = Bright | Grey,
-            BrightWhite = Bright | White
-        };
-
-        DOCTEST_INTERFACE std::ostream& operator<<(std::ostream& s, Color::Enum code);
-    } // namespace Color
-
-    namespace assertType {
-        enum Enum
-        {
-            // macro traits
-
-            is_warn    = 1,
-            is_check   = 2 * is_warn,
-            is_require = 2 * is_check,
-
-            is_normal      = 2 * is_require,
-            is_throws      = 2 * is_normal,
-            is_throws_as   = 2 * is_throws,
-            is_throws_with = 2 * is_throws_as,
-            is_nothrow     = 2 * is_throws_with,
-
-            is_false = 2 * is_nothrow,
-            is_unary = 2 * is_false, // not checked anywhere - used just to distinguish the types
-
-            is_eq = 2 * is_unary,
-            is_ne = 2 * is_eq,
-
-            is_lt = 2 * is_ne,
-            is_gt = 2 * is_lt,
-
-            is_ge = 2 * is_gt,
-            is_le = 2 * is_ge,
-
-            // macro types
-
-            DT_WARN    = is_normal | is_warn,
-            DT_CHECK   = is_normal | is_check,
-            DT_REQUIRE = is_normal | is_require,
-
-            DT_WARN_FALSE    = is_normal | is_false | is_warn,
-            DT_CHECK_FALSE   = is_normal | is_false | is_check,
-            DT_REQUIRE_FALSE = is_normal | is_false | is_require,
-
-            DT_WARN_THROWS    = is_throws | is_warn,
-            DT_CHECK_THROWS   = is_throws | is_check,
-            DT_REQUIRE_THROWS = is_throws | is_require,
-
-            DT_WARN_THROWS_AS    = is_throws_as | is_warn,
-            DT_CHECK_THROWS_AS   = is_throws_as | is_check,
-            DT_REQUIRE_THROWS_AS = is_throws_as | is_require,
-
-            DT_WARN_THROWS_WITH    = is_throws_with | is_warn,
-            DT_CHECK_THROWS_WITH   = is_throws_with | is_check,
-            DT_REQUIRE_THROWS_WITH = is_throws_with | is_require,
-
-            DT_WARN_THROWS_WITH_AS    = is_throws_with | is_throws_as | is_warn,
-            DT_CHECK_THROWS_WITH_AS   = is_throws_with | is_throws_as | is_check,
-            DT_REQUIRE_THROWS_WITH_AS = is_throws_with | is_throws_as | is_require,
-
-            DT_WARN_NOTHROW    = is_nothrow | is_warn,
-            DT_CHECK_NOTHROW   = is_nothrow | is_check,
-            DT_REQUIRE_NOTHROW = is_nothrow | is_require,
-
-            DT_WARN_EQ    = is_normal | is_eq | is_warn,
-            DT_CHECK_EQ   = is_normal | is_eq | is_check,
-            DT_REQUIRE_EQ = is_normal | is_eq | is_require,
-
-            DT_WARN_NE    = is_normal | is_ne | is_warn,
-            DT_CHECK_NE   = is_normal | is_ne | is_check,
-            DT_REQUIRE_NE = is_normal | is_ne | is_require,
-
-            DT_WARN_GT    = is_normal | is_gt | is_warn,
-            DT_CHECK_GT   = is_normal | is_gt | is_check,
-            DT_REQUIRE_GT = is_normal | is_gt | is_require,
-
-            DT_WARN_LT    = is_normal | is_lt | is_warn,
-            DT_CHECK_LT   = is_normal | is_lt | is_check,
-            DT_REQUIRE_LT = is_normal | is_lt | is_require,
-
-            DT_WARN_GE    = is_normal | is_ge | is_warn,
-            DT_CHECK_GE   = is_normal | is_ge | is_check,
-            DT_REQUIRE_GE = is_normal | is_ge | is_require,
-
-            DT_WARN_LE    = is_normal | is_le | is_warn,
-            DT_CHECK_LE   = is_normal | is_le | is_check,
-            DT_REQUIRE_LE = is_normal | is_le | is_require,
-
-            DT_WARN_UNARY    = is_normal | is_unary | is_warn,
-            DT_CHECK_UNARY   = is_normal | is_unary | is_check,
-            DT_REQUIRE_UNARY = is_normal | is_unary | is_require,
-
-            DT_WARN_UNARY_FALSE    = is_normal | is_false | is_unary | is_warn,
-            DT_CHECK_UNARY_FALSE   = is_normal | is_false | is_unary | is_check,
-            DT_REQUIRE_UNARY_FALSE = is_normal | is_false | is_unary | is_require,
-        };
-    } // namespace assertType
-
-    DOCTEST_INTERFACE const char* assertString(assertType::Enum at);
-    DOCTEST_INTERFACE const char* failureString(assertType::Enum at);
-    DOCTEST_INTERFACE const char* skipPathFromFilename(const char* file);
-
-    struct DOCTEST_INTERFACE TestCaseData
-    {
-        String      m_file;       // the file in which the test was registered (using String - see #350)
-        unsigned    m_line;       // the line where the test was registered
-        const char* m_name;       // name of the test case
-        const char* m_test_suite; // the test suite in which the test was added
-        const char* m_description;
-        bool        m_skip;
-        bool        m_no_breaks;
-        bool        m_no_output;
-        bool        m_may_fail;
-        bool        m_should_fail;
-        int         m_expected_failures;
-        double      m_timeout;
-    };
-
-    struct DOCTEST_INTERFACE AssertData
-    {
-        // common - for all asserts
-        const TestCaseData* m_test_case;
-        assertType::Enum    m_at;
-        const char*         m_file;
-        int                 m_line;
-        const char*         m_expr;
-        bool                m_failed;
-
-        // exception-related - for all asserts
-        bool   m_threw;
-        String m_exception;
-
-        // for normal asserts
-        String m_decomp;
-
-        // for specific exception-related asserts
-        bool           m_threw_as;
-        const char*    m_exception_type;
-
-        class DOCTEST_INTERFACE StringContains {
-        private:
-            Contains content;
-            bool isContains;
-
-        public:
-            StringContains(const String& str) : content(str), isContains(false) { }
-            StringContains(Contains cntn) : content(static_cast<Contains&&>(cntn)), isContains(true) { }
-
-            bool check(const String& str) { return isContains ? (content == str) : (content.string == str); }
-
-            operator const String&() const { return content.string; }
-
-            const char* c_str() const { return content.string.c_str(); }
-        } m_exception_string;
-
-        AssertData(assertType::Enum at, const char* file, int line, const char* expr,
-                   const char* exception_type, const StringContains& exception_string);
-    };
-
-    struct DOCTEST_INTERFACE MessageData
-    {
-        String           m_string;
-        const char*      m_file;
-        int              m_line;
-        assertType::Enum m_severity;
-    };
-
-    struct DOCTEST_INTERFACE SubcaseSignature
-    {
-        String      m_name;
-        const char* m_file;
-        int         m_line;
-
-        bool operator==(const SubcaseSignature& other) const;
-        bool operator<(const SubcaseSignature& other) const;
-    };
-
-    struct DOCTEST_INTERFACE IContextScope
-    {
-        DOCTEST_DECLARE_INTERFACE(IContextScope)
-        virtual void stringify(std::ostream*) const = 0;
-    };
-
-    namespace detail {
-        struct DOCTEST_INTERFACE TestCase;
-    } // namespace detail
-
-    struct ContextOptions //!OCLINT too many fields
-    {
-        std::ostream* cout = nullptr; // stdout stream
-        String        binary_name;    // the test binary name
-
-        const detail::TestCase* currentTest = nullptr;
-
-        // == parameters from the command line
-        String   out;       // output filename
-        String   order_by;  // how tests should be ordered
-        unsigned rand_seed; // the seed for rand ordering
-
-        unsigned first; // the first (matching) test to be executed
-        unsigned last;  // the last (matching) test to be executed
-
-        int abort_after;           // stop tests after this many failed assertions
-        int subcase_filter_levels; // apply the subcase filters for the first N levels
-
-        bool success;              // include successful assertions in output
-        bool case_sensitive;       // if filtering should be case sensitive
-        bool exit;                 // if the program should be exited after the tests are ran/whatever
-        bool duration;             // print the time duration of each test case
-        bool minimal;              // minimal console output (only test failures)
-        bool quiet;                // no console output
-        bool no_throw;             // to skip exceptions-related assertion macros
-        bool no_exitcode;          // if the framework should return 0 as the exitcode
-        bool no_run;               // to not run the tests at all (can be done with an "*" exclude)
-        bool no_intro;             // to not print the intro of the framework
-        bool no_version;           // to not print the version of the framework
-        bool no_colors;            // if output to the console should be colorized
-        bool force_colors;         // forces the use of colors even when a tty cannot be detected
-        bool no_breaks;            // to not break into the debugger
-        bool no_skip;              // don't skip test cases which are marked to be skipped
-        bool gnu_file_line;        // if line numbers should be surrounded with :x: and not (x):
-        bool no_path_in_filenames; // if the path to files should be removed from the output
-        bool no_line_numbers;      // if source code line numbers should be omitted from the output
-        bool no_debug_output;      // no output in the debug console when a debugger is attached
-        bool no_skipped_summary;   // don't print "skipped" in the summary !!! UNDOCUMENTED !!!
-        bool no_time_in_output;    // omit any time/timestamps from output !!! UNDOCUMENTED !!!
-
-        bool help;             // to print the help
-        bool version;          // to print the version
-        bool count;            // if only the count of matching tests is to be retrieved
-        bool list_test_cases;  // to list all tests matching the filters
-        bool list_test_suites; // to list all suites matching the filters
-        bool list_reporters;   // lists all registered reporters
-    };
-
-    namespace detail {
-        namespace types {
-#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-            using namespace std;
-#else
-            template <bool COND, typename T = void>
-            struct enable_if { };
-
-            template <typename T>
-            struct enable_if<true, T> { using type = T; };
-
-            struct true_type { static DOCTEST_CONSTEXPR bool value = true; };
-            struct false_type { static DOCTEST_CONSTEXPR bool value = false; };
-
-            template <typename T> struct remove_reference { using type = T; };
-            template <typename T> struct remove_reference<T&> { using type = T; };
-            template <typename T> struct remove_reference<T&&> { using type = T; };
-
-            template <typename T> struct is_rvalue_reference : false_type { };
-            template <typename T> struct is_rvalue_reference<T&&> : true_type { };
-
-            template<typename T> struct remove_const { using type = T; };
-            template <typename T> struct remove_const<const T> { using type = T; };
-
-            // Compiler intrinsics
-            template <typename T> struct is_enum { static DOCTEST_CONSTEXPR bool value = __is_enum(T); };
-            template <typename T> struct underlying_type { using type = __underlying_type(T); };
-
-            template <typename T> struct is_pointer : false_type { };
-            template <typename T> struct is_pointer<T*> : true_type { };
-
-            template <typename T> struct is_array : false_type { };
-            // NOLINTNEXTLINE(*-avoid-c-arrays)
-            template <typename T, size_t SIZE> struct is_array<T[SIZE]> : true_type { };
-#endif
-        }
-
-        // <utility>
-        template <typename T>
-        T&& declval();
-
-        template <class T>
-        DOCTEST_CONSTEXPR_FUNC T&& forward(typename types::remove_reference<T>::type& t) DOCTEST_NOEXCEPT {
-            return static_cast<T&&>(t);
-        }
-
-        template <class T>
-        DOCTEST_CONSTEXPR_FUNC T&& forward(typename types::remove_reference<T>::type&& t) DOCTEST_NOEXCEPT {
-            return static_cast<T&&>(t);
-        }
-
-        template <typename T>
-        struct deferred_false : types::false_type { };
-
-// MSVS 2015 :(
-#if !DOCTEST_CLANG && defined(_MSC_VER) && _MSC_VER <= 1900
-        template <typename T, typename = void>
-    struct has_global_insertion_operator : types::false_type { };
-
-    template <typename T>
-    struct has_global_insertion_operator<T, decltype(::operator<<(declval<std::ostream&>(), declval<const T&>()), void())> : types::true_type { };
-
-    template <typename T, typename = void>
-    struct has_insertion_operator { static DOCTEST_CONSTEXPR bool value = has_global_insertion_operator<T>::value; };
-
-    template <typename T, bool global>
-    struct insert_hack;
-
-    template <typename T>
-    struct insert_hack<T, true> {
-        static void insert(std::ostream& os, const T& t) { ::operator<<(os, t); }
-    };
-
-    template <typename T>
-    struct insert_hack<T, false> {
-        static void insert(std::ostream& os, const T& t) { operator<<(os, t); }
-    };
-
-    template <typename T>
-    using insert_hack_t = insert_hack<T, has_global_insertion_operator<T>::value>;
-#else
-        template <typename T, typename = void>
-        struct has_insertion_operator : types::false_type { };
-#endif
-
-        template <typename T>
-        struct has_insertion_operator<T, decltype(operator<<(declval<std::ostream&>(), declval<const T&>()), void())> : types::true_type { };
-
-        template <typename T>
-        struct should_stringify_as_underlying_type {
-            static DOCTEST_CONSTEXPR bool value = detail::types::is_enum<T>::value && !doctest::detail::has_insertion_operator<T>::value;
-        };
-
-        DOCTEST_INTERFACE std::ostream* tlssPush();
-        DOCTEST_INTERFACE String tlssPop();
-
-        template <bool C>
-        struct StringMakerBase {
-            template <typename T>
-            static String convert(const DOCTEST_REF_WRAP(T)) {
-#ifdef DOCTEST_CONFIG_REQUIRE_STRINGIFICATION_FOR_ALL_USED_TYPES
-                static_assert(deferred_false<T>::value, "No stringification detected for type T. See string conversion manual");
-#endif
-                return "{?}";
-            }
-        };
-
-        template <typename T>
-        struct filldata;
-
-        template <typename T>
-        void filloss(std::ostream* stream, const T& in) {
-            filldata<T>::fill(stream, in);
-        }
-
-        template <typename T, size_t N>
-        void filloss(std::ostream* stream, const T (&in)[N]) { // NOLINT(*-avoid-c-arrays)
-            // T[N], T(&)[N], T(&&)[N] have same behaviour.
-            // Hence remove reference.
-            filloss<typename types::remove_reference<decltype(in)>::type>(stream, in);
-        }
-
-        template <typename T>
-        String toStream(const T& in) {
-            std::ostream* stream = tlssPush();
-            filloss(stream, in);
-            return tlssPop();
-        }
-
-        template <>
-        struct StringMakerBase<true> {
-            template <typename T>
-            static String convert(const DOCTEST_REF_WRAP(T) in) {
-                return toStream(in);
-            }
-        };
-    } // namespace detail
-
-    template <typename T>
-    struct StringMaker : public detail::StringMakerBase<
-            detail::has_insertion_operator<T>::value || detail::types::is_pointer<T>::value || detail::types::is_array<T>::value>
-    {};
-
-#ifndef DOCTEST_STRINGIFY
-#ifdef DOCTEST_CONFIG_DOUBLE_STRINGIFY
-#define DOCTEST_STRINGIFY(...) toString(toString(__VA_ARGS__))
-#else
-#define DOCTEST_STRINGIFY(...) toString(__VA_ARGS__)
-#endif
-#endif
-
-    template <typename T>
-    String toString() {
-#if DOCTEST_CLANG == 0 && DOCTEST_GCC == 0 && DOCTEST_ICC == 0
-        String ret = __FUNCSIG__; // class doctest::String __cdecl doctest::toString<TYPE>(void)
-        String::size_type beginPos = ret.find('<');
-        return ret.substr(beginPos + 1, ret.size() - beginPos - static_cast<String::size_type>(sizeof(">(void)")));
-#else
-        String ret = __PRETTY_FUNCTION__; // doctest::String toString() [with T = TYPE]
-    String::size_type begin = ret.find('=') + 2;
-    return ret.substr(begin, ret.size() - begin - 1);
-#endif
-    }
-
-    template <typename T, typename detail::types::enable_if<!detail::should_stringify_as_underlying_type<T>::value, bool>::type = true>
-    String toString(const DOCTEST_REF_WRAP(T) value) {
-        return StringMaker<T>::convert(value);
-    }
-
-#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
-    DOCTEST_INTERFACE String toString(const char* in);
-#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
-
-#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0)
-// see this issue on why this is needed: https://github.com/doctest/doctest/issues/183
-    DOCTEST_INTERFACE String toString(const std::string& in);
-#endif // VS 2019
-
-    DOCTEST_INTERFACE String toString(String in);
-
-    DOCTEST_INTERFACE String toString(std::nullptr_t);
-
-    DOCTEST_INTERFACE String toString(bool in);
-
-    DOCTEST_INTERFACE String toString(float in);
-    DOCTEST_INTERFACE String toString(double in);
-    DOCTEST_INTERFACE String toString(double long in);
-
-    DOCTEST_INTERFACE String toString(char in);
-    DOCTEST_INTERFACE String toString(char signed in);
-    DOCTEST_INTERFACE String toString(char unsigned in);
-    DOCTEST_INTERFACE String toString(short in);
-    DOCTEST_INTERFACE String toString(short unsigned in);
-    DOCTEST_INTERFACE String toString(signed in);
-    DOCTEST_INTERFACE String toString(unsigned in);
-    DOCTEST_INTERFACE String toString(long in);
-    DOCTEST_INTERFACE String toString(long unsigned in);
-    DOCTEST_INTERFACE String toString(long long in);
-    DOCTEST_INTERFACE String toString(long long unsigned in);
-
-    template <typename T, typename detail::types::enable_if<detail::should_stringify_as_underlying_type<T>::value, bool>::type = true>
-    String toString(const DOCTEST_REF_WRAP(T) value) {
-        using UT = typename detail::types::underlying_type<T>::type;
-        return (DOCTEST_STRINGIFY(static_cast<UT>(value)));
-    }
-
-    namespace detail {
-        template <typename T>
-        struct filldata
-        {
-            static void fill(std::ostream* stream, const T& in) {
-#if defined(_MSC_VER) && _MSC_VER <= 1900
-                insert_hack_t<T>::insert(*stream, in);
-#else
-                operator<<(*stream, in);
-#endif
-            }
-        };
-
-        DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4866)
-// NOLINTBEGIN(*-avoid-c-arrays)
-        template <typename T, size_t N>
-        struct filldata<T[N]> {
-            static void fill(std::ostream* stream, const T(&in)[N]) {
-                *stream << "[";
-                for (size_t i = 0; i < N; i++) {
-                    if (i != 0) { *stream << ", "; }
-                    *stream << (DOCTEST_STRINGIFY(in[i]));
-                }
-                *stream << "]";
-            }
-        };
-// NOLINTEND(*-avoid-c-arrays)
-        DOCTEST_MSVC_SUPPRESS_WARNING_POP
-
-        // Specialized since we don't want the terminating null byte!
-// NOLINTBEGIN(*-avoid-c-arrays)
-        template <size_t N>
-        struct filldata<const char[N]> {
-            static void fill(std::ostream* stream, const char (&in)[N]) {
-                *stream << String(in, in[N - 1] ? N : N - 1);
-            } // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
-        };
-// NOLINTEND(*-avoid-c-arrays)
-
-        template <>
-        struct filldata<const void*> {
-            static void fill(std::ostream* stream, const void* in);
-        };
-
-        template <typename T>
-        struct filldata<T*> {
-            DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4180)
-            static void fill(std::ostream* stream, const T* in) {
-                DOCTEST_MSVC_SUPPRESS_WARNING_POP
-                DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wmicrosoft-cast")
-                filldata<const void*>::fill(stream,
-#if DOCTEST_GCC == 0 || DOCTEST_GCC >= DOCTEST_COMPILER(4, 9, 0)
-                                            reinterpret_cast<const void*>(in)
-#else
-                        *reinterpret_cast<const void* const*>(&in)
-#endif
-                );
-                DOCTEST_CLANG_SUPPRESS_WARNING_POP
-            }
-        };
-    }
-
-    struct DOCTEST_INTERFACE Approx
-    {
-        Approx(double value);
-
-        Approx operator()(double value) const;
-
-#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-        template <typename T>
-    explicit Approx(const T& value,
-                    typename detail::types::enable_if<std::is_constructible<double, T>::value>::type* =
-                            static_cast<T*>(nullptr)) {
-        *this = static_cast<double>(value);
-    }
-#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-
-        Approx& epsilon(double newEpsilon);
-
-#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-        template <typename T>
-    typename std::enable_if<std::is_constructible<double, T>::value, Approx&>::type epsilon(
-            const T& newEpsilon) {
-        m_epsilon = static_cast<double>(newEpsilon);
-        return *this;
-    }
-#endif //  DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-
-        Approx& scale(double newScale);
-
-#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-        template <typename T>
-    typename std::enable_if<std::is_constructible<double, T>::value, Approx&>::type scale(
-            const T& newScale) {
-        m_scale = static_cast<double>(newScale);
-        return *this;
-    }
-#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-
-        // clang-format off
-        DOCTEST_INTERFACE friend bool operator==(double lhs, const Approx & rhs);
-        DOCTEST_INTERFACE friend bool operator==(const Approx & lhs, double rhs);
-        DOCTEST_INTERFACE friend bool operator!=(double lhs, const Approx & rhs);
-        DOCTEST_INTERFACE friend bool operator!=(const Approx & lhs, double rhs);
-        DOCTEST_INTERFACE friend bool operator<=(double lhs, const Approx & rhs);
-        DOCTEST_INTERFACE friend bool operator<=(const Approx & lhs, double rhs);
-        DOCTEST_INTERFACE friend bool operator>=(double lhs, const Approx & rhs);
-        DOCTEST_INTERFACE friend bool operator>=(const Approx & lhs, double rhs);
-        DOCTEST_INTERFACE friend bool operator< (double lhs, const Approx & rhs);
-        DOCTEST_INTERFACE friend bool operator< (const Approx & lhs, double rhs);
-        DOCTEST_INTERFACE friend bool operator> (double lhs, const Approx & rhs);
-        DOCTEST_INTERFACE friend bool operator> (const Approx & lhs, double rhs);
-
-#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-        #define DOCTEST_APPROX_PREFIX \
-    template <typename T> friend typename std::enable_if<std::is_constructible<double, T>::value, bool>::type
-
-    DOCTEST_APPROX_PREFIX operator==(const T& lhs, const Approx& rhs) { return operator==(static_cast<double>(lhs), rhs); }
-    DOCTEST_APPROX_PREFIX operator==(const Approx& lhs, const T& rhs) { return operator==(rhs, lhs); }
-    DOCTEST_APPROX_PREFIX operator!=(const T& lhs, const Approx& rhs) { return !operator==(lhs, rhs); }
-    DOCTEST_APPROX_PREFIX operator!=(const Approx& lhs, const T& rhs) { return !operator==(rhs, lhs); }
-    DOCTEST_APPROX_PREFIX operator<=(const T& lhs, const Approx& rhs) { return static_cast<double>(lhs) < rhs.m_value || lhs == rhs; }
-    DOCTEST_APPROX_PREFIX operator<=(const Approx& lhs, const T& rhs) { return lhs.m_value < static_cast<double>(rhs) || lhs == rhs; }
-    DOCTEST_APPROX_PREFIX operator>=(const T& lhs, const Approx& rhs) { return static_cast<double>(lhs) > rhs.m_value || lhs == rhs; }
-    DOCTEST_APPROX_PREFIX operator>=(const Approx& lhs, const T& rhs) { return lhs.m_value > static_cast<double>(rhs) || lhs == rhs; }
-    DOCTEST_APPROX_PREFIX operator< (const T& lhs, const Approx& rhs) { return static_cast<double>(lhs) < rhs.m_value && lhs != rhs; }
-    DOCTEST_APPROX_PREFIX operator< (const Approx& lhs, const T& rhs) { return lhs.m_value < static_cast<double>(rhs) && lhs != rhs; }
-    DOCTEST_APPROX_PREFIX operator> (const T& lhs, const Approx& rhs) { return static_cast<double>(lhs) > rhs.m_value && lhs != rhs; }
-    DOCTEST_APPROX_PREFIX operator> (const Approx& lhs, const T& rhs) { return lhs.m_value > static_cast<double>(rhs) && lhs != rhs; }
-#undef DOCTEST_APPROX_PREFIX
-#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
-
-        // clang-format on
-
-        double m_epsilon;
-        double m_scale;
-        double m_value;
-    };
-
-    DOCTEST_INTERFACE String toString(const Approx& in);
-
-    DOCTEST_INTERFACE const ContextOptions* getContextOptions();
-
-    template <typename F>
-    struct DOCTEST_INTERFACE_DECL IsNaN
-    {
-        F value; bool flipped;
-        IsNaN(F f, bool flip = false) : value(f), flipped(flip) { }
-        IsNaN<F> operator!() const { return { value, !flipped }; }
-        operator bool() const;
-    };
-#ifndef __MINGW32__
-    extern template struct DOCTEST_INTERFACE_DECL IsNaN<float>;
-    extern template struct DOCTEST_INTERFACE_DECL IsNaN<double>;
-    extern template struct DOCTEST_INTERFACE_DECL IsNaN<long double>;
-#endif
-    DOCTEST_INTERFACE String toString(IsNaN<float> in);
-    DOCTEST_INTERFACE String toString(IsNaN<double> in);
-    DOCTEST_INTERFACE String toString(IsNaN<double long> in);
-
-#ifndef DOCTEST_CONFIG_DISABLE
-
-    namespace detail {
-        // clang-format off
-#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
-        template<class T>               struct decay_array       { using type = T; };
-    template<class T, unsigned N>   struct decay_array<T[N]> { using type = T*; };
-    template<class T>               struct decay_array<T[]>  { using type = T*; };
-
-    template<class T>   struct not_char_pointer              { static DOCTEST_CONSTEXPR int value = 1; };
-    template<>          struct not_char_pointer<char*>       { static DOCTEST_CONSTEXPR int value = 0; };
-    template<>          struct not_char_pointer<const char*> { static DOCTEST_CONSTEXPR int value = 0; };
-
-    template<class T> struct can_use_op : public not_char_pointer<typename decay_array<T>::type> {};
-#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
-        // clang-format on
-
-        struct DOCTEST_INTERFACE TestFailureException
-        {
-        };
-
-        DOCTEST_INTERFACE bool checkIfShouldThrow(assertType::Enum at);
-
-#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
-        DOCTEST_NORETURN
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
-        DOCTEST_INTERFACE void throwException();
-
-        struct DOCTEST_INTERFACE Subcase
-        {
-            SubcaseSignature m_signature;
-            bool             m_entered = false;
-
-            Subcase(const String& name, const char* file, int line);
-            Subcase(const Subcase&) = delete;
-            Subcase(Subcase&&) = delete;
-            Subcase& operator=(const Subcase&) = delete;
-            Subcase& operator=(Subcase&&) = delete;
-            ~Subcase();
-
-            operator bool() const;
-
-        private:
-            bool checkFilters();
-        };
-
-        template <typename L, typename R>
-        String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
-                                   const DOCTEST_REF_WRAP(R) rhs) {
-            return (DOCTEST_STRINGIFY(lhs)) + op + (DOCTEST_STRINGIFY(rhs));
-        }
-
-#if DOCTEST_CLANG && DOCTEST_CLANG < DOCTEST_COMPILER(3, 6, 0)
-        DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wunused-comparison")
-#endif
-
-// This will check if there is any way it could find a operator like member or friend and uses it.
-// If not it doesn't find the operator or if the operator at global scope is defined after
-// this template, the template won't be instantiated due to SFINAE. Once the template is not
-// instantiated it can look for global operator using normal conversions.
-#ifdef __NVCC__
-#define SFINAE_OP(ret,op) ret
-#else
-#define SFINAE_OP(ret,op) decltype((void)(doctest::detail::declval<L>() op doctest::detail::declval<R>()),ret{})
-#endif
-
-#define DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(op, op_str, op_macro)                              \
-    template <typename R>                                                                          \
-    DOCTEST_NOINLINE SFINAE_OP(Result,op) operator op(R&& rhs) {                                   \
-    bool res = op_macro(doctest::detail::forward<const L>(lhs), doctest::detail::forward<R>(rhs)); \
-        if(m_at & assertType::is_false)                                                            \
-            res = !res;                                                                            \
-        if(!res || doctest::getContextOptions()->success)                                          \
-            return Result(res, stringifyBinaryExpr(lhs, op_str, rhs));                             \
-        return Result(res);                                                                        \
-    }
-
-        // more checks could be added - like in Catch:
-        // https://github.com/catchorg/Catch2/pull/1480/files
-        // https://github.com/catchorg/Catch2/pull/1481/files
-#define DOCTEST_FORBIT_EXPRESSION(rt, op)                                                          \
-    template <typename R>                                                                          \
-    rt& operator op(const R&) {                                                                    \
-        static_assert(deferred_false<R>::value,                                                    \
-                      "Expression Too Complex Please Rewrite As Binary Comparison!");              \
-        return *this;                                                                              \
-    }
-
-        struct DOCTEST_INTERFACE Result // NOLINT(*-member-init)
-        {
-            bool   m_passed;
-            String m_decomp;
-
-            Result() = default; // TODO: Why do we need this? (To remove NOLINT)
-            Result(bool passed, const String& decomposition = String());
-
-            // forbidding some expressions based on this table: https://en.cppreference.com/w/cpp/language/operator_precedence
-            DOCTEST_FORBIT_EXPRESSION(Result, &)
-            DOCTEST_FORBIT_EXPRESSION(Result, ^)
-            DOCTEST_FORBIT_EXPRESSION(Result, |)
-            DOCTEST_FORBIT_EXPRESSION(Result, &&)
-            DOCTEST_FORBIT_EXPRESSION(Result, ||)
-            DOCTEST_FORBIT_EXPRESSION(Result, ==)
-            DOCTEST_FORBIT_EXPRESSION(Result, !=)
-            DOCTEST_FORBIT_EXPRESSION(Result, <)
-            DOCTEST_FORBIT_EXPRESSION(Result, >)
-            DOCTEST_FORBIT_EXPRESSION(Result, <=)
-            DOCTEST_FORBIT_EXPRESSION(Result, >=)
-            DOCTEST_FORBIT_EXPRESSION(Result, =)
-            DOCTEST_FORBIT_EXPRESSION(Result, +=)
-            DOCTEST_FORBIT_EXPRESSION(Result, -=)
-            DOCTEST_FORBIT_EXPRESSION(Result, *=)
-            DOCTEST_FORBIT_EXPRESSION(Result, /=)
-            DOCTEST_FORBIT_EXPRESSION(Result, %=)
-            DOCTEST_FORBIT_EXPRESSION(Result, <<=)
-            DOCTEST_FORBIT_EXPRESSION(Result, >>=)
-            DOCTEST_FORBIT_EXPRESSION(Result, &=)
-            DOCTEST_FORBIT_EXPRESSION(Result, ^=)
-            DOCTEST_FORBIT_EXPRESSION(Result, |=)
-        };
-
-#ifndef DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION
-
-        DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
-        DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-conversion")
-        DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-compare")
-        //DOCTEST_CLANG_SUPPRESS_WARNING("-Wdouble-promotion")
-        //DOCTEST_CLANG_SUPPRESS_WARNING("-Wconversion")
-        //DOCTEST_CLANG_SUPPRESS_WARNING("-Wfloat-equal")
-
-        DOCTEST_GCC_SUPPRESS_WARNING_PUSH
-        DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-conversion")
-        DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-compare")
-        //DOCTEST_GCC_SUPPRESS_WARNING("-Wdouble-promotion")
-        //DOCTEST_GCC_SUPPRESS_WARNING("-Wconversion")
-        //DOCTEST_GCC_SUPPRESS_WARNING("-Wfloat-equal")
-
-        DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
-        // https://stackoverflow.com/questions/39479163 what's the difference between 4018 and 4389
-        DOCTEST_MSVC_SUPPRESS_WARNING(4388) // signed/unsigned mismatch
-        DOCTEST_MSVC_SUPPRESS_WARNING(4389) // 'operator' : signed/unsigned mismatch
-        DOCTEST_MSVC_SUPPRESS_WARNING(4018) // 'expression' : signed/unsigned mismatch
-        //DOCTEST_MSVC_SUPPRESS_WARNING(4805) // 'operation' : unsafe mix of type 'type' and type 'type' in operation
-
-#endif // DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION
-
-        // clang-format off
-#ifndef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
-#define DOCTEST_COMPARISON_RETURN_TYPE bool
-#else // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
-        #define DOCTEST_COMPARISON_RETURN_TYPE typename types::enable_if<can_use_op<L>::value || can_use_op<R>::value, bool>::type
-    inline bool eq(const char* lhs, const char* rhs) { return String(lhs) == String(rhs); }
-    inline bool ne(const char* lhs, const char* rhs) { return String(lhs) != String(rhs); }
-    inline bool lt(const char* lhs, const char* rhs) { return String(lhs) <  String(rhs); }
-    inline bool gt(const char* lhs, const char* rhs) { return String(lhs) >  String(rhs); }
-    inline bool le(const char* lhs, const char* rhs) { return String(lhs) <= String(rhs); }
-    inline bool ge(const char* lhs, const char* rhs) { return String(lhs) >= String(rhs); }
-#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
-        // clang-format on
-
-#define DOCTEST_RELATIONAL_OP(name, op)                                                            \
-    template <typename L, typename R>                                                              \
-    DOCTEST_COMPARISON_RETURN_TYPE name(const DOCTEST_REF_WRAP(L) lhs,                             \
-                                        const DOCTEST_REF_WRAP(R) rhs) {                           \
-        return lhs op rhs;                                                                         \
-    }
-
-        DOCTEST_RELATIONAL_OP(eq, ==)
-        DOCTEST_RELATIONAL_OP(ne, !=)
-        DOCTEST_RELATIONAL_OP(lt, <)
-        DOCTEST_RELATIONAL_OP(gt, >)
-        DOCTEST_RELATIONAL_OP(le, <=)
-        DOCTEST_RELATIONAL_OP(ge, >=)
-
-#ifndef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
-#define DOCTEST_CMP_EQ(l, r) l == r
-#define DOCTEST_CMP_NE(l, r) l != r
-#define DOCTEST_CMP_GT(l, r) l > r
-#define DOCTEST_CMP_LT(l, r) l < r
-#define DOCTEST_CMP_GE(l, r) l >= r
-#define DOCTEST_CMP_LE(l, r) l <= r
-#else // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
-        #define DOCTEST_CMP_EQ(l, r) eq(l, r)
-#define DOCTEST_CMP_NE(l, r) ne(l, r)
-#define DOCTEST_CMP_GT(l, r) gt(l, r)
-#define DOCTEST_CMP_LT(l, r) lt(l, r)
-#define DOCTEST_CMP_GE(l, r) ge(l, r)
-#define DOCTEST_CMP_LE(l, r) le(l, r)
-#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
-
-        template <typename L>
-        // cppcheck-suppress copyCtorAndEqOperator
-        struct Expression_lhs
-        {
-            L                lhs;
-            assertType::Enum m_at;
-
-            explicit Expression_lhs(L&& in, assertType::Enum at)
-                    : lhs(static_cast<L&&>(in))
-                    , m_at(at) {}
-
-            DOCTEST_NOINLINE operator Result() {
-// this is needed only for MSVC 2015
-                DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4800) // 'int': forcing value to bool
-                bool res = static_cast<bool>(lhs);
-                DOCTEST_MSVC_SUPPRESS_WARNING_POP
-                if(m_at & assertType::is_false) { //!OCLINT bitwise operator in conditional
-                    res = !res;
-                }
-
-                if(!res || getContextOptions()->success) {
-                    return { res, (DOCTEST_STRINGIFY(lhs)) };
-                }
-                return { res };
-            }
-
-            /* This is required for user-defined conversions from Expression_lhs to L */
-            operator L() const { return lhs; }
-
-            // clang-format off
-            DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(==, " == ", DOCTEST_CMP_EQ) //!OCLINT bitwise operator in conditional
-            DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(!=, " != ", DOCTEST_CMP_NE) //!OCLINT bitwise operator in conditional
-            DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(>,  " >  ", DOCTEST_CMP_GT) //!OCLINT bitwise operator in conditional
-            DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(<,  " <  ", DOCTEST_CMP_LT) //!OCLINT bitwise operator in conditional
-            DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(>=, " >= ", DOCTEST_CMP_GE) //!OCLINT bitwise operator in conditional
-            DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(<=, " <= ", DOCTEST_CMP_LE) //!OCLINT bitwise operator in conditional
-            // clang-format on
-
-            // forbidding some expressions based on this table: https://en.cppreference.com/w/cpp/language/operator_precedence
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ^)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, |)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &&)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ||)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, =)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, +=)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, -=)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, *=)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, /=)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, %=)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, <<=)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, >>=)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &=)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ^=)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, |=)
-            // these 2 are unfortunate because they should be allowed - they have higher precedence over the comparisons, but the
-            // ExpressionDecomposer class uses the left shift operator to capture the left operand of the binary expression...
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, <<)
-            DOCTEST_FORBIT_EXPRESSION(Expression_lhs, >>)
-        };
-
-#ifndef DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION
-
-        DOCTEST_CLANG_SUPPRESS_WARNING_POP
-        DOCTEST_MSVC_SUPPRESS_WARNING_POP
-        DOCTEST_GCC_SUPPRESS_WARNING_POP
-
-#endif // DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION
-
-#if DOCTEST_CLANG && DOCTEST_CLANG < DOCTEST_COMPILER(3, 6, 0)
-        DOCTEST_CLANG_SUPPRESS_WARNING_POP
-#endif
-
-        struct DOCTEST_INTERFACE ExpressionDecomposer
-        {
-            assertType::Enum m_at;
-
-            ExpressionDecomposer(assertType::Enum at);
-
-            // The right operator for capturing expressions is "<=" instead of "<<" (based on the operator precedence table)
-            // but then there will be warnings from GCC about "-Wparentheses" and since "_Pragma()" is problematic this will stay for now...
-            // https://github.com/catchorg/Catch2/issues/870
-            // https://github.com/catchorg/Catch2/issues/565
-            template <typename L>
-            Expression_lhs<L> operator<<(L&& operand) {
-                return Expression_lhs<L>(static_cast<L&&>(operand), m_at);
-            }
-
-            template <typename L,typename types::enable_if<!doctest::detail::types::is_rvalue_reference<L>::value,void >::type* = nullptr>
-            Expression_lhs<const L&> operator<<(const L &operand) {
-                return Expression_lhs<const L&>(operand, m_at);
-            }
-        };
-
-        struct DOCTEST_INTERFACE TestSuite
-        {
-            const char* m_test_suite = nullptr;
-            const char* m_description = nullptr;
-            bool        m_skip = false;
-            bool        m_no_breaks = false;
-            bool        m_no_output = false;
-            bool        m_may_fail = false;
-            bool        m_should_fail = false;
-            int         m_expected_failures = 0;
-            double      m_timeout = 0;
-
-            TestSuite& operator*(const char* in);
-
-            template <typename T>
-            TestSuite& operator*(const T& in) {
-                in.fill(*this);
-                return *this;
-            }
-        };
-
-        using funcType = void (*)();
-
-        struct DOCTEST_INTERFACE TestCase : public TestCaseData
-        {
-            funcType m_test; // a function pointer to the test case
-
-            String m_type; // for templated test cases - gets appended to the real name
-            int m_template_id; // an ID used to distinguish between the different versions of a templated test case
-            String m_full_name; // contains the name (only for templated test cases!) + the template type
-
-            TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite,
-                     const String& type = String(), int template_id = -1);
-
-            TestCase(const TestCase& other);
-            TestCase(TestCase&&) = delete;
-
-            DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(26434) // hides a non-virtual function
-            TestCase& operator=(const TestCase& other);
-            DOCTEST_MSVC_SUPPRESS_WARNING_POP
-
-            TestCase& operator=(TestCase&&) = delete;
-
-            TestCase& operator*(const char* in);
-
-            template <typename T>
-            TestCase& operator*(const T& in) {
-                in.fill(*this);
-                return *this;
-            }
-
-            bool operator<(const TestCase& other) const;
-
-            ~TestCase() = default;
-        };
-
-        // forward declarations of functions used by the macros
-        DOCTEST_INTERFACE int  regTest(const TestCase& tc);
-        DOCTEST_INTERFACE int  setTestSuite(const TestSuite& ts);
-        DOCTEST_INTERFACE bool isDebuggerActive();
-
-        template<typename T>
-        int instantiationHelper(const T&) { return 0; }
-
-        namespace binaryAssertComparison {
-            enum Enum
-            {
-                eq = 0,
-                ne,
-                gt,
-                lt,
-                ge,
-                le
-            };
-        } // namespace binaryAssertComparison
-
-        // clang-format off
-        template <int, class L, class R> struct RelationalComparator     { bool operator()(const DOCTEST_REF_WRAP(L),     const DOCTEST_REF_WRAP(R)    ) const { return false;        } };
-
-#define DOCTEST_BINARY_RELATIONAL_OP(n, op) \
-    template <class L, class R> struct RelationalComparator<n, L, R> { bool operator()(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) const { return op(lhs, rhs); } };
-        // clang-format on
-
-        DOCTEST_BINARY_RELATIONAL_OP(0, doctest::detail::eq)
-        DOCTEST_BINARY_RELATIONAL_OP(1, doctest::detail::ne)
-        DOCTEST_BINARY_RELATIONAL_OP(2, doctest::detail::gt)
-        DOCTEST_BINARY_RELATIONAL_OP(3, doctest::detail::lt)
-        DOCTEST_BINARY_RELATIONAL_OP(4, doctest::detail::ge)
-        DOCTEST_BINARY_RELATIONAL_OP(5, doctest::detail::le)
-
-        struct DOCTEST_INTERFACE ResultBuilder : public AssertData
-        {
-            ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
-                          const char* exception_type = "", const String& exception_string = "");
-
-            ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
-                          const char* exception_type, const Contains& exception_string);
-
-            void setResult(const Result& res);
-
-            template <int comparison, typename L, typename R>
-            DOCTEST_NOINLINE bool binary_assert(const DOCTEST_REF_WRAP(L) lhs,
-                                                const DOCTEST_REF_WRAP(R) rhs) {
-                m_failed = !RelationalComparator<comparison, L, R>()(lhs, rhs);
-                if (m_failed || getContextOptions()->success) {
-                    m_decomp = stringifyBinaryExpr(lhs, ", ", rhs);
-                }
-                return !m_failed;
-            }
-
-            template <typename L>
-            DOCTEST_NOINLINE bool unary_assert(const DOCTEST_REF_WRAP(L) val) {
-                m_failed = !val;
-
-                if (m_at & assertType::is_false) { //!OCLINT bitwise operator in conditional
-                    m_failed = !m_failed;
-                }
-
-                if (m_failed || getContextOptions()->success) {
-                    m_decomp = (DOCTEST_STRINGIFY(val));
-                }
-
-                return !m_failed;
-            }
-
-            void translateException();
-
-            bool log();
-            void react() const;
-        };
-
-        namespace assertAction {
-            enum Enum
-            {
-                nothing     = 0,
-                dbgbreak    = 1,
-                shouldthrow = 2
-            };
-        } // namespace assertAction
-
-        DOCTEST_INTERFACE void failed_out_of_a_testing_context(const AssertData& ad);
-
-        DOCTEST_INTERFACE bool decomp_assert(assertType::Enum at, const char* file, int line,
-                                             const char* expr, const Result& result);
-
-#define DOCTEST_ASSERT_OUT_OF_TESTS(decomp)                                                        \
-    do {                                                                                           \
-        if(!is_running_in_test) {                                                                  \
-            if(failed) {                                                                           \
-                ResultBuilder rb(at, file, line, expr);                                            \
-                rb.m_failed = failed;                                                              \
-                rb.m_decomp = decomp;                                                              \
-                failed_out_of_a_testing_context(rb);                                               \
-                if(isDebuggerActive() && !getContextOptions()->no_breaks)                          \
-                    DOCTEST_BREAK_INTO_DEBUGGER();                                                 \
-                if(checkIfShouldThrow(at))                                                         \
-                    throwException();                                                              \
-            }                                                                                      \
-            return !failed;                                                                        \
-        }                                                                                          \
-    } while(false)
-
-#define DOCTEST_ASSERT_IN_TESTS(decomp)                                                            \
-    ResultBuilder rb(at, file, line, expr);                                                        \
-    rb.m_failed = failed;                                                                          \
-    if(rb.m_failed || getContextOptions()->success)                                                \
-        rb.m_decomp = decomp;                                                                      \
-    if(rb.log())                                                                                   \
-        DOCTEST_BREAK_INTO_DEBUGGER();                                                             \
-    if(rb.m_failed && checkIfShouldThrow(at))                                                      \
-    throwException()
-
-        template <int comparison, typename L, typename R>
-        DOCTEST_NOINLINE bool binary_assert(assertType::Enum at, const char* file, int line,
-                                            const char* expr, const DOCTEST_REF_WRAP(L) lhs,
-                                            const DOCTEST_REF_WRAP(R) rhs) {
-            bool failed = !RelationalComparator<comparison, L, R>()(lhs, rhs);
-
-            // ###################################################################################
-            // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
-            // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
-            // ###################################################################################
-            DOCTEST_ASSERT_OUT_OF_TESTS(stringifyBinaryExpr(lhs, ", ", rhs));
-            DOCTEST_ASSERT_IN_TESTS(stringifyBinaryExpr(lhs, ", ", rhs));
-            return !failed;
-        }
-
-        template <typename L>
-        DOCTEST_NOINLINE bool unary_assert(assertType::Enum at, const char* file, int line,
-                                           const char* expr, const DOCTEST_REF_WRAP(L) val) {
-            bool failed = !val;
-
-            if(at & assertType::is_false) //!OCLINT bitwise operator in conditional
-                failed = !failed;
-
-            // ###################################################################################
-            // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
-            // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
-            // ###################################################################################
-            DOCTEST_ASSERT_OUT_OF_TESTS((DOCTEST_STRINGIFY(val)));
-            DOCTEST_ASSERT_IN_TESTS((DOCTEST_STRINGIFY(val)));
-            return !failed;
-        }
-
-        struct DOCTEST_INTERFACE IExceptionTranslator
-        {
-            DOCTEST_DECLARE_INTERFACE(IExceptionTranslator)
-            virtual bool translate(String&) const = 0;
-        };
-
-        template <typename T>
-        class ExceptionTranslator : public IExceptionTranslator //!OCLINT destructor of virtual class
-        {
-        public:
-            explicit ExceptionTranslator(String (*translateFunction)(T))
-                    : m_translateFunction(translateFunction) {}
-
-            bool translate(String& res) const override {
-#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
-                try {
-                    throw; // lgtm [cpp/rethrow-no-exception]
-                    // cppcheck-suppress catchExceptionByValue
-                } catch(const T& ex) {
-                    res = m_translateFunction(ex); //!OCLINT parameter reassignment
-                    return true;
-                } catch(...) {}         //!OCLINT -  empty catch statement
-#endif                              // DOCTEST_CONFIG_NO_EXCEPTIONS
-                static_cast<void>(res); // to silence -Wunused-parameter
-                return false;
-            }
-
-        private:
-            String (*m_translateFunction)(T);
-        };
-
-        DOCTEST_INTERFACE void registerExceptionTranslatorImpl(const IExceptionTranslator* et);
-
-        // ContextScope base class used to allow implementing methods of ContextScope
-        // that don't depend on the template parameter in doctest.cpp.
-        struct DOCTEST_INTERFACE ContextScopeBase : public IContextScope {
-            ContextScopeBase(const ContextScopeBase&) = delete;
-
-            ContextScopeBase& operator=(const ContextScopeBase&) = delete;
-            ContextScopeBase& operator=(ContextScopeBase&&) = delete;
-
-            ~ContextScopeBase() override = default;
-
-        protected:
-            ContextScopeBase();
-            ContextScopeBase(ContextScopeBase&& other) noexcept;
-
-            void destroy();
-            bool need_to_destroy{true};
-        };
-
-        template <typename L> class ContextScope : public ContextScopeBase
-        {
-            L lambda_;
-
-        public:
-            explicit ContextScope(const L &lambda) : lambda_(lambda) {}
-            explicit ContextScope(L&& lambda) : lambda_(static_cast<L&&>(lambda)) { }
-
-            ContextScope(const ContextScope&) = delete;
-            ContextScope(ContextScope&&) noexcept = default;
-
-            ContextScope& operator=(const ContextScope&) = delete;
-            ContextScope& operator=(ContextScope&&) = delete;
-
-            void stringify(std::ostream* s) const override { lambda_(s); }
-
-            ~ContextScope() override {
-                if (need_to_destroy) {
-                    destroy();
-                }
-            }
-        };
-
-        struct DOCTEST_INTERFACE MessageBuilder : public MessageData
-        {
-            std::ostream* m_stream;
-            bool          logged = false;
-
-            MessageBuilder(const char* file, int line, assertType::Enum severity);
-
-            MessageBuilder(const MessageBuilder&) = delete;
-            MessageBuilder(MessageBuilder&&) = delete;
-
-            MessageBuilder& operator=(const MessageBuilder&) = delete;
-            MessageBuilder& operator=(MessageBuilder&&) = delete;
-
-            ~MessageBuilder();
-
-            // the preferred way of chaining parameters for stringification
-            DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4866)
-            template <typename T>
-            MessageBuilder& operator,(const T& in) {
-                *m_stream << (DOCTEST_STRINGIFY(in));
-                return *this;
-            }
-            DOCTEST_MSVC_SUPPRESS_WARNING_POP
-
-            // kept here just for backwards-compatibility - the comma operator should be preferred now
-            template <typename T>
-            MessageBuilder& operator<<(const T& in) { return this->operator,(in); }
-
-            // the `,` operator has the lowest operator precedence - if `<<` is used by the user then
-            // the `,` operator will be called last which is not what we want and thus the `*` operator
-            // is used first (has higher operator precedence compared to `<<`) so that we guarantee that
-            // an operator of the MessageBuilder class is called first before the rest of the parameters
-            template <typename T>
-            MessageBuilder& operator*(const T& in) { return this->operator,(in); }
-
-            bool log();
-            void react();
-        };
-
-        template <typename L>
-        ContextScope<L> MakeContextScope(const L &lambda) {
-            return ContextScope<L>(lambda);
-        }
-    } // namespace detail
-
-#define DOCTEST_DEFINE_DECORATOR(name, type, def)                                                  \
-    struct name                                                                                    \
-    {                                                                                              \
-        type data;                                                                                 \
-        name(type in = def)                                                                        \
-                : data(in) {}                                                                      \
-        void fill(detail::TestCase& state) const { state.DOCTEST_CAT(m_, name) = data; }           \
-        void fill(detail::TestSuite& state) const { state.DOCTEST_CAT(m_, name) = data; }          \
-    }
-
-    DOCTEST_DEFINE_DECORATOR(test_suite, const char*, "");
-    DOCTEST_DEFINE_DECORATOR(description, const char*, "");
-    DOCTEST_DEFINE_DECORATOR(skip, bool, true);
-    DOCTEST_DEFINE_DECORATOR(no_breaks, bool, true);
-    DOCTEST_DEFINE_DECORATOR(no_output, bool, true);
-    DOCTEST_DEFINE_DECORATOR(timeout, double, 0);
-    DOCTEST_DEFINE_DECORATOR(may_fail, bool, true);
-    DOCTEST_DEFINE_DECORATOR(should_fail, bool, true);
-    DOCTEST_DEFINE_DECORATOR(expected_failures, int, 0);
-
-    template <typename T>
-    int registerExceptionTranslator(String (*translateFunction)(T)) {
-        DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wexit-time-destructors")
-        static detail::ExceptionTranslator<T> exceptionTranslator(translateFunction);
-        DOCTEST_CLANG_SUPPRESS_WARNING_POP
-        detail::registerExceptionTranslatorImpl(&exceptionTranslator);
-        return 0;
-    }
-
-} // namespace doctest
-
-// in a separate namespace outside of doctest because the DOCTEST_TEST_SUITE macro
-// introduces an anonymous namespace in which getCurrentTestSuite gets overridden
-namespace doctest_detail_test_suite_ns {
-    DOCTEST_INTERFACE doctest::detail::TestSuite& getCurrentTestSuite();
-} // namespace doctest_detail_test_suite_ns
-
-namespace doctest {
-#else  // DOCTEST_CONFIG_DISABLE
-    template <typename T>
-int registerExceptionTranslator(String (*)(T)) {
-    return 0;
-}
-#endif // DOCTEST_CONFIG_DISABLE
-
-    namespace detail {
-        using assert_handler = void (*)(const AssertData&);
-        struct ContextState;
-    } // namespace detail
-
-    class DOCTEST_INTERFACE Context
-    {
-        detail::ContextState* p;
-
-        void parseArgs(int argc, const char* const* argv, bool withDefaults = false);
-
-    public:
-        explicit Context(int argc = 0, const char* const* argv = nullptr);
-
-        Context(const Context&) = delete;
-        Context(Context&&) = delete;
-
-        Context& operator=(const Context&) = delete;
-        Context& operator=(Context&&) = delete;
-
-        ~Context(); // NOLINT(performance-trivially-destructible)
-
-        void applyCommandLine(int argc, const char* const* argv);
-
-        void addFilter(const char* filter, const char* value);
-        void clearFilters();
-        void setOption(const char* option, bool value);
-        void setOption(const char* option, int value);
-        void setOption(const char* option, const char* value);
-
-        bool shouldExit();
-
-        void setAsDefaultForAssertsOutOfTestCases();
-
-        void setAssertHandler(detail::assert_handler ah);
-
-        void setCout(std::ostream* out);
-
-        int run();
-    };
-
-    namespace TestCaseFailureReason {
-        enum Enum
-        {
-            None                     = 0,
-            AssertFailure            = 1,   // an assertion has failed in the test case
-            Exception                = 2,   // test case threw an exception
-            Crash                    = 4,   // a crash...
-            TooManyFailedAsserts     = 8,   // the abort-after option
-            Timeout                  = 16,  // see the timeout decorator
-            ShouldHaveFailedButDidnt = 32,  // see the should_fail decorator
-            ShouldHaveFailedAndDid   = 64,  // see the should_fail decorator
-            DidntFailExactlyNumTimes = 128, // see the expected_failures decorator
-            FailedExactlyNumTimes    = 256, // see the expected_failures decorator
-            CouldHaveFailedAndDid    = 512  // see the may_fail decorator
-        };
-    } // namespace TestCaseFailureReason
-
-    struct DOCTEST_INTERFACE CurrentTestCaseStats
-    {
-        int    numAssertsCurrentTest;
-        int    numAssertsFailedCurrentTest;
-        double seconds;
-        int    failure_flags; // use TestCaseFailureReason::Enum
-        bool   testCaseSuccess;
-    };
-
-    struct DOCTEST_INTERFACE TestCaseException
-    {
-        String error_string;
-        bool   is_crash;
-    };
-
-    struct DOCTEST_INTERFACE TestRunStats
-    {
-        unsigned numTestCases;
-        unsigned numTestCasesPassingFilters;
-        unsigned numTestSuitesPassingFilters;
-        unsigned numTestCasesFailed;
-        int      numAsserts;
-        int      numAssertsFailed;
-    };
-
-    struct QueryData
-    {
-        const TestRunStats*  run_stats = nullptr;
-        const TestCaseData** data      = nullptr;
-        unsigned             num_data  = 0;
-    };
-
-    struct DOCTEST_INTERFACE IReporter
-    {
-        // The constructor has to accept "const ContextOptions&" as a single argument
-        // which has most of the options for the run + a pointer to the stdout stream
-        // Reporter(const ContextOptions& in)
-
-        // called when a query should be reported (listing test cases, printing the version, etc.)
-        virtual void report_query(const QueryData&) = 0;
-
-        // called when the whole test run starts
-        virtual void test_run_start() = 0;
-        // called when the whole test run ends (caching a pointer to the input doesn't make sense here)
-        virtual void test_run_end(const TestRunStats&) = 0;
-
-        // called when a test case is started (safe to cache a pointer to the input)
-        virtual void test_case_start(const TestCaseData&) = 0;
-        // called when a test case is reentered because of unfinished subcases (safe to cache a pointer to the input)
-        virtual void test_case_reenter(const TestCaseData&) = 0;
-        // called when a test case has ended
-        virtual void test_case_end(const CurrentTestCaseStats&) = 0;
-
-        // called when an exception is thrown from the test case (or it crashes)
-        virtual void test_case_exception(const TestCaseException&) = 0;
-
-        // called whenever a subcase is entered (don't cache pointers to the input)
-        virtual void subcase_start(const SubcaseSignature&) = 0;
-        // called whenever a subcase is exited (don't cache pointers to the input)
-        virtual void subcase_end() = 0;
-
-        // called for each assert (don't cache pointers to the input)
-        virtual void log_assert(const AssertData&) = 0;
-        // called for each message (don't cache pointers to the input)
-        virtual void log_message(const MessageData&) = 0;
-
-        // called when a test case is skipped either because it doesn't pass the filters, has a skip decorator
-        // or isn't in the execution range (between first and last) (safe to cache a pointer to the input)
-        virtual void test_case_skipped(const TestCaseData&) = 0;
-
-        DOCTEST_DECLARE_INTERFACE(IReporter)
-
-        // can obtain all currently active contexts and stringify them if one wishes to do so
-        static int                         get_num_active_contexts();
-        static const IContextScope* const* get_active_contexts();
-
-        // can iterate through contexts which have been stringified automatically in their destructors when an exception has been thrown
-        static int           get_num_stringified_contexts();
-        static const String* get_stringified_contexts();
-    };
-
-    namespace detail {
-        using reporterCreatorFunc =  IReporter* (*)(const ContextOptions&);
-
-        DOCTEST_INTERFACE void registerReporterImpl(const char* name, int prio, reporterCreatorFunc c, bool isReporter);
-
-        template <typename Reporter>
-        IReporter* reporterCreator(const ContextOptions& o) {
-            return new Reporter(o);
-        }
-    } // namespace detail
-
-    template <typename Reporter>
-    int registerReporter(const char* name, int priority, bool isReporter) {
-        detail::registerReporterImpl(name, priority, detail::reporterCreator<Reporter>, isReporter);
-        return 0;
-    }
-} // namespace doctest
-
-#ifdef DOCTEST_CONFIG_ASSERTS_RETURN_VALUES
-#define DOCTEST_FUNC_EMPTY [] { return false; }()
-#else
-#define DOCTEST_FUNC_EMPTY (void)0
-#endif
-
-// if registering is not disabled
-#ifndef DOCTEST_CONFIG_DISABLE
-
-#ifdef DOCTEST_CONFIG_ASSERTS_RETURN_VALUES
-#define DOCTEST_FUNC_SCOPE_BEGIN [&]
-#define DOCTEST_FUNC_SCOPE_END ()
-#define DOCTEST_FUNC_SCOPE_RET(v) return v
-#else
-#define DOCTEST_FUNC_SCOPE_BEGIN do
-#define DOCTEST_FUNC_SCOPE_END while(false)
-#define DOCTEST_FUNC_SCOPE_RET(v) (void)0
-#endif
-
-// common code in asserts - for convenience
-#define DOCTEST_ASSERT_LOG_REACT_RETURN(b)                                                         \
-    if(b.log()) DOCTEST_BREAK_INTO_DEBUGGER();                                                     \
-    b.react();                                                                                     \
-    DOCTEST_FUNC_SCOPE_RET(!b.m_failed)
-
-#ifdef DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
-#define DOCTEST_WRAP_IN_TRY(x) x;
-#else // DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
-#define DOCTEST_WRAP_IN_TRY(x)                                                                     \
-    try {                                                                                          \
-        x;                                                                                         \
-    } catch(...) { DOCTEST_RB.translateException(); }
-#endif // DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
-
-#ifdef DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS
-#define DOCTEST_CAST_TO_VOID(...)                                                                  \
-    DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wuseless-cast")                                       \
-    static_cast<void>(__VA_ARGS__);                                                                \
-    DOCTEST_GCC_SUPPRESS_WARNING_POP
-#else // DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS
-#define DOCTEST_CAST_TO_VOID(...) __VA_ARGS__;
-#endif // DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS
-
-// registers the test by initializing a dummy var with a function
-#define DOCTEST_REGISTER_FUNCTION(global_prefix, f, decorators)                                    \
-    global_prefix DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_VAR_), /* NOLINT */    \
-            doctest::detail::regTest(                                                              \
-                    doctest::detail::TestCase(                                                     \
-                            f, __FILE__, __LINE__,                                                 \
-                            doctest_detail_test_suite_ns::getCurrentTestSuite()) *                 \
-                    decorators))
-
-#define DOCTEST_IMPLEMENT_FIXTURE(der, base, func, decorators)                                     \
-    namespace { /* NOLINT */                                                                       \
-        struct der : public base                                                                   \
-        {                                                                                          \
-            void f();                                                                              \
-        };                                                                                         \
-        static DOCTEST_INLINE_NOINLINE void func() {                                               \
-            der v;                                                                                 \
-            v.f();                                                                                 \
-        }                                                                                          \
-        DOCTEST_REGISTER_FUNCTION(DOCTEST_EMPTY, func, decorators)                                 \
-    }                                                                                              \
-    DOCTEST_INLINE_NOINLINE void der::f() // NOLINT(misc-definitions-in-headers)
-
-#define DOCTEST_CREATE_AND_REGISTER_FUNCTION(f, decorators)                                        \
-    static void f();                                                                               \
-    DOCTEST_REGISTER_FUNCTION(DOCTEST_EMPTY, f, decorators)                                        \
-    static void f()
-
-#define DOCTEST_CREATE_AND_REGISTER_FUNCTION_IN_CLASS(f, proxy, decorators)                        \
-    static doctest::detail::funcType proxy() { return f; }                                         \
-    DOCTEST_REGISTER_FUNCTION(inline, proxy(), decorators)                                         \
-    static void f()
-
-// for registering tests
-#define DOCTEST_TEST_CASE(decorators)                                                              \
-    DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), decorators)
-
-// for registering tests in classes - requires C++17 for inline variables!
-#if DOCTEST_CPLUSPLUS >= 201703L
-#define DOCTEST_TEST_CASE_CLASS(decorators)                                                        \
-    DOCTEST_CREATE_AND_REGISTER_FUNCTION_IN_CLASS(DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_),           \
-                                                  DOCTEST_ANONYMOUS(DOCTEST_ANON_PROXY_),          \
-                                                  decorators)
-#else // DOCTEST_TEST_CASE_CLASS
-#define DOCTEST_TEST_CASE_CLASS(...)                                                               \
-    TEST_CASES_CAN_BE_REGISTERED_IN_CLASSES_ONLY_IN_CPP17_MODE_OR_WITH_VS_2017_OR_NEWER
-#endif // DOCTEST_TEST_CASE_CLASS
-
-// for registering tests with a fixture
-#define DOCTEST_TEST_CASE_FIXTURE(c, decorators)                                                   \
-    DOCTEST_IMPLEMENT_FIXTURE(DOCTEST_ANONYMOUS(DOCTEST_ANON_CLASS_), c,                           \
-                              DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), decorators)
-
-// for converting types to strings without the <typeinfo> header and demangling
-#define DOCTEST_TYPE_TO_STRING_AS(str, ...)                                                        \
-    namespace doctest {                                                                            \
-        template <>                                                                                \
-        inline String toString<__VA_ARGS__>() {                                                    \
-            return str;                                                                            \
-        }                                                                                          \
-    }                                                                                              \
-    static_assert(true, "")
-
-#define DOCTEST_TYPE_TO_STRING(...) DOCTEST_TYPE_TO_STRING_AS(#__VA_ARGS__, __VA_ARGS__)
-
-#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, iter, func)                                 \
-    template <typename T>                                                                          \
-    static void func();                                                                            \
-    namespace { /* NOLINT */                                                                       \
-        template <typename Tuple>                                                                  \
-        struct iter;                                                                               \
-        template <typename Type, typename... Rest>                                                 \
-        struct iter<std::tuple<Type, Rest...>>                                                     \
-        {                                                                                          \
-            iter(const char* file, unsigned line, int index) {                                     \
-                doctest::detail::regTest(doctest::detail::TestCase(func<Type>, file, line,         \
-                                            doctest_detail_test_suite_ns::getCurrentTestSuite(),   \
-                                            doctest::toString<Type>(),                             \
-                                            int(line) * 1000 + index)                              \
-                                         * dec);                                                   \
-                iter<std::tuple<Rest...>>(file, line, index + 1);                                  \
-            }                                                                                      \
-        };                                                                                         \
-        template <>                                                                                \
-        struct iter<std::tuple<>>                                                                  \
-        {                                                                                          \
-            iter(const char*, unsigned, int) {}                                                    \
-        };                                                                                         \
-    }                                                                                              \
-    template <typename T>                                                                          \
-    static void func()
-
-#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE(dec, T, id)                                              \
-    DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, DOCTEST_CAT(id, ITERATOR),                      \
-                                           DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_))
-
-#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, anon, ...)                                 \
-    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_CAT(anon, DUMMY), /* NOLINT(cert-err58-cpp, fuchsia-statically-constructed-objects) */ \
-        doctest::detail::instantiationHelper(                                                      \
-            DOCTEST_CAT(id, ITERATOR)<__VA_ARGS__>(__FILE__, __LINE__, 0)))
-
-#define DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, ...)                                                 \
-    DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_), std::tuple<__VA_ARGS__>) \
-    static_assert(true, "")
-
-#define DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, ...)                                                  \
-    DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_), __VA_ARGS__) \
-    static_assert(true, "")
-
-#define DOCTEST_TEST_CASE_TEMPLATE_IMPL(dec, T, anon, ...)                                         \
-    DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, DOCTEST_CAT(anon, ITERATOR), anon);             \
-    DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(anon, anon, std::tuple<__VA_ARGS__>)               \
-    template <typename T>                                                                          \
-    static void anon()
-
-#define DOCTEST_TEST_CASE_TEMPLATE(dec, T, ...)                                                    \
-    DOCTEST_TEST_CASE_TEMPLATE_IMPL(dec, T, DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_), __VA_ARGS__)
-
-// for subcases
-#define DOCTEST_SUBCASE(name)                                                                      \
-    if(const doctest::detail::Subcase & DOCTEST_ANONYMOUS(DOCTEST_ANON_SUBCASE_) DOCTEST_UNUSED =  \
-               doctest::detail::Subcase(name, __FILE__, __LINE__))
-
-// for grouping tests in test suites by using code blocks
-#define DOCTEST_TEST_SUITE_IMPL(decorators, ns_name)                                               \
-    namespace ns_name { namespace doctest_detail_test_suite_ns {                                   \
-            static DOCTEST_NOINLINE doctest::detail::TestSuite& getCurrentTestSuite() noexcept {   \
-                DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4640)                                      \
-                DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wexit-time-destructors")                \
-                DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wmissing-field-initializers")             \
-                static doctest::detail::TestSuite data{};                                          \
-                static bool                       inited = false;                                  \
-                DOCTEST_MSVC_SUPPRESS_WARNING_POP                                                  \
-                DOCTEST_CLANG_SUPPRESS_WARNING_POP                                                 \
-                DOCTEST_GCC_SUPPRESS_WARNING_POP                                                   \
-                if(!inited) {                                                                      \
-                    data* decorators;                                                              \
-                    inited = true;                                                                 \
-                }                                                                                  \
-                return data;                                                                       \
-            }                                                                                      \
-        }                                                                                          \
-    }                                                                                              \
-    namespace ns_name
-
-#define DOCTEST_TEST_SUITE(decorators)                                                             \
-    DOCTEST_TEST_SUITE_IMPL(decorators, DOCTEST_ANONYMOUS(DOCTEST_ANON_SUITE_))
-
-// for starting a testsuite block
-#define DOCTEST_TEST_SUITE_BEGIN(decorators)                                                       \
-    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_VAR_), /* NOLINT(cert-err58-cpp) */  \
-            doctest::detail::setTestSuite(doctest::detail::TestSuite() * decorators))              \
-    static_assert(true, "")
-
-// for ending a testsuite block
-#define DOCTEST_TEST_SUITE_END                                                                     \
-    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_VAR_), /* NOLINT(cert-err58-cpp) */  \
-            doctest::detail::setTestSuite(doctest::detail::TestSuite() * ""))                      \
-    using DOCTEST_ANONYMOUS(DOCTEST_ANON_FOR_SEMICOLON_) = int
-
-// for registering exception translators
-#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR_IMPL(translatorName, signature)                      \
-    inline doctest::String translatorName(signature);                                              \
-    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_TRANSLATOR_), /* NOLINT(cert-err58-cpp) */ \
-            doctest::registerExceptionTranslator(translatorName))                                  \
-    doctest::String translatorName(signature)
-
-#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature)                                           \
-    DOCTEST_REGISTER_EXCEPTION_TRANSLATOR_IMPL(DOCTEST_ANONYMOUS(DOCTEST_ANON_TRANSLATOR_),        \
-                                               signature)
-
-// for registering reporters
-#define DOCTEST_REGISTER_REPORTER(name, priority, reporter)                                        \
-    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_REPORTER_), /* NOLINT(cert-err58-cpp) */ \
-            doctest::registerReporter<reporter>(name, priority, true))                             \
-    static_assert(true, "")
-
-// for registering listeners
-#define DOCTEST_REGISTER_LISTENER(name, priority, reporter)                                        \
-    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_REPORTER_), /* NOLINT(cert-err58-cpp) */ \
-            doctest::registerReporter<reporter>(name, priority, false))                            \
-    static_assert(true, "")
-
-// clang-format off
-// for logging - disabling formatting because it's important to have these on 2 separate lines - see PR #557
-#define DOCTEST_INFO(...)                                                                          \
-    DOCTEST_INFO_IMPL(DOCTEST_ANONYMOUS(DOCTEST_CAPTURE_),                                         \
-                      DOCTEST_ANONYMOUS(DOCTEST_CAPTURE_OTHER_),                                   \
-                      __VA_ARGS__)
-// clang-format on
-
-#define DOCTEST_INFO_IMPL(mb_name, s_name, ...)                                       \
-    auto DOCTEST_ANONYMOUS(DOCTEST_CAPTURE_) = doctest::detail::MakeContextScope(                  \
-        [&](std::ostream* s_name) {                                                                \
-        doctest::detail::MessageBuilder mb_name(__FILE__, __LINE__, doctest::assertType::is_warn); \
-        mb_name.m_stream = s_name;                                                                 \
-        mb_name * __VA_ARGS__;                                                                     \
-    })
-
-#define DOCTEST_CAPTURE(x) DOCTEST_INFO(#x " := ", x)
-
-#define DOCTEST_ADD_AT_IMPL(type, file, line, mb, ...)                                             \
-    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
-        doctest::detail::MessageBuilder mb(file, line, doctest::assertType::type);                 \
-        mb * __VA_ARGS__;                                                                          \
-        if(mb.log())                                                                               \
-            DOCTEST_BREAK_INTO_DEBUGGER();                                                         \
-        mb.react();                                                                                \
-    } DOCTEST_FUNC_SCOPE_END
-
-// clang-format off
-#define DOCTEST_ADD_MESSAGE_AT(file, line, ...) DOCTEST_ADD_AT_IMPL(is_warn, file, line, DOCTEST_ANONYMOUS(DOCTEST_MESSAGE_), __VA_ARGS__)
-#define DOCTEST_ADD_FAIL_CHECK_AT(file, line, ...) DOCTEST_ADD_AT_IMPL(is_check, file, line, DOCTEST_ANONYMOUS(DOCTEST_MESSAGE_), __VA_ARGS__)
-#define DOCTEST_ADD_FAIL_AT(file, line, ...) DOCTEST_ADD_AT_IMPL(is_require, file, line, DOCTEST_ANONYMOUS(DOCTEST_MESSAGE_), __VA_ARGS__)
-// clang-format on
-
-#define DOCTEST_MESSAGE(...) DOCTEST_ADD_MESSAGE_AT(__FILE__, __LINE__, __VA_ARGS__)
-#define DOCTEST_FAIL_CHECK(...) DOCTEST_ADD_FAIL_CHECK_AT(__FILE__, __LINE__, __VA_ARGS__)
-#define DOCTEST_FAIL(...) DOCTEST_ADD_FAIL_AT(__FILE__, __LINE__, __VA_ARGS__)
-
-#define DOCTEST_TO_LVALUE(...) __VA_ARGS__ // Not removed to keep backwards compatibility.
-
-#ifndef DOCTEST_CONFIG_SUPER_FAST_ASSERTS
-
-#define DOCTEST_ASSERT_IMPLEMENT_2(assert_type, ...)                                               \
-    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Woverloaded-shift-op-parentheses")                  \
-    /* NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) */                                  \
-    doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__,          \
-                                               __LINE__, #__VA_ARGS__);                            \
-    DOCTEST_WRAP_IN_TRY(DOCTEST_RB.setResult(                                                      \
-            doctest::detail::ExpressionDecomposer(doctest::assertType::assert_type)                \
-            << __VA_ARGS__)) /* NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) */         \
-    DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB)                                                    \
-    DOCTEST_CLANG_SUPPRESS_WARNING_POP
-
-#define DOCTEST_ASSERT_IMPLEMENT_1(assert_type, ...)                                               \
-    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
-        DOCTEST_ASSERT_IMPLEMENT_2(assert_type, __VA_ARGS__);                                      \
-    } DOCTEST_FUNC_SCOPE_END // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
-
-#define DOCTEST_BINARY_ASSERT(assert_type, comp, ...)                                              \
-    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
-        doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__,      \
-                                                   __LINE__, #__VA_ARGS__);                        \
-        DOCTEST_WRAP_IN_TRY(                                                                       \
-                DOCTEST_RB.binary_assert<doctest::detail::binaryAssertComparison::comp>(           \
-                        __VA_ARGS__))                                                              \
-        DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB);                                               \
-    } DOCTEST_FUNC_SCOPE_END
-
-#define DOCTEST_UNARY_ASSERT(assert_type, ...)                                                     \
-    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
-        doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__,      \
-                                                   __LINE__, #__VA_ARGS__);                        \
-        DOCTEST_WRAP_IN_TRY(DOCTEST_RB.unary_assert(__VA_ARGS__))                                  \
-        DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB);                                               \
-    } DOCTEST_FUNC_SCOPE_END
-
-#else // DOCTEST_CONFIG_SUPER_FAST_ASSERTS
-
-// necessary for <ASSERT>_MESSAGE
-#define DOCTEST_ASSERT_IMPLEMENT_2 DOCTEST_ASSERT_IMPLEMENT_1
-
-#define DOCTEST_ASSERT_IMPLEMENT_1(assert_type, ...)                                               \
-    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Woverloaded-shift-op-parentheses")                  \
-    doctest::detail::decomp_assert(                                                                \
-            doctest::assertType::assert_type, __FILE__, __LINE__, #__VA_ARGS__,                    \
-            doctest::detail::ExpressionDecomposer(doctest::assertType::assert_type)                \
-                    << __VA_ARGS__) DOCTEST_CLANG_SUPPRESS_WARNING_POP
-
-#define DOCTEST_BINARY_ASSERT(assert_type, comparison, ...)                                        \
-    doctest::detail::binary_assert<doctest::detail::binaryAssertComparison::comparison>(           \
-            doctest::assertType::assert_type, __FILE__, __LINE__, #__VA_ARGS__, __VA_ARGS__)
-
-#define DOCTEST_UNARY_ASSERT(assert_type, ...)                                                     \
-    doctest::detail::unary_assert(doctest::assertType::assert_type, __FILE__, __LINE__,            \
-                                  #__VA_ARGS__, __VA_ARGS__)
-
-#endif // DOCTEST_CONFIG_SUPER_FAST_ASSERTS
-
-#define DOCTEST_WARN(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_WARN, __VA_ARGS__)
-#define DOCTEST_CHECK(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_CHECK, __VA_ARGS__)
-#define DOCTEST_REQUIRE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_REQUIRE, __VA_ARGS__)
-#define DOCTEST_WARN_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_WARN_FALSE, __VA_ARGS__)
-#define DOCTEST_CHECK_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_CHECK_FALSE, __VA_ARGS__)
-#define DOCTEST_REQUIRE_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_REQUIRE_FALSE, __VA_ARGS__)
-
-// clang-format off
-#define DOCTEST_WARN_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_WARN, cond); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_CHECK_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_CHECK, cond); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_REQUIRE_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_REQUIRE, cond); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_WARN_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_WARN_FALSE, cond); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_CHECK_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_CHECK_FALSE, cond); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_REQUIRE_FALSE, cond); } DOCTEST_FUNC_SCOPE_END
-// clang-format on
-
-#define DOCTEST_WARN_EQ(...) DOCTEST_BINARY_ASSERT(DT_WARN_EQ, eq, __VA_ARGS__)
-#define DOCTEST_CHECK_EQ(...) DOCTEST_BINARY_ASSERT(DT_CHECK_EQ, eq, __VA_ARGS__)
-#define DOCTEST_REQUIRE_EQ(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_EQ, eq, __VA_ARGS__)
-#define DOCTEST_WARN_NE(...) DOCTEST_BINARY_ASSERT(DT_WARN_NE, ne, __VA_ARGS__)
-#define DOCTEST_CHECK_NE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_NE, ne, __VA_ARGS__)
-#define DOCTEST_REQUIRE_NE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_NE, ne, __VA_ARGS__)
-#define DOCTEST_WARN_GT(...) DOCTEST_BINARY_ASSERT(DT_WARN_GT, gt, __VA_ARGS__)
-#define DOCTEST_CHECK_GT(...) DOCTEST_BINARY_ASSERT(DT_CHECK_GT, gt, __VA_ARGS__)
-#define DOCTEST_REQUIRE_GT(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GT, gt, __VA_ARGS__)
-#define DOCTEST_WARN_LT(...) DOCTEST_BINARY_ASSERT(DT_WARN_LT, lt, __VA_ARGS__)
-#define DOCTEST_CHECK_LT(...) DOCTEST_BINARY_ASSERT(DT_CHECK_LT, lt, __VA_ARGS__)
-#define DOCTEST_REQUIRE_LT(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LT, lt, __VA_ARGS__)
-#define DOCTEST_WARN_GE(...) DOCTEST_BINARY_ASSERT(DT_WARN_GE, ge, __VA_ARGS__)
-#define DOCTEST_CHECK_GE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_GE, ge, __VA_ARGS__)
-#define DOCTEST_REQUIRE_GE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GE, ge, __VA_ARGS__)
-#define DOCTEST_WARN_LE(...) DOCTEST_BINARY_ASSERT(DT_WARN_LE, le, __VA_ARGS__)
-#define DOCTEST_CHECK_LE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_LE, le, __VA_ARGS__)
-#define DOCTEST_REQUIRE_LE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LE, le, __VA_ARGS__)
-
-#define DOCTEST_WARN_UNARY(...) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY, __VA_ARGS__)
-#define DOCTEST_CHECK_UNARY(...) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY, __VA_ARGS__)
-#define DOCTEST_REQUIRE_UNARY(...) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY, __VA_ARGS__)
-#define DOCTEST_WARN_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY_FALSE, __VA_ARGS__)
-#define DOCTEST_CHECK_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY_FALSE, __VA_ARGS__)
-#define DOCTEST_REQUIRE_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY_FALSE, __VA_ARGS__)
-
-#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
-
-#define DOCTEST_ASSERT_THROWS_AS(expr, assert_type, message, ...)                                  \
-    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
-        if(!doctest::getContextOptions()->no_throw) {                                              \
-            doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__,  \
-                                                       __LINE__, #expr, #__VA_ARGS__, message);    \
-            try {                                                                                  \
-                DOCTEST_CAST_TO_VOID(expr)                                                         \
-            } catch(const typename doctest::detail::types::remove_const<                           \
-                    typename doctest::detail::types::remove_reference<__VA_ARGS__>::type>::type&) {\
-                DOCTEST_RB.translateException();                                                   \
-                DOCTEST_RB.m_threw_as = true;                                                      \
-            } catch(...) { DOCTEST_RB.translateException(); }                                      \
-            DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB);                                           \
-        } else { /* NOLINT(*-else-after-return) */                                                 \
-            DOCTEST_FUNC_SCOPE_RET(false);                                                         \
-        }                                                                                          \
-    } DOCTEST_FUNC_SCOPE_END
-
-#define DOCTEST_ASSERT_THROWS_WITH(expr, expr_str, assert_type, ...)                               \
-    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
-        if(!doctest::getContextOptions()->no_throw) {                                              \
-            doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__,  \
-                                                       __LINE__, expr_str, "", __VA_ARGS__);       \
-            try {                                                                                  \
-                DOCTEST_CAST_TO_VOID(expr)                                                         \
-            } catch(...) { DOCTEST_RB.translateException(); }                                      \
-            DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB);                                           \
-        } else { /* NOLINT(*-else-after-return) */                                                 \
-           DOCTEST_FUNC_SCOPE_RET(false);                                                          \
-        }                                                                                          \
-    } DOCTEST_FUNC_SCOPE_END
-
-#define DOCTEST_ASSERT_NOTHROW(assert_type, ...)                                                   \
-    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
-        doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__,      \
-                                                   __LINE__, #__VA_ARGS__);                        \
-        try {                                                                                      \
-            DOCTEST_CAST_TO_VOID(__VA_ARGS__)                                                      \
-        } catch(...) { DOCTEST_RB.translateException(); }                                          \
-        DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB);                                               \
-    } DOCTEST_FUNC_SCOPE_END
-
-// clang-format off
-#define DOCTEST_WARN_THROWS(...) DOCTEST_ASSERT_THROWS_WITH((__VA_ARGS__), #__VA_ARGS__, DT_WARN_THROWS, "")
-#define DOCTEST_CHECK_THROWS(...) DOCTEST_ASSERT_THROWS_WITH((__VA_ARGS__), #__VA_ARGS__, DT_CHECK_THROWS, "")
-#define DOCTEST_REQUIRE_THROWS(...) DOCTEST_ASSERT_THROWS_WITH((__VA_ARGS__), #__VA_ARGS__, DT_REQUIRE_THROWS, "")
-
-#define DOCTEST_WARN_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_WARN_THROWS_AS, "", __VA_ARGS__)
-#define DOCTEST_CHECK_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_CHECK_THROWS_AS, "", __VA_ARGS__)
-#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_REQUIRE_THROWS_AS, "", __VA_ARGS__)
-
-#define DOCTEST_WARN_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, #expr, DT_WARN_THROWS_WITH, __VA_ARGS__)
-#define DOCTEST_CHECK_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, #expr, DT_CHECK_THROWS_WITH, __VA_ARGS__)
-#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, #expr, DT_REQUIRE_THROWS_WITH, __VA_ARGS__)
-
-#define DOCTEST_WARN_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_WARN_THROWS_WITH_AS, message, __VA_ARGS__)
-#define DOCTEST_CHECK_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_CHECK_THROWS_WITH_AS, message, __VA_ARGS__)
-#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_REQUIRE_THROWS_WITH_AS, message, __VA_ARGS__)
-
-#define DOCTEST_WARN_NOTHROW(...) DOCTEST_ASSERT_NOTHROW(DT_WARN_NOTHROW, __VA_ARGS__)
-#define DOCTEST_CHECK_NOTHROW(...) DOCTEST_ASSERT_NOTHROW(DT_CHECK_NOTHROW, __VA_ARGS__)
-#define DOCTEST_REQUIRE_NOTHROW(...) DOCTEST_ASSERT_NOTHROW(DT_REQUIRE_NOTHROW, __VA_ARGS__)
-
-#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS(expr); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS(expr); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS(expr); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS_AS(expr, ex); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS_AS(expr, ex); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS_AS(expr, ex); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS_WITH(expr, with); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS_WITH(expr, with); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS_WITH(expr, with); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS_WITH_AS(expr, with, ex); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ex); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ex); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_NOTHROW(expr); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_NOTHROW(expr); } DOCTEST_FUNC_SCOPE_END
-#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_NOTHROW(expr); } DOCTEST_FUNC_SCOPE_END
-// clang-format on
-
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
-
-// =================================================================================================
-// == WHAT FOLLOWS IS VERSIONS OF THE MACROS THAT DO NOT DO ANY REGISTERING!                      ==
-// == THIS CAN BE ENABLED BY DEFINING DOCTEST_CONFIG_DISABLE GLOBALLY!                            ==
-// =================================================================================================
-#else // DOCTEST_CONFIG_DISABLE
-
-#define DOCTEST_IMPLEMENT_FIXTURE(der, base, func, name)                                           \
-    namespace /* NOLINT */ {                                                                       \
-        template <typename DOCTEST_UNUSED_TEMPLATE_TYPE>                                           \
-        struct der : public base                                                                   \
-        { void f(); };                                                                             \
-    }                                                                                              \
-    template <typename DOCTEST_UNUSED_TEMPLATE_TYPE>                                               \
-    inline void der<DOCTEST_UNUSED_TEMPLATE_TYPE>::f()
-
-#define DOCTEST_CREATE_AND_REGISTER_FUNCTION(f, name)                                              \
-    template <typename DOCTEST_UNUSED_TEMPLATE_TYPE>                                               \
-    static inline void f()
-
-// for registering tests
-#define DOCTEST_TEST_CASE(name)                                                                    \
-    DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), name)
-
-// for registering tests in classes
-#define DOCTEST_TEST_CASE_CLASS(name)                                                              \
-    DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), name)
-
-// for registering tests with a fixture
-#define DOCTEST_TEST_CASE_FIXTURE(x, name)                                                         \
-    DOCTEST_IMPLEMENT_FIXTURE(DOCTEST_ANONYMOUS(DOCTEST_ANON_CLASS_), x,                           \
-                              DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), name)
-
-// for converting types to strings without the <typeinfo> header and demangling
-#define DOCTEST_TYPE_TO_STRING_AS(str, ...) static_assert(true, "")
-#define DOCTEST_TYPE_TO_STRING(...) static_assert(true, "")
-
-// for typed tests
-#define DOCTEST_TEST_CASE_TEMPLATE(name, type, ...)                                                \
-    template <typename type>                                                                       \
-    inline void DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_)()
-
-#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE(name, type, id)                                          \
-    template <typename type>                                                                       \
-    inline void DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_)()
-
-#define DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, ...) static_assert(true, "")
-#define DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, ...) static_assert(true, "")
-
-// for subcases
-#define DOCTEST_SUBCASE(name)
-
-// for a testsuite block
-#define DOCTEST_TEST_SUITE(name) namespace // NOLINT
-
-// for starting a testsuite block
-#define DOCTEST_TEST_SUITE_BEGIN(name) static_assert(true, "")
-
-// for ending a testsuite block
-#define DOCTEST_TEST_SUITE_END using DOCTEST_ANONYMOUS(DOCTEST_ANON_FOR_SEMICOLON_) = int
-
-#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature)                                           \
-    template <typename DOCTEST_UNUSED_TEMPLATE_TYPE>                                               \
-    static inline doctest::String DOCTEST_ANONYMOUS(DOCTEST_ANON_TRANSLATOR_)(signature)
-
-#define DOCTEST_REGISTER_REPORTER(name, priority, reporter)
-#define DOCTEST_REGISTER_LISTENER(name, priority, reporter)
-
-#define DOCTEST_INFO(...) (static_cast<void>(0))
-#define DOCTEST_CAPTURE(x) (static_cast<void>(0))
-#define DOCTEST_ADD_MESSAGE_AT(file, line, ...) (static_cast<void>(0))
-#define DOCTEST_ADD_FAIL_CHECK_AT(file, line, ...) (static_cast<void>(0))
-#define DOCTEST_ADD_FAIL_AT(file, line, ...) (static_cast<void>(0))
-#define DOCTEST_MESSAGE(...) (static_cast<void>(0))
-#define DOCTEST_FAIL_CHECK(...) (static_cast<void>(0))
-#define DOCTEST_FAIL(...) (static_cast<void>(0))
-
-#if defined(DOCTEST_CONFIG_EVALUATE_ASSERTS_EVEN_WHEN_DISABLED)                                    \
- && defined(DOCTEST_CONFIG_ASSERTS_RETURN_VALUES)
-
-#define DOCTEST_WARN(...) [&] { return __VA_ARGS__; }()
-#define DOCTEST_CHECK(...) [&] { return __VA_ARGS__; }()
-#define DOCTEST_REQUIRE(...) [&] { return __VA_ARGS__; }()
-#define DOCTEST_WARN_FALSE(...) [&] { return !(__VA_ARGS__); }()
-#define DOCTEST_CHECK_FALSE(...) [&] { return !(__VA_ARGS__); }()
-#define DOCTEST_REQUIRE_FALSE(...) [&] { return !(__VA_ARGS__); }()
-
-#define DOCTEST_WARN_MESSAGE(cond, ...) [&] { return cond; }()
-#define DOCTEST_CHECK_MESSAGE(cond, ...) [&] { return cond; }()
-#define DOCTEST_REQUIRE_MESSAGE(cond, ...) [&] { return cond; }()
-#define DOCTEST_WARN_FALSE_MESSAGE(cond, ...) [&] { return !(cond); }()
-#define DOCTEST_CHECK_FALSE_MESSAGE(cond, ...) [&] { return !(cond); }()
-#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, ...) [&] { return !(cond); }()
-
-namespace doctest {
-namespace detail {
-#define DOCTEST_RELATIONAL_OP(name, op)                                                            \
-    template <typename L, typename R>                                                              \
-    bool name(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) { return lhs op rhs; }
-
-    DOCTEST_RELATIONAL_OP(eq, ==)
-    DOCTEST_RELATIONAL_OP(ne, !=)
-    DOCTEST_RELATIONAL_OP(lt, <)
-    DOCTEST_RELATIONAL_OP(gt, >)
-    DOCTEST_RELATIONAL_OP(le, <=)
-    DOCTEST_RELATIONAL_OP(ge, >=)
-} // namespace detail
-} // namespace doctest
-
-#define DOCTEST_WARN_EQ(...) [&] { return doctest::detail::eq(__VA_ARGS__); }()
-#define DOCTEST_CHECK_EQ(...) [&] { return doctest::detail::eq(__VA_ARGS__); }()
-#define DOCTEST_REQUIRE_EQ(...) [&] { return doctest::detail::eq(__VA_ARGS__); }()
-#define DOCTEST_WARN_NE(...) [&] { return doctest::detail::ne(__VA_ARGS__); }()
-#define DOCTEST_CHECK_NE(...) [&] { return doctest::detail::ne(__VA_ARGS__); }()
-#define DOCTEST_REQUIRE_NE(...) [&] { return doctest::detail::ne(__VA_ARGS__); }()
-#define DOCTEST_WARN_LT(...) [&] { return doctest::detail::lt(__VA_ARGS__); }()
-#define DOCTEST_CHECK_LT(...) [&] { return doctest::detail::lt(__VA_ARGS__); }()
-#define DOCTEST_REQUIRE_LT(...) [&] { return doctest::detail::lt(__VA_ARGS__); }()
-#define DOCTEST_WARN_GT(...) [&] { return doctest::detail::gt(__VA_ARGS__); }()
-#define DOCTEST_CHECK_GT(...) [&] { return doctest::detail::gt(__VA_ARGS__); }()
-#define DOCTEST_REQUIRE_GT(...) [&] { return doctest::detail::gt(__VA_ARGS__); }()
-#define DOCTEST_WARN_LE(...) [&] { return doctest::detail::le(__VA_ARGS__); }()
-#define DOCTEST_CHECK_LE(...) [&] { return doctest::detail::le(__VA_ARGS__); }()
-#define DOCTEST_REQUIRE_LE(...) [&] { return doctest::detail::le(__VA_ARGS__); }()
-#define DOCTEST_WARN_GE(...) [&] { return doctest::detail::ge(__VA_ARGS__); }()
-#define DOCTEST_CHECK_GE(...) [&] { return doctest::detail::ge(__VA_ARGS__); }()
-#define DOCTEST_REQUIRE_GE(...) [&] { return doctest::detail::ge(__VA_ARGS__); }()
-#define DOCTEST_WARN_UNARY(...) [&] { return __VA_ARGS__; }()
-#define DOCTEST_CHECK_UNARY(...) [&] { return __VA_ARGS__; }()
-#define DOCTEST_REQUIRE_UNARY(...) [&] { return __VA_ARGS__; }()
-#define DOCTEST_WARN_UNARY_FALSE(...) [&] { return !(__VA_ARGS__); }()
-#define DOCTEST_CHECK_UNARY_FALSE(...) [&] { return !(__VA_ARGS__); }()
-#define DOCTEST_REQUIRE_UNARY_FALSE(...) [&] { return !(__VA_ARGS__); }()
-
-#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
-
-#define DOCTEST_WARN_THROWS_WITH(expr, with, ...) [] { static_assert(false, "Exception translation is not available when doctest is disabled."); return false; }()
-#define DOCTEST_CHECK_THROWS_WITH(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
-#define DOCTEST_REQUIRE_THROWS_WITH(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
-#define DOCTEST_WARN_THROWS_WITH_AS(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
-#define DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
-#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
-
-#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
-#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
-#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
-#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
-#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
-#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
-
-#define DOCTEST_WARN_THROWS(...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
-#define DOCTEST_CHECK_THROWS(...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
-#define DOCTEST_REQUIRE_THROWS(...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
-#define DOCTEST_WARN_THROWS_AS(expr, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
-#define DOCTEST_CHECK_THROWS_AS(expr, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
-#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
-#define DOCTEST_WARN_NOTHROW(...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
-#define DOCTEST_CHECK_NOTHROW(...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
-#define DOCTEST_REQUIRE_NOTHROW(...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
-
-#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
-#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
-#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
-#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
-#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
-#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
-#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
-#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
-#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
-
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
-
-#else // DOCTEST_CONFIG_EVALUATE_ASSERTS_EVEN_WHEN_DISABLED
-
-#define DOCTEST_WARN(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_FALSE(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_FALSE(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_FALSE(...) DOCTEST_FUNC_EMPTY
-
-#define DOCTEST_WARN_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
-
-#define DOCTEST_WARN_EQ(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_EQ(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_EQ(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_NE(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_NE(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_NE(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_GT(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_GT(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_GT(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_LT(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_LT(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_LT(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_GE(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_GE(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_GE(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_LE(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_LE(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_LE(...) DOCTEST_FUNC_EMPTY
-
-#define DOCTEST_WARN_UNARY(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_UNARY(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_UNARY(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_UNARY_FALSE(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_UNARY_FALSE(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_UNARY_FALSE(...) DOCTEST_FUNC_EMPTY
-
-#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
-
-#define DOCTEST_WARN_THROWS(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_THROWS(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_THROWS(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_THROWS_AS(expr, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_THROWS_AS(expr, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_THROWS_WITH(expr, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_THROWS_WITH(expr, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_THROWS_WITH_AS(expr, with, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_NOTHROW(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_NOTHROW(...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_NOTHROW(...) DOCTEST_FUNC_EMPTY
-
-#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
-#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
-
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
-
-#endif // DOCTEST_CONFIG_EVALUATE_ASSERTS_EVEN_WHEN_DISABLED
-
-#endif // DOCTEST_CONFIG_DISABLE
-
-#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS
-
-#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
-#define DOCTEST_EXCEPTION_EMPTY_FUNC DOCTEST_FUNC_EMPTY
-#else // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
-#define DOCTEST_EXCEPTION_EMPTY_FUNC [] { static_assert(false, "Exceptions are disabled! " \
-    "Use DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS if you want to compile with exceptions disabled."); return false; }()
-
-#undef DOCTEST_REQUIRE
-#undef DOCTEST_REQUIRE_FALSE
-#undef DOCTEST_REQUIRE_MESSAGE
-#undef DOCTEST_REQUIRE_FALSE_MESSAGE
-#undef DOCTEST_REQUIRE_EQ
-#undef DOCTEST_REQUIRE_NE
-#undef DOCTEST_REQUIRE_GT
-#undef DOCTEST_REQUIRE_LT
-#undef DOCTEST_REQUIRE_GE
-#undef DOCTEST_REQUIRE_LE
-#undef DOCTEST_REQUIRE_UNARY
-#undef DOCTEST_REQUIRE_UNARY_FALSE
-
-#define DOCTEST_REQUIRE DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_FALSE DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_MESSAGE DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_FALSE_MESSAGE DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_EQ DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_NE DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_GT DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_LT DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_GE DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_LE DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_UNARY DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_UNARY_FALSE DOCTEST_EXCEPTION_EMPTY_FUNC
-
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
-
-#define DOCTEST_WARN_THROWS(...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_CHECK_THROWS(...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_THROWS(...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_WARN_THROWS_AS(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_CHECK_THROWS_AS(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_WARN_THROWS_WITH(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_CHECK_THROWS_WITH(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_WARN_THROWS_WITH_AS(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_WARN_NOTHROW(...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_CHECK_NOTHROW(...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_NOTHROW(...) DOCTEST_EXCEPTION_EMPTY_FUNC
-
-#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
-
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
-
-// clang-format off
-// KEPT FOR BACKWARDS COMPATIBILITY - FORWARDING TO THE RIGHT MACROS
-#define DOCTEST_FAST_WARN_EQ             DOCTEST_WARN_EQ
-#define DOCTEST_FAST_CHECK_EQ            DOCTEST_CHECK_EQ
-#define DOCTEST_FAST_REQUIRE_EQ          DOCTEST_REQUIRE_EQ
-#define DOCTEST_FAST_WARN_NE             DOCTEST_WARN_NE
-#define DOCTEST_FAST_CHECK_NE            DOCTEST_CHECK_NE
-#define DOCTEST_FAST_REQUIRE_NE          DOCTEST_REQUIRE_NE
-#define DOCTEST_FAST_WARN_GT             DOCTEST_WARN_GT
-#define DOCTEST_FAST_CHECK_GT            DOCTEST_CHECK_GT
-#define DOCTEST_FAST_REQUIRE_GT          DOCTEST_REQUIRE_GT
-#define DOCTEST_FAST_WARN_LT             DOCTEST_WARN_LT
-#define DOCTEST_FAST_CHECK_LT            DOCTEST_CHECK_LT
-#define DOCTEST_FAST_REQUIRE_LT          DOCTEST_REQUIRE_LT
-#define DOCTEST_FAST_WARN_GE             DOCTEST_WARN_GE
-#define DOCTEST_FAST_CHECK_GE            DOCTEST_CHECK_GE
-#define DOCTEST_FAST_REQUIRE_GE          DOCTEST_REQUIRE_GE
-#define DOCTEST_FAST_WARN_LE             DOCTEST_WARN_LE
-#define DOCTEST_FAST_CHECK_LE            DOCTEST_CHECK_LE
-#define DOCTEST_FAST_REQUIRE_LE          DOCTEST_REQUIRE_LE
-
-#define DOCTEST_FAST_WARN_UNARY          DOCTEST_WARN_UNARY
-#define DOCTEST_FAST_CHECK_UNARY         DOCTEST_CHECK_UNARY
-#define DOCTEST_FAST_REQUIRE_UNARY       DOCTEST_REQUIRE_UNARY
-#define DOCTEST_FAST_WARN_UNARY_FALSE    DOCTEST_WARN_UNARY_FALSE
-#define DOCTEST_FAST_CHECK_UNARY_FALSE   DOCTEST_CHECK_UNARY_FALSE
-#define DOCTEST_FAST_REQUIRE_UNARY_FALSE DOCTEST_REQUIRE_UNARY_FALSE
-
-#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE(id, ...) DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id,__VA_ARGS__)
-// clang-format on
-
-// BDD style macros
-// clang-format off
-#define DOCTEST_SCENARIO(name) DOCTEST_TEST_CASE("  Scenario: " name)
-#define DOCTEST_SCENARIO_CLASS(name) DOCTEST_TEST_CASE_CLASS("  Scenario: " name)
-#define DOCTEST_SCENARIO_TEMPLATE(name, T, ...)  DOCTEST_TEST_CASE_TEMPLATE("  Scenario: " name, T, __VA_ARGS__)
-#define DOCTEST_SCENARIO_TEMPLATE_DEFINE(name, T, id) DOCTEST_TEST_CASE_TEMPLATE_DEFINE("  Scenario: " name, T, id)
-
-#define DOCTEST_GIVEN(name)     DOCTEST_SUBCASE("   Given: " name)
-#define DOCTEST_WHEN(name)      DOCTEST_SUBCASE("    When: " name)
-#define DOCTEST_AND_WHEN(name)  DOCTEST_SUBCASE("And when: " name)
-#define DOCTEST_THEN(name)      DOCTEST_SUBCASE("    Then: " name)
-#define DOCTEST_AND_THEN(name)  DOCTEST_SUBCASE("     And: " name)
-// clang-format on
-
-// == SHORT VERSIONS OF THE MACROS
-#ifndef DOCTEST_CONFIG_NO_SHORT_MACRO_NAMES
-
-#define TEST_CASE(name) DOCTEST_TEST_CASE(name)
-#define TEST_CASE_CLASS(name) DOCTEST_TEST_CASE_CLASS(name)
-#define TEST_CASE_FIXTURE(x, name) DOCTEST_TEST_CASE_FIXTURE(x, name)
-#define TYPE_TO_STRING_AS(str, ...) DOCTEST_TYPE_TO_STRING_AS(str, __VA_ARGS__)
-#define TYPE_TO_STRING(...) DOCTEST_TYPE_TO_STRING(__VA_ARGS__)
-#define TEST_CASE_TEMPLATE(name, T, ...) DOCTEST_TEST_CASE_TEMPLATE(name, T, __VA_ARGS__)
-#define TEST_CASE_TEMPLATE_DEFINE(name, T, id) DOCTEST_TEST_CASE_TEMPLATE_DEFINE(name, T, id)
-#define TEST_CASE_TEMPLATE_INVOKE(id, ...) DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, __VA_ARGS__)
-#define TEST_CASE_TEMPLATE_APPLY(id, ...) DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, __VA_ARGS__)
-#define SUBCASE(name) DOCTEST_SUBCASE(name)
-#define TEST_SUITE(decorators) DOCTEST_TEST_SUITE(decorators)
-#define TEST_SUITE_BEGIN(name) DOCTEST_TEST_SUITE_BEGIN(name)
-#define TEST_SUITE_END DOCTEST_TEST_SUITE_END
-#define REGISTER_EXCEPTION_TRANSLATOR(signature) DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature)
-#define REGISTER_REPORTER(name, priority, reporter) DOCTEST_REGISTER_REPORTER(name, priority, reporter)
-#define REGISTER_LISTENER(name, priority, reporter) DOCTEST_REGISTER_LISTENER(name, priority, reporter)
-#define INFO(...) DOCTEST_INFO(__VA_ARGS__)
-#define CAPTURE(x) DOCTEST_CAPTURE(x)
-#define ADD_MESSAGE_AT(file, line, ...) DOCTEST_ADD_MESSAGE_AT(file, line, __VA_ARGS__)
-#define ADD_FAIL_CHECK_AT(file, line, ...) DOCTEST_ADD_FAIL_CHECK_AT(file, line, __VA_ARGS__)
-#define ADD_FAIL_AT(file, line, ...) DOCTEST_ADD_FAIL_AT(file, line, __VA_ARGS__)
-#define MESSAGE(...) DOCTEST_MESSAGE(__VA_ARGS__)
-#define FAIL_CHECK(...) DOCTEST_FAIL_CHECK(__VA_ARGS__)
-#define FAIL(...) DOCTEST_FAIL(__VA_ARGS__)
-#define TO_LVALUE(...) DOCTEST_TO_LVALUE(__VA_ARGS__)
-
-#define WARN(...) DOCTEST_WARN(__VA_ARGS__)
-#define WARN_FALSE(...) DOCTEST_WARN_FALSE(__VA_ARGS__)
-#define WARN_THROWS(...) DOCTEST_WARN_THROWS(__VA_ARGS__)
-#define WARN_THROWS_AS(expr, ...) DOCTEST_WARN_THROWS_AS(expr, __VA_ARGS__)
-#define WARN_THROWS_WITH(expr, ...) DOCTEST_WARN_THROWS_WITH(expr, __VA_ARGS__)
-#define WARN_THROWS_WITH_AS(expr, with, ...) DOCTEST_WARN_THROWS_WITH_AS(expr, with, __VA_ARGS__)
-#define WARN_NOTHROW(...) DOCTEST_WARN_NOTHROW(__VA_ARGS__)
-#define CHECK(...) DOCTEST_CHECK(__VA_ARGS__)
-#define CHECK_FALSE(...) DOCTEST_CHECK_FALSE(__VA_ARGS__)
-#define CHECK_THROWS(...) DOCTEST_CHECK_THROWS(__VA_ARGS__)
-#define CHECK_THROWS_AS(expr, ...) DOCTEST_CHECK_THROWS_AS(expr, __VA_ARGS__)
-#define CHECK_THROWS_WITH(expr, ...) DOCTEST_CHECK_THROWS_WITH(expr, __VA_ARGS__)
-#define CHECK_THROWS_WITH_AS(expr, with, ...) DOCTEST_CHECK_THROWS_WITH_AS(expr, with, __VA_ARGS__)
-#define CHECK_NOTHROW(...) DOCTEST_CHECK_NOTHROW(__VA_ARGS__)
-#define REQUIRE(...) DOCTEST_REQUIRE(__VA_ARGS__)
-#define REQUIRE_FALSE(...) DOCTEST_REQUIRE_FALSE(__VA_ARGS__)
-#define REQUIRE_THROWS(...) DOCTEST_REQUIRE_THROWS(__VA_ARGS__)
-#define REQUIRE_THROWS_AS(expr, ...) DOCTEST_REQUIRE_THROWS_AS(expr, __VA_ARGS__)
-#define REQUIRE_THROWS_WITH(expr, ...) DOCTEST_REQUIRE_THROWS_WITH(expr, __VA_ARGS__)
-#define REQUIRE_THROWS_WITH_AS(expr, with, ...) DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, __VA_ARGS__)
-#define REQUIRE_NOTHROW(...) DOCTEST_REQUIRE_NOTHROW(__VA_ARGS__)
-
-#define WARN_MESSAGE(cond, ...) DOCTEST_WARN_MESSAGE(cond, __VA_ARGS__)
-#define WARN_FALSE_MESSAGE(cond, ...) DOCTEST_WARN_FALSE_MESSAGE(cond, __VA_ARGS__)
-#define WARN_THROWS_MESSAGE(expr, ...) DOCTEST_WARN_THROWS_MESSAGE(expr, __VA_ARGS__)
-#define WARN_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, __VA_ARGS__)
-#define WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, __VA_ARGS__)
-#define WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, __VA_ARGS__)
-#define WARN_NOTHROW_MESSAGE(expr, ...) DOCTEST_WARN_NOTHROW_MESSAGE(expr, __VA_ARGS__)
-#define CHECK_MESSAGE(cond, ...) DOCTEST_CHECK_MESSAGE(cond, __VA_ARGS__)
-#define CHECK_FALSE_MESSAGE(cond, ...) DOCTEST_CHECK_FALSE_MESSAGE(cond, __VA_ARGS__)
-#define CHECK_THROWS_MESSAGE(expr, ...) DOCTEST_CHECK_THROWS_MESSAGE(expr, __VA_ARGS__)
-#define CHECK_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, __VA_ARGS__)
-#define CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, __VA_ARGS__)
-#define CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, __VA_ARGS__)
-#define CHECK_NOTHROW_MESSAGE(expr, ...) DOCTEST_CHECK_NOTHROW_MESSAGE(expr, __VA_ARGS__)
-#define REQUIRE_MESSAGE(cond, ...) DOCTEST_REQUIRE_MESSAGE(cond, __VA_ARGS__)
-#define REQUIRE_FALSE_MESSAGE(cond, ...) DOCTEST_REQUIRE_FALSE_MESSAGE(cond, __VA_ARGS__)
-#define REQUIRE_THROWS_MESSAGE(expr, ...) DOCTEST_REQUIRE_THROWS_MESSAGE(expr, __VA_ARGS__)
-#define REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, __VA_ARGS__)
-#define REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, __VA_ARGS__)
-#define REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, __VA_ARGS__)
-#define REQUIRE_NOTHROW_MESSAGE(expr, ...) DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, __VA_ARGS__)
-
-#define SCENARIO(name) DOCTEST_SCENARIO(name)
-#define SCENARIO_CLASS(name) DOCTEST_SCENARIO_CLASS(name)
-#define SCENARIO_TEMPLATE(name, T, ...) DOCTEST_SCENARIO_TEMPLATE(name, T, __VA_ARGS__)
-#define SCENARIO_TEMPLATE_DEFINE(name, T, id) DOCTEST_SCENARIO_TEMPLATE_DEFINE(name, T, id)
-#define GIVEN(name) DOCTEST_GIVEN(name)
-#define WHEN(name) DOCTEST_WHEN(name)
-#define AND_WHEN(name) DOCTEST_AND_WHEN(name)
-#define THEN(name) DOCTEST_THEN(name)
-#define AND_THEN(name) DOCTEST_AND_THEN(name)
-
-#define WARN_EQ(...) DOCTEST_WARN_EQ(__VA_ARGS__)
-#define CHECK_EQ(...) DOCTEST_CHECK_EQ(__VA_ARGS__)
-#define REQUIRE_EQ(...) DOCTEST_REQUIRE_EQ(__VA_ARGS__)
-#define WARN_NE(...) DOCTEST_WARN_NE(__VA_ARGS__)
-#define CHECK_NE(...) DOCTEST_CHECK_NE(__VA_ARGS__)
-#define REQUIRE_NE(...) DOCTEST_REQUIRE_NE(__VA_ARGS__)
-#define WARN_GT(...) DOCTEST_WARN_GT(__VA_ARGS__)
-#define CHECK_GT(...) DOCTEST_CHECK_GT(__VA_ARGS__)
-#define REQUIRE_GT(...) DOCTEST_REQUIRE_GT(__VA_ARGS__)
-#define WARN_LT(...) DOCTEST_WARN_LT(__VA_ARGS__)
-#define CHECK_LT(...) DOCTEST_CHECK_LT(__VA_ARGS__)
-#define REQUIRE_LT(...) DOCTEST_REQUIRE_LT(__VA_ARGS__)
-#define WARN_GE(...) DOCTEST_WARN_GE(__VA_ARGS__)
-#define CHECK_GE(...) DOCTEST_CHECK_GE(__VA_ARGS__)
-#define REQUIRE_GE(...) DOCTEST_REQUIRE_GE(__VA_ARGS__)
-#define WARN_LE(...) DOCTEST_WARN_LE(__VA_ARGS__)
-#define CHECK_LE(...) DOCTEST_CHECK_LE(__VA_ARGS__)
-#define REQUIRE_LE(...) DOCTEST_REQUIRE_LE(__VA_ARGS__)
-#define WARN_UNARY(...) DOCTEST_WARN_UNARY(__VA_ARGS__)
-#define CHECK_UNARY(...) DOCTEST_CHECK_UNARY(__VA_ARGS__)
-#define REQUIRE_UNARY(...) DOCTEST_REQUIRE_UNARY(__VA_ARGS__)
-#define WARN_UNARY_FALSE(...) DOCTEST_WARN_UNARY_FALSE(__VA_ARGS__)
-#define CHECK_UNARY_FALSE(...) DOCTEST_CHECK_UNARY_FALSE(__VA_ARGS__)
-#define REQUIRE_UNARY_FALSE(...) DOCTEST_REQUIRE_UNARY_FALSE(__VA_ARGS__)
-
-// KEPT FOR BACKWARDS COMPATIBILITY
-#define FAST_WARN_EQ(...) DOCTEST_FAST_WARN_EQ(__VA_ARGS__)
-#define FAST_CHECK_EQ(...) DOCTEST_FAST_CHECK_EQ(__VA_ARGS__)
-#define FAST_REQUIRE_EQ(...) DOCTEST_FAST_REQUIRE_EQ(__VA_ARGS__)
-#define FAST_WARN_NE(...) DOCTEST_FAST_WARN_NE(__VA_ARGS__)
-#define FAST_CHECK_NE(...) DOCTEST_FAST_CHECK_NE(__VA_ARGS__)
-#define FAST_REQUIRE_NE(...) DOCTEST_FAST_REQUIRE_NE(__VA_ARGS__)
-#define FAST_WARN_GT(...) DOCTEST_FAST_WARN_GT(__VA_ARGS__)
-#define FAST_CHECK_GT(...) DOCTEST_FAST_CHECK_GT(__VA_ARGS__)
-#define FAST_REQUIRE_GT(...) DOCTEST_FAST_REQUIRE_GT(__VA_ARGS__)
-#define FAST_WARN_LT(...) DOCTEST_FAST_WARN_LT(__VA_ARGS__)
-#define FAST_CHECK_LT(...) DOCTEST_FAST_CHECK_LT(__VA_ARGS__)
-#define FAST_REQUIRE_LT(...) DOCTEST_FAST_REQUIRE_LT(__VA_ARGS__)
-#define FAST_WARN_GE(...) DOCTEST_FAST_WARN_GE(__VA_ARGS__)
-#define FAST_CHECK_GE(...) DOCTEST_FAST_CHECK_GE(__VA_ARGS__)
-#define FAST_REQUIRE_GE(...) DOCTEST_FAST_REQUIRE_GE(__VA_ARGS__)
-#define FAST_WARN_LE(...) DOCTEST_FAST_WARN_LE(__VA_ARGS__)
-#define FAST_CHECK_LE(...) DOCTEST_FAST_CHECK_LE(__VA_ARGS__)
-#define FAST_REQUIRE_LE(...) DOCTEST_FAST_REQUIRE_LE(__VA_ARGS__)
-
-#define FAST_WARN_UNARY(...) DOCTEST_FAST_WARN_UNARY(__VA_ARGS__)
-#define FAST_CHECK_UNARY(...) DOCTEST_FAST_CHECK_UNARY(__VA_ARGS__)
-#define FAST_REQUIRE_UNARY(...) DOCTEST_FAST_REQUIRE_UNARY(__VA_ARGS__)
-#define FAST_WARN_UNARY_FALSE(...) DOCTEST_FAST_WARN_UNARY_FALSE(__VA_ARGS__)
-#define FAST_CHECK_UNARY_FALSE(...) DOCTEST_FAST_CHECK_UNARY_FALSE(__VA_ARGS__)
-#define FAST_REQUIRE_UNARY_FALSE(...) DOCTEST_FAST_REQUIRE_UNARY_FALSE(__VA_ARGS__)
-
-#define TEST_CASE_TEMPLATE_INSTANTIATE(id, ...) DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE(id, __VA_ARGS__)
-
-#endif // DOCTEST_CONFIG_NO_SHORT_MACRO_NAMES
-
-#ifndef DOCTEST_CONFIG_DISABLE
-
-// this is here to clear the 'current test suite' for the current translation unit - at the top
-DOCTEST_TEST_SUITE_END();
-
-#endif // DOCTEST_CONFIG_DISABLE
-
-DOCTEST_CLANG_SUPPRESS_WARNING_POP
-DOCTEST_MSVC_SUPPRESS_WARNING_POP
-DOCTEST_GCC_SUPPRESS_WARNING_POP
-
-DOCTEST_SUPPRESS_COMMON_WARNINGS_POP
-
-#endif // DOCTEST_LIBRARY_INCLUDED
-
-#ifndef DOCTEST_SINGLE_HEADER
-#define DOCTEST_SINGLE_HEADER
-#endif // DOCTEST_SINGLE_HEADER
-
-#if defined(DOCTEST_CONFIG_IMPLEMENT) || !defined(DOCTEST_SINGLE_HEADER)
-
-#ifndef DOCTEST_SINGLE_HEADER
-#include "doctest_fwd.h"
-#endif // DOCTEST_SINGLE_HEADER
-
-DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wunused-macros")
-
-#ifndef DOCTEST_LIBRARY_IMPLEMENTATION
-#define DOCTEST_LIBRARY_IMPLEMENTATION
-
-DOCTEST_CLANG_SUPPRESS_WARNING_POP
-
-DOCTEST_SUPPRESS_COMMON_WARNINGS_PUSH
-
-DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wglobal-constructors")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-conversion")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wshorten-64-to-32")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-variable-declarations")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wswitch")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wswitch-enum")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wcovered-switch-default")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-noreturn")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wdisabled-macro-expansion")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-braces")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-field-initializers")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wunused-member-function")
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wnonportable-system-include-path")
-
-DOCTEST_GCC_SUPPRESS_WARNING_PUSH
-DOCTEST_GCC_SUPPRESS_WARNING("-Wconversion")
-DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-conversion")
-DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-field-initializers")
-DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-braces")
-DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch")
-DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch-enum")
-DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch-default")
-DOCTEST_GCC_SUPPRESS_WARNING("-Wunsafe-loop-optimizations")
-DOCTEST_GCC_SUPPRESS_WARNING("-Wold-style-cast")
-DOCTEST_GCC_SUPPRESS_WARNING("-Wunused-function")
-DOCTEST_GCC_SUPPRESS_WARNING("-Wmultiple-inheritance")
-DOCTEST_GCC_SUPPRESS_WARNING("-Wsuggest-attribute")
-
-DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
-DOCTEST_MSVC_SUPPRESS_WARNING(4267) // 'var' : conversion from 'x' to 'y', possible loss of data
-DOCTEST_MSVC_SUPPRESS_WARNING(4530) // C++ exception handler used, but unwind semantics not enabled
-DOCTEST_MSVC_SUPPRESS_WARNING(4577) // 'noexcept' used with no exception handling mode specified
-DOCTEST_MSVC_SUPPRESS_WARNING(4774) // format string expected in argument is not a string literal
-DOCTEST_MSVC_SUPPRESS_WARNING(4365) // conversion from 'int' to 'unsigned', signed/unsigned mismatch
-DOCTEST_MSVC_SUPPRESS_WARNING(5039) // pointer to potentially throwing function passed to extern C
-DOCTEST_MSVC_SUPPRESS_WARNING(4800) // forcing value to bool 'true' or 'false' (performance warning)
-DOCTEST_MSVC_SUPPRESS_WARNING(5245) // unreferenced function with internal linkage has been removed
-
-DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_BEGIN
-
-// required includes - will go only in one translation unit!
-#include <ctime>
-#include <cmath>
-#include <climits>
-// borland (Embarcadero) compiler requires math.h and not cmath - https://github.com/doctest/doctest/pull/37
-#ifdef __BORLANDC__
-#include <math.h>
-#endif // __BORLANDC__
-#include <new>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <limits>
-#include <utility>
-#include <fstream>
-#include <sstream>
-#ifndef DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
-#include <iostream>
-#endif // DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
-#include <algorithm>
-#include <iomanip>
-#include <vector>
-#ifndef DOCTEST_CONFIG_NO_MULTITHREADING
-#include <atomic>
-#include <mutex>
-#define DOCTEST_DECLARE_MUTEX(name) std::mutex name;
-#define DOCTEST_DECLARE_STATIC_MUTEX(name) static DOCTEST_DECLARE_MUTEX(name)
-#define DOCTEST_LOCK_MUTEX(name) std::lock_guard<std::mutex> DOCTEST_ANONYMOUS(DOCTEST_ANON_LOCK_)(name);
-#else // DOCTEST_CONFIG_NO_MULTITHREADING
-#define DOCTEST_DECLARE_MUTEX(name)
-#define DOCTEST_DECLARE_STATIC_MUTEX(name)
-#define DOCTEST_LOCK_MUTEX(name)
-#endif // DOCTEST_CONFIG_NO_MULTITHREADING
-#include <set>
-#include <map>
-#include <unordered_set>
-#include <exception>
-#include <stdexcept>
-#include <csignal>
-#include <cfloat>
-#include <cctype>
-#include <cstdint>
-#include <string>
-
-#ifdef DOCTEST_PLATFORM_MAC
-#include <sys/types.h>
-#include <unistd.h>
-#include <sys/sysctl.h>
-#endif // DOCTEST_PLATFORM_MAC
-
-#ifdef DOCTEST_PLATFORM_WINDOWS
-
-// defines for a leaner windows.h
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#define DOCTEST_UNDEF_WIN32_LEAN_AND_MEAN
-#endif // WIN32_LEAN_AND_MEAN
-#ifndef NOMINMAX
-#define NOMINMAX
-#define DOCTEST_UNDEF_NOMINMAX
-#endif // NOMINMAX
-
-// not sure what AfxWin.h is for - here I do what Catch does
-#ifdef __AFXDLL
-#include <AfxWin.h>
-#else
-#include <windows.h>
-#endif
-#include <io.h>
-
-#else // DOCTEST_PLATFORM_WINDOWS
-
-#include <sys/time.h>
-#include <unistd.h>
-
-#endif // DOCTEST_PLATFORM_WINDOWS
-
-// this is a fix for https://github.com/doctest/doctest/issues/348
-// https://mail.gnome.org/archives/xml/2012-January/msg00000.html
-#if !defined(HAVE_UNISTD_H) && !defined(STDOUT_FILENO)
-#define STDOUT_FILENO fileno(stdout)
-#endif // HAVE_UNISTD_H
-
-DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END
-
-// counts the number of elements in a C array
-#define DOCTEST_COUNTOF(x) (sizeof(x) / sizeof(x[0]))
-
-#ifdef DOCTEST_CONFIG_DISABLE
-#define DOCTEST_BRANCH_ON_DISABLED(if_disabled, if_not_disabled) if_disabled
-#else // DOCTEST_CONFIG_DISABLE
-#define DOCTEST_BRANCH_ON_DISABLED(if_disabled, if_not_disabled) if_not_disabled
-#endif // DOCTEST_CONFIG_DISABLE
-
-#ifndef DOCTEST_CONFIG_OPTIONS_PREFIX
-#define DOCTEST_CONFIG_OPTIONS_PREFIX "dt-"
-#endif
-
-#ifndef DOCTEST_THREAD_LOCAL
-#if defined(DOCTEST_CONFIG_NO_MULTITHREADING) || DOCTEST_MSVC && (DOCTEST_MSVC < DOCTEST_COMPILER(19, 0, 0))
-#define DOCTEST_THREAD_LOCAL
-#else // DOCTEST_MSVC
-#define DOCTEST_THREAD_LOCAL thread_local
-#endif // DOCTEST_MSVC
-#endif // DOCTEST_THREAD_LOCAL
-
-#ifndef DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES
-#define DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES 32
-#endif
-
-#ifndef DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE
-#define DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE 64
-#endif
-
-#ifdef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
-#define DOCTEST_OPTIONS_PREFIX_DISPLAY DOCTEST_CONFIG_OPTIONS_PREFIX
-#else
-#define DOCTEST_OPTIONS_PREFIX_DISPLAY ""
-#endif
-
-#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
-#define DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS
-#endif
-
-#ifndef DOCTEST_CDECL
-#define DOCTEST_CDECL __cdecl
-#endif
-
-namespace doctest {
-
-bool is_running_in_test = false;
-
-namespace {
-    using namespace detail;
-
-    template <typename Ex>
-    DOCTEST_NORETURN void throw_exception(Ex const& e) {
-#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
-        throw e;
-#else  // DOCTEST_CONFIG_NO_EXCEPTIONS
-#ifdef DOCTEST_CONFIG_HANDLE_EXCEPTION
-        DOCTEST_CONFIG_HANDLE_EXCEPTION(e);
-#else // DOCTEST_CONFIG_HANDLE_EXCEPTION
-#ifndef DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
-        std::cerr << "doctest will terminate because it needed to throw an exception.\n"
-                  << "The message was: " << e.what() << '\n';
-#endif // DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
-#endif // DOCTEST_CONFIG_HANDLE_EXCEPTION
-        std::terminate();
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
-    }
-
-#ifndef DOCTEST_INTERNAL_ERROR
-#define DOCTEST_INTERNAL_ERROR(msg)                                                                \
-    throw_exception(std::logic_error(                                                              \
-            __FILE__ ":" DOCTEST_TOSTR(__LINE__) ": Internal doctest error: " msg))
-#endif // DOCTEST_INTERNAL_ERROR
-
-    // case insensitive strcmp
-    int stricmp(const char* a, const char* b) {
-        for(;; a++, b++) {
-            const int d = tolower(*a) - tolower(*b);
-            if(d != 0 || !*a)
-                return d;
-        }
-    }
-
-    struct Endianness
-    {
-        enum Arch
-        {
-            Big,
-            Little
-        };
-
-        static Arch which() {
-            int x = 1;
-            // casting any data pointer to char* is allowed
-            auto ptr = reinterpret_cast<char*>(&x);
-            if(*ptr)
-                return Little;
-            return Big;
-        }
-    };
-} // namespace
-
-namespace detail {
-    DOCTEST_THREAD_LOCAL class
-    {
-        std::vector<std::streampos> stack;
-        std::stringstream           ss;
-
-    public:
-        std::ostream* push() {
-            stack.push_back(ss.tellp());
-            return &ss;
-        }
-
-        String pop() {
-            if (stack.empty())
-                DOCTEST_INTERNAL_ERROR("TLSS was empty when trying to pop!");
-
-            std::streampos pos = stack.back();
-            stack.pop_back();
-            unsigned sz = static_cast<unsigned>(ss.tellp() - pos);
-            ss.rdbuf()->pubseekpos(pos, std::ios::in | std::ios::out);
-            return String(ss, sz);
-        }
-    } g_oss;
-
-    std::ostream* tlssPush() {
-        return g_oss.push();
-    }
-
-    String tlssPop() {
-        return g_oss.pop();
-    }
-
-#ifndef DOCTEST_CONFIG_DISABLE
-
-namespace timer_large_integer
-{
-
-#if defined(DOCTEST_PLATFORM_WINDOWS)
-    using type = ULONGLONG;
-#else // DOCTEST_PLATFORM_WINDOWS
-    using type = std::uint64_t;
-#endif // DOCTEST_PLATFORM_WINDOWS
-}
-
-using ticks_t = timer_large_integer::type;
-
-#ifdef DOCTEST_CONFIG_GETCURRENTTICKS
-    ticks_t getCurrentTicks() { return DOCTEST_CONFIG_GETCURRENTTICKS(); }
-#elif defined(DOCTEST_PLATFORM_WINDOWS)
-    ticks_t getCurrentTicks() {
-        static LARGE_INTEGER hz = { {0} }, hzo = { {0} };
-        if(!hz.QuadPart) {
-            QueryPerformanceFrequency(&hz);
-            QueryPerformanceCounter(&hzo);
-        }
-        LARGE_INTEGER t;
-        QueryPerformanceCounter(&t);
-        return ((t.QuadPart - hzo.QuadPart) * LONGLONG(1000000)) / hz.QuadPart;
-    }
-#else  // DOCTEST_PLATFORM_WINDOWS
-    ticks_t getCurrentTicks() {
-        timeval t;
-        gettimeofday(&t, nullptr);
-        return static_cast<ticks_t>(t.tv_sec) * 1000000 + static_cast<ticks_t>(t.tv_usec);
-    }
-#endif // DOCTEST_PLATFORM_WINDOWS
-
-    struct Timer
-    {
-        void         start() { m_ticks = getCurrentTicks(); }
-        unsigned int getElapsedMicroseconds() const {
-            return static_cast<unsigned int>(getCurrentTicks() - m_ticks);
-        }
-        //unsigned int getElapsedMilliseconds() const {
-        //    return static_cast<unsigned int>(getElapsedMicroseconds() / 1000);
-        //}
-        double getElapsedSeconds() const { return static_cast<double>(getCurrentTicks() - m_ticks) / 1000000.0; }
-
-    private:
-        ticks_t m_ticks = 0;
-    };
-
-#ifdef DOCTEST_CONFIG_NO_MULTITHREADING
-    template <typename T>
-    using Atomic = T;
-#else // DOCTEST_CONFIG_NO_MULTITHREADING
-    template <typename T>
-    using Atomic = std::atomic<T>;
-#endif // DOCTEST_CONFIG_NO_MULTITHREADING
-
-#if defined(DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS) || defined(DOCTEST_CONFIG_NO_MULTITHREADING)
-    template <typename T>
-    using MultiLaneAtomic = Atomic<T>;
-#else // DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS
-    // Provides a multilane implementation of an atomic variable that supports add, sub, load,
-    // store. Instead of using a single atomic variable, this splits up into multiple ones,
-    // each sitting on a separate cache line. The goal is to provide a speedup when most
-    // operations are modifying. It achieves this with two properties:
-    //
-    // * Multiple atomics are used, so chance of congestion from the same atomic is reduced.
-    // * Each atomic sits on a separate cache line, so false sharing is reduced.
-    //
-    // The disadvantage is that there is a small overhead due to the use of TLS, and load/store
-    // is slower because all atomics have to be accessed.
-    template <typename T>
-    class MultiLaneAtomic
-    {
-        struct CacheLineAlignedAtomic
-        {
-            Atomic<T> atomic{};
-            char padding[DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE - sizeof(Atomic<T>)];
-        };
-        CacheLineAlignedAtomic m_atomics[DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES];
-
-        static_assert(sizeof(CacheLineAlignedAtomic) == DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE,
-                      "guarantee one atomic takes exactly one cache line");
-
-    public:
-        T operator++() DOCTEST_NOEXCEPT { return fetch_add(1) + 1; }
-
-        T operator++(int) DOCTEST_NOEXCEPT { return fetch_add(1); }
-
-        T fetch_add(T arg, std::memory_order order = std::memory_order_seq_cst) DOCTEST_NOEXCEPT {
-            return myAtomic().fetch_add(arg, order);
-        }
-
-        T fetch_sub(T arg, std::memory_order order = std::memory_order_seq_cst) DOCTEST_NOEXCEPT {
-            return myAtomic().fetch_sub(arg, order);
-        }
-
-        operator T() const DOCTEST_NOEXCEPT { return load(); }
-
-        T load(std::memory_order order = std::memory_order_seq_cst) const DOCTEST_NOEXCEPT {
-            auto result = T();
-            for(auto const& c : m_atomics) {
-                result += c.atomic.load(order);
-            }
-            return result;
-        }
-
-        T operator=(T desired) DOCTEST_NOEXCEPT { // lgtm [cpp/assignment-does-not-return-this]
-            store(desired);
-            return desired;
-        }
-
-        void store(T desired, std::memory_order order = std::memory_order_seq_cst) DOCTEST_NOEXCEPT {
-            // first value becomes desired", all others become 0.
-            for(auto& c : m_atomics) {
-                c.atomic.store(desired, order);
-                desired = {};
-            }
-        }
-
-    private:
-        // Each thread has a different atomic that it operates on. If more than NumLanes threads
-        // use this, some will use the same atomic. So performance will degrade a bit, but still
-        // everything will work.
-        //
-        // The logic here is a bit tricky. The call should be as fast as possible, so that there
-        // is minimal to no overhead in determining the correct atomic for the current thread.
-        //
-        // 1. A global static counter laneCounter counts continuously up.
-        // 2. Each successive thread will use modulo operation of that counter so it gets an atomic
-        //    assigned in a round-robin fashion.
-        // 3. This tlsLaneIdx is stored in the thread local data, so it is directly available with
-        //    little overhead.
-        Atomic<T>& myAtomic() DOCTEST_NOEXCEPT {
-            static Atomic<size_t> laneCounter;
-            DOCTEST_THREAD_LOCAL size_t tlsLaneIdx =
-                    laneCounter++ % DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES;
-
-            return m_atomics[tlsLaneIdx].atomic;
-        }
-    };
-#endif // DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS
-
-    // this holds both parameters from the command line and runtime data for tests
-    struct ContextState : ContextOptions, TestRunStats, CurrentTestCaseStats
-    {
-        MultiLaneAtomic<int> numAssertsCurrentTest_atomic;
-        MultiLaneAtomic<int> numAssertsFailedCurrentTest_atomic;
-
-        std::vector<std::vector<String>> filters = decltype(filters)(9); // 9 different filters
-
-        std::vector<IReporter*> reporters_currently_used;
-
-        assert_handler ah = nullptr;
-
-        Timer timer;
-
-        std::vector<String> stringifiedContexts; // logging from INFO() due to an exception
-
-        // stuff for subcases
-        bool reachedLeaf;
-        std::vector<SubcaseSignature> subcaseStack;
-        std::vector<SubcaseSignature> nextSubcaseStack;
-        std::unordered_set<unsigned long long> fullyTraversedSubcases;
-        size_t currentSubcaseDepth;
-        Atomic<bool> shouldLogCurrentException;
-
-        void resetRunData() {
-            numTestCases                = 0;
-            numTestCasesPassingFilters  = 0;
-            numTestSuitesPassingFilters = 0;
-            numTestCasesFailed          = 0;
-            numAsserts                  = 0;
-            numAssertsFailed            = 0;
-            numAssertsCurrentTest       = 0;
-            numAssertsFailedCurrentTest = 0;
-        }
-
-        void finalizeTestCaseData() {
-            seconds = timer.getElapsedSeconds();
-
-            // update the non-atomic counters
-            numAsserts += numAssertsCurrentTest_atomic;
-            numAssertsFailed += numAssertsFailedCurrentTest_atomic;
-            numAssertsCurrentTest       = numAssertsCurrentTest_atomic;
-            numAssertsFailedCurrentTest = numAssertsFailedCurrentTest_atomic;
-
-            if(numAssertsFailedCurrentTest)
-                failure_flags |= TestCaseFailureReason::AssertFailure;
-
-            if(Approx(currentTest->m_timeout).epsilon(DBL_EPSILON) != 0 &&
-               Approx(seconds).epsilon(DBL_EPSILON) > currentTest->m_timeout)
-                failure_flags |= TestCaseFailureReason::Timeout;
-
-            if(currentTest->m_should_fail) {
-                if(failure_flags) {
-                    failure_flags |= TestCaseFailureReason::ShouldHaveFailedAndDid;
-                } else {
-                    failure_flags |= TestCaseFailureReason::ShouldHaveFailedButDidnt;
-                }
-            } else if(failure_flags && currentTest->m_may_fail) {
-                failure_flags |= TestCaseFailureReason::CouldHaveFailedAndDid;
-            } else if(currentTest->m_expected_failures > 0) {
-                if(numAssertsFailedCurrentTest == currentTest->m_expected_failures) {
-                    failure_flags |= TestCaseFailureReason::FailedExactlyNumTimes;
-                } else {
-                    failure_flags |= TestCaseFailureReason::DidntFailExactlyNumTimes;
-                }
-            }
-
-            bool ok_to_fail = (TestCaseFailureReason::ShouldHaveFailedAndDid & failure_flags) ||
-                              (TestCaseFailureReason::CouldHaveFailedAndDid & failure_flags) ||
-                              (TestCaseFailureReason::FailedExactlyNumTimes & failure_flags);
-
-            // if any subcase has failed - the whole test case has failed
-            testCaseSuccess = !(failure_flags && !ok_to_fail);
-            if(!testCaseSuccess)
-                numTestCasesFailed++;
-        }
-    };
-
-    ContextState* g_cs = nullptr;
-
-    // used to avoid locks for the debug output
-    // TODO: figure out if this is indeed necessary/correct - seems like either there still
-    // could be a race or that there wouldn't be a race even if using the context directly
-    DOCTEST_THREAD_LOCAL bool g_no_colors;
-
-#endif // DOCTEST_CONFIG_DISABLE
-} // namespace detail
-
-char* String::allocate(size_type sz) {
-    if (sz <= last) {
-        buf[sz] = '\0';
-        setLast(last - sz);
-        return buf;
-    } else {
-        setOnHeap();
-        data.size = sz;
-        data.capacity = data.size + 1;
-        data.ptr = new char[data.capacity];
-        data.ptr[sz] = '\0';
-        return data.ptr;
-    }
-}
-
-void String::setOnHeap() noexcept { *reinterpret_cast<unsigned char*>(&buf[last]) = 128; }
-void String::setLast(size_type in) noexcept { buf[last] = char(in); }
-void String::setSize(size_type sz) noexcept {
-    if (isOnStack()) { buf[sz] = '\0'; setLast(last - sz); }
-    else { data.ptr[sz] = '\0'; data.size = sz; }
-}
-
-void String::copy(const String& other) {
-    if(other.isOnStack()) {
-        memcpy(buf, other.buf, len);
-    } else {
-        memcpy(allocate(other.data.size), other.data.ptr, other.data.size);
-    }
-}
-
-String::String() noexcept {
-    buf[0] = '\0';
-    setLast();
-}
-
-String::~String() {
-    if(!isOnStack())
-        delete[] data.ptr;
-} // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
-
-String::String(const char* in)
-        : String(in, strlen(in)) {}
-
-String::String(const char* in, size_type in_size) {
-    memcpy(allocate(in_size), in, in_size);
-}
-
-String::String(std::istream& in, size_type in_size) {
-    in.read(allocate(in_size), in_size);
-}
-
-String::String(const String& other) { copy(other); }
-
-String& String::operator=(const String& other) {
-    if(this != &other) {
-        if(!isOnStack())
-            delete[] data.ptr;
-
-        copy(other);
-    }
-
-    return *this;
-}
-
-String& String::operator+=(const String& other) {
-    const size_type my_old_size = size();
-    const size_type other_size  = other.size();
-    const size_type total_size  = my_old_size + other_size;
-    if(isOnStack()) {
-        if(total_size < len) {
-            // append to the current stack space
-            memcpy(buf + my_old_size, other.c_str(), other_size + 1);
-            // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
-            setLast(last - total_size);
-        } else {
-            // alloc new chunk
-            char* temp = new char[total_size + 1];
-            // copy current data to new location before writing in the union
-            memcpy(temp, buf, my_old_size); // skip the +1 ('\0') for speed
-            // update data in union
-            setOnHeap();
-            data.size     = total_size;
-            data.capacity = data.size + 1;
-            data.ptr      = temp;
-            // transfer the rest of the data
-            memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1);
-        }
-    } else {
-        if(data.capacity > total_size) {
-            // append to the current heap block
-            data.size = total_size;
-            memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1);
-        } else {
-            // resize
-            data.capacity *= 2;
-            if(data.capacity <= total_size)
-                data.capacity = total_size + 1;
-            // alloc new chunk
-            char* temp = new char[data.capacity];
-            // copy current data to new location before releasing it
-            memcpy(temp, data.ptr, my_old_size); // skip the +1 ('\0') for speed
-            // release old chunk
-            delete[] data.ptr;
-            // update the rest of the union members
-            data.size = total_size;
-            data.ptr  = temp;
-            // transfer the rest of the data
-            memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1);
-        }
-    }
-
-    return *this;
-}
-
-String::String(String&& other) noexcept {
-    memcpy(buf, other.buf, len);
-    other.buf[0] = '\0';
-    other.setLast();
-}
-
-String& String::operator=(String&& other) noexcept {
-    if(this != &other) {
-        if(!isOnStack())
-            delete[] data.ptr;
-        memcpy(buf, other.buf, len);
-        other.buf[0] = '\0';
-        other.setLast();
-    }
-    return *this;
-}
-
-char String::operator[](size_type i) const {
-    return const_cast<String*>(this)->operator[](i);
-}
-
-char& String::operator[](size_type i) {
-    if(isOnStack())
-        return reinterpret_cast<char*>(buf)[i];
-    return data.ptr[i];
-}
-
-DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wmaybe-uninitialized")
-String::size_type String::size() const {
-    if(isOnStack())
-        return last - (size_type(buf[last]) & 31); // using "last" would work only if "len" is 32
-    return data.size;
-}
-DOCTEST_GCC_SUPPRESS_WARNING_POP
-
-String::size_type String::capacity() const {
-    if(isOnStack())
-        return len;
-    return data.capacity;
-}
-
-String String::substr(size_type pos, size_type cnt) && {
-    cnt = std::min(cnt, size() - 1 - pos);
-    char* cptr = c_str();
-    memmove(cptr, cptr + pos, cnt);
-    setSize(cnt);
-    return std::move(*this);
-}
-
-String String::substr(size_type pos, size_type cnt) const & {
-    cnt = std::min(cnt, size() - 1 - pos);
-    return String{ c_str() + pos, cnt };
-}
-
-String::size_type String::find(char ch, size_type pos) const {
-    const char* begin = c_str();
-    const char* end = begin + size();
-    const char* it = begin + pos;
-    for (; it < end && *it != ch; it++);
-    if (it < end) { return static_cast<size_type>(it - begin); }
-    else { return npos; }
-}
-
-String::size_type String::rfind(char ch, size_type pos) const {
-    const char* begin = c_str();
-    const char* it = begin + std::min(pos, size() - 1);
-    for (; it >= begin && *it != ch; it--);
-    if (it >= begin) { return static_cast<size_type>(it - begin); }
-    else { return npos; }
-}
-
-int String::compare(const char* other, bool no_case) const {
-    if(no_case)
-        return doctest::stricmp(c_str(), other);
-    return std::strcmp(c_str(), other);
-}
-
-int String::compare(const String& other, bool no_case) const {
-    return compare(other.c_str(), no_case);
-}
-
-String operator+(const String& lhs, const String& rhs) { return  String(lhs) += rhs; }
-
-bool operator==(const String& lhs, const String& rhs) { return lhs.compare(rhs) == 0; }
-bool operator!=(const String& lhs, const String& rhs) { return lhs.compare(rhs) != 0; }
-bool operator< (const String& lhs, const String& rhs) { return lhs.compare(rhs) < 0; }
-bool operator> (const String& lhs, const String& rhs) { return lhs.compare(rhs) > 0; }
-bool operator<=(const String& lhs, const String& rhs) { return (lhs != rhs) ? lhs.compare(rhs) < 0 : true; }
-bool operator>=(const String& lhs, const String& rhs) { return (lhs != rhs) ? lhs.compare(rhs) > 0 : true; }
-
-std::ostream& operator<<(std::ostream& s, const String& in) { return s << in.c_str(); }
-
-Contains::Contains(const String& str) : string(str) { }
-
-bool Contains::checkWith(const String& other) const {
-    return strstr(other.c_str(), string.c_str()) != nullptr;
-}
-
-String toString(const Contains& in) {
-    return "Contains( " + in.string + " )";
-}
-
-bool operator==(const String& lhs, const Contains& rhs) { return rhs.checkWith(lhs); }
-bool operator==(const Contains& lhs, const String& rhs) { return lhs.checkWith(rhs); }
-bool operator!=(const String& lhs, const Contains& rhs) { return !rhs.checkWith(lhs); }
-bool operator!=(const Contains& lhs, const String& rhs) { return !lhs.checkWith(rhs); }
-
-namespace {
-    void color_to_stream(std::ostream&, Color::Enum) DOCTEST_BRANCH_ON_DISABLED({}, ;)
-} // namespace
-
-namespace Color {
-    std::ostream& operator<<(std::ostream& s, Color::Enum code) {
-        color_to_stream(s, code);
-        return s;
-    }
-} // namespace Color
-
-// clang-format off
-const char* assertString(assertType::Enum at) {
-    DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4061) // enum 'x' in switch of enum 'y' is not explicitly handled
-    #define DOCTEST_GENERATE_ASSERT_TYPE_CASE(assert_type) case assertType::DT_ ## assert_type: return #assert_type
-    #define DOCTEST_GENERATE_ASSERT_TYPE_CASES(assert_type) \
-        DOCTEST_GENERATE_ASSERT_TYPE_CASE(WARN_ ## assert_type); \
-        DOCTEST_GENERATE_ASSERT_TYPE_CASE(CHECK_ ## assert_type); \
-        DOCTEST_GENERATE_ASSERT_TYPE_CASE(REQUIRE_ ## assert_type)
-    switch(at) {
-        DOCTEST_GENERATE_ASSERT_TYPE_CASE(WARN);
-        DOCTEST_GENERATE_ASSERT_TYPE_CASE(CHECK);
-        DOCTEST_GENERATE_ASSERT_TYPE_CASE(REQUIRE);
-
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(FALSE);
-
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(THROWS);
-
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(THROWS_AS);
-
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(THROWS_WITH);
-
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(THROWS_WITH_AS);
-
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(NOTHROW);
-
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(EQ);
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(NE);
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(GT);
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(LT);
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(GE);
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(LE);
-
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(UNARY);
-        DOCTEST_GENERATE_ASSERT_TYPE_CASES(UNARY_FALSE);
-
-        default: DOCTEST_INTERNAL_ERROR("Tried stringifying invalid assert type!");
-    }
-    DOCTEST_MSVC_SUPPRESS_WARNING_POP
-}
-// clang-format on
-
-const char* failureString(assertType::Enum at) {
-    if(at & assertType::is_warn) //!OCLINT bitwise operator in conditional
-        return "WARNING";
-    if(at & assertType::is_check) //!OCLINT bitwise operator in conditional
-        return "ERROR";
-    if(at & assertType::is_require) //!OCLINT bitwise operator in conditional
-        return "FATAL ERROR";
-    return "";
-}
-
-DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wnull-dereference")
-DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wnull-dereference")
-// depending on the current options this will remove the path of filenames
-const char* skipPathFromFilename(const char* file) {
-#ifndef DOCTEST_CONFIG_DISABLE
-    if(getContextOptions()->no_path_in_filenames) {
-        auto back    = std::strrchr(file, '\\');
-        auto forward = std::strrchr(file, '/');
-        if(back || forward) {
-            if(back > forward)
-                forward = back;
-            return forward + 1;
-        }
-    }
-#endif // DOCTEST_CONFIG_DISABLE
-    return file;
-}
-DOCTEST_CLANG_SUPPRESS_WARNING_POP
-DOCTEST_GCC_SUPPRESS_WARNING_POP
-
-bool SubcaseSignature::operator==(const SubcaseSignature& other) const {
-    return m_line == other.m_line
-        && std::strcmp(m_file, other.m_file) == 0
-        && m_name == other.m_name;
-}
-
-bool SubcaseSignature::operator<(const SubcaseSignature& other) const {
-    if(m_line != other.m_line)
-        return m_line < other.m_line;
-    if(std::strcmp(m_file, other.m_file) != 0)
-        return std::strcmp(m_file, other.m_file) < 0;
-    return m_name.compare(other.m_name) < 0;
-}
-
-DOCTEST_DEFINE_INTERFACE(IContextScope)
-
-namespace detail {
-    void filldata<const void*>::fill(std::ostream* stream, const void* in) {
-        if (in) { *stream << in; }
-        else { *stream << "nullptr"; }
-    }
-
-    template <typename T>
-    String toStreamLit(T t) {
-        std::ostream* os = tlssPush();
-        os->operator<<(t);
-        return tlssPop();
-    }
-}
-
-#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
-String toString(const char* in) { return String("\"") + (in ? in : "{null string}") + "\""; }
-#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
-
-#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0)
-// see this issue on why this is needed: https://github.com/doctest/doctest/issues/183
-String toString(const std::string& in) { return in.c_str(); }
-#endif // VS 2019
-
-String toString(String in) { return in; }
-
-String toString(std::nullptr_t) { return "nullptr"; }
-
-String toString(bool in) { return in ? "true" : "false"; }
-
-String toString(float in) { return toStreamLit(in); }
-String toString(double in) { return toStreamLit(in); }
-String toString(double long in) { return toStreamLit(in); }
-
-String toString(char in) { return toStreamLit(static_cast<signed>(in)); }
-String toString(char signed in) { return toStreamLit(static_cast<signed>(in)); }
-String toString(char unsigned in) { return toStreamLit(static_cast<unsigned>(in)); }
-String toString(short in) { return toStreamLit(in); }
-String toString(short unsigned in) { return toStreamLit(in); }
-String toString(signed in) { return toStreamLit(in); }
-String toString(unsigned in) { return toStreamLit(in); }
-String toString(long in) { return toStreamLit(in); }
-String toString(long unsigned in) { return toStreamLit(in); }
-String toString(long long in) { return toStreamLit(in); }
-String toString(long long unsigned in) { return toStreamLit(in); }
-
-Approx::Approx(double value)
-        : m_epsilon(static_cast<double>(std::numeric_limits<float>::epsilon()) * 100)
-        , m_scale(1.0)
-        , m_value(value) {}
-
-Approx Approx::operator()(double value) const {
-    Approx approx(value);
-    approx.epsilon(m_epsilon);
-    approx.scale(m_scale);
-    return approx;
-}
-
-Approx& Approx::epsilon(double newEpsilon) {
-    m_epsilon = newEpsilon;
-    return *this;
-}
-Approx& Approx::scale(double newScale) {
-    m_scale = newScale;
-    return *this;
-}
-
-bool operator==(double lhs, const Approx& rhs) {
-    // Thanks to Richard Harris for his help refining this formula
-    return std::fabs(lhs - rhs.m_value) <
-           rhs.m_epsilon * (rhs.m_scale + std::max<double>(std::fabs(lhs), std::fabs(rhs.m_value)));
-}
-bool operator==(const Approx& lhs, double rhs) { return operator==(rhs, lhs); }
-bool operator!=(double lhs, const Approx& rhs) { return !operator==(lhs, rhs); }
-bool operator!=(const Approx& lhs, double rhs) { return !operator==(rhs, lhs); }
-bool operator<=(double lhs, const Approx& rhs) { return lhs < rhs.m_value || lhs == rhs; }
-bool operator<=(const Approx& lhs, double rhs) { return lhs.m_value < rhs || lhs == rhs; }
-bool operator>=(double lhs, const Approx& rhs) { return lhs > rhs.m_value || lhs == rhs; }
-bool operator>=(const Approx& lhs, double rhs) { return lhs.m_value > rhs || lhs == rhs; }
-bool operator<(double lhs, const Approx& rhs) { return lhs < rhs.m_value && lhs != rhs; }
-bool operator<(const Approx& lhs, double rhs) { return lhs.m_value < rhs && lhs != rhs; }
-bool operator>(double lhs, const Approx& rhs) { return lhs > rhs.m_value && lhs != rhs; }
-bool operator>(const Approx& lhs, double rhs) { return lhs.m_value > rhs && lhs != rhs; }
-
-String toString(const Approx& in) {
-    return "Approx( " + doctest::toString(in.m_value) + " )";
-}
-const ContextOptions* getContextOptions() { return DOCTEST_BRANCH_ON_DISABLED(nullptr, g_cs); }
-
-DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4738)
-template <typename F>
-IsNaN<F>::operator bool() const {
-    return std::isnan(value) ^ flipped;
-}
-DOCTEST_MSVC_SUPPRESS_WARNING_POP
-template struct DOCTEST_INTERFACE_DEF IsNaN<float>;
-template struct DOCTEST_INTERFACE_DEF IsNaN<double>;
-template struct DOCTEST_INTERFACE_DEF IsNaN<long double>;
-template <typename F>
-String toString(IsNaN<F> in) { return String(in.flipped ? "! " : "") + "IsNaN( " + doctest::toString(in.value) + " )"; }
-String toString(IsNaN<float> in) { return toString<float>(in); }
-String toString(IsNaN<double> in) { return toString<double>(in); }
-String toString(IsNaN<double long> in) { return toString<double long>(in); }
-
-} // namespace doctest
-
-#ifdef DOCTEST_CONFIG_DISABLE
-namespace doctest {
-Context::Context(int, const char* const*) {}
-Context::~Context() = default;
-void Context::applyCommandLine(int, const char* const*) {}
-void Context::addFilter(const char*, const char*) {}
-void Context::clearFilters() {}
-void Context::setOption(const char*, bool) {}
-void Context::setOption(const char*, int) {}
-void Context::setOption(const char*, const char*) {}
-bool Context::shouldExit() { return false; }
-void Context::setAsDefaultForAssertsOutOfTestCases() {}
-void Context::setAssertHandler(detail::assert_handler) {}
-void Context::setCout(std::ostream*) {}
-int  Context::run() { return 0; }
-
-int                         IReporter::get_num_active_contexts() { return 0; }
-const IContextScope* const* IReporter::get_active_contexts() { return nullptr; }
-int                         IReporter::get_num_stringified_contexts() { return 0; }
-const String*               IReporter::get_stringified_contexts() { return nullptr; }
-
-int registerReporter(const char*, int, IReporter*) { return 0; }
-
-} // namespace doctest
-#else // DOCTEST_CONFIG_DISABLE
-
-#if !defined(DOCTEST_CONFIG_COLORS_NONE)
-#if !defined(DOCTEST_CONFIG_COLORS_WINDOWS) && !defined(DOCTEST_CONFIG_COLORS_ANSI)
-#ifdef DOCTEST_PLATFORM_WINDOWS
-#define DOCTEST_CONFIG_COLORS_WINDOWS
-#else // linux
-#define DOCTEST_CONFIG_COLORS_ANSI
-#endif // platform
-#endif // DOCTEST_CONFIG_COLORS_WINDOWS && DOCTEST_CONFIG_COLORS_ANSI
-#endif // DOCTEST_CONFIG_COLORS_NONE
-
-namespace doctest_detail_test_suite_ns {
-// holds the current test suite
-doctest::detail::TestSuite& getCurrentTestSuite() {
-    static doctest::detail::TestSuite data{};
-    return data;
-}
-} // namespace doctest_detail_test_suite_ns
-
-namespace doctest {
-namespace {
-    // the int (priority) is part of the key for automatic sorting - sadly one can register a
-    // reporter with a duplicate name and a different priority but hopefully that won't happen often :|
-    using reporterMap = std::map<std::pair<int, String>, reporterCreatorFunc>;
-
-    reporterMap& getReporters() {
-        static reporterMap data;
-        return data;
-    }
-    reporterMap& getListeners() {
-        static reporterMap data;
-        return data;
-    }
-} // namespace
-namespace detail {
-#define DOCTEST_ITERATE_THROUGH_REPORTERS(function, ...)                                           \
-    for(auto& curr_rep : g_cs->reporters_currently_used)                                           \
-    curr_rep->function(__VA_ARGS__)
-
-    bool checkIfShouldThrow(assertType::Enum at) {
-        if(at & assertType::is_require) //!OCLINT bitwise operator in conditional
-            return true;
-
-        if((at & assertType::is_check) //!OCLINT bitwise operator in conditional
-           && getContextOptions()->abort_after > 0 &&
-           (g_cs->numAssertsFailed + g_cs->numAssertsFailedCurrentTest_atomic) >=
-                   getContextOptions()->abort_after)
-            return true;
-
-        return false;
-    }
-
-#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
-    DOCTEST_NORETURN void throwException() {
-        g_cs->shouldLogCurrentException = false;
-        throw TestFailureException(); // NOLINT(hicpp-exception-baseclass)
-    }
-#else // DOCTEST_CONFIG_NO_EXCEPTIONS
-    void throwException() {}
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
-} // namespace detail
-
-namespace {
-    using namespace detail;
-    // matching of a string against a wildcard mask (case sensitivity configurable) taken from
-    // https://www.codeproject.com/Articles/1088/Wildcard-string-compare-globbing
-    int wildcmp(const char* str, const char* wild, bool caseSensitive) {
-        const char* cp = str;
-        const char* mp = wild;
-
-        while((*str) && (*wild != '*')) {
-            if((caseSensitive ? (*wild != *str) : (tolower(*wild) != tolower(*str))) &&
-               (*wild != '?')) {
-                return 0;
-            }
-            wild++;
-            str++;
-        }
-
-        while(*str) {
-            if(*wild == '*') {
-                if(!*++wild) {
-                    return 1;
-                }
-                mp = wild;
-                cp = str + 1;
-            } else if((caseSensitive ? (*wild == *str) : (tolower(*wild) == tolower(*str))) ||
-                      (*wild == '?')) {
-                wild++;
-                str++;
-            } else {
-                wild = mp;   //!OCLINT parameter reassignment
-                str  = cp++; //!OCLINT parameter reassignment
-            }
-        }
-
-        while(*wild == '*') {
-            wild++;
-        }
-        return !*wild;
-    }
-
-    // checks if the name matches any of the filters (and can be configured what to do when empty)
-    bool matchesAny(const char* name, const std::vector<String>& filters, bool matchEmpty,
-        bool caseSensitive) {
-        if (filters.empty() && matchEmpty)
-            return true;
-        for (auto& curr : filters)
-            if (wildcmp(name, curr.c_str(), caseSensitive))
-                return true;
-        return false;
-    }
-
-    DOCTEST_NO_SANITIZE_INTEGER
-    unsigned long long hash(unsigned long long a, unsigned long long b) {
-        return (a << 5) + b;
-    }
-
-    // C string hash function (djb2) - taken from http://www.cse.yorku.ca/~oz/hash.html
-    DOCTEST_NO_SANITIZE_INTEGER
-    unsigned long long hash(const char* str) {
-        unsigned long long hash = 5381;
-        char c;
-        while ((c = *str++))
-            hash = ((hash << 5) + hash) + c; // hash * 33 + c
-        return hash;
-    }
-
-    unsigned long long hash(const SubcaseSignature& sig) {
-        return hash(hash(hash(sig.m_file), hash(sig.m_name.c_str())), sig.m_line);
-    }
-
-    unsigned long long hash(const std::vector<SubcaseSignature>& sigs, size_t count) {
-        unsigned long long running = 0;
-        auto end = sigs.begin() + count;
-        for (auto it = sigs.begin(); it != end; it++) {
-            running = hash(running, hash(*it));
-        }
-        return running;
-    }
-
-    unsigned long long hash(const std::vector<SubcaseSignature>& sigs) {
-        unsigned long long running = 0;
-        for (const SubcaseSignature& sig : sigs) {
-            running = hash(running, hash(sig));
-        }
-        return running;
-    }
-} // namespace
-namespace detail {
-    bool Subcase::checkFilters() {
-        if (g_cs->subcaseStack.size() < size_t(g_cs->subcase_filter_levels)) {
-            if (!matchesAny(m_signature.m_name.c_str(), g_cs->filters[6], true, g_cs->case_sensitive))
-                return true;
-            if (matchesAny(m_signature.m_name.c_str(), g_cs->filters[7], false, g_cs->case_sensitive))
-                return true;
-        }
-        return false;
-    }
-
-    Subcase::Subcase(const String& name, const char* file, int line)
-            : m_signature({name, file, line}) {
-        if (!g_cs->reachedLeaf) {
-            if (g_cs->nextSubcaseStack.size() <= g_cs->subcaseStack.size()
-                || g_cs->nextSubcaseStack[g_cs->subcaseStack.size()] == m_signature) {
-                // Going down.
-                if (checkFilters()) { return; }
-
-                g_cs->subcaseStack.push_back(m_signature);
-                g_cs->currentSubcaseDepth++;
-                m_entered = true;
-                DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_start, m_signature);
-            }
-        } else {
-            if (g_cs->subcaseStack[g_cs->currentSubcaseDepth] == m_signature) {
-                // This subcase is reentered via control flow.
-                g_cs->currentSubcaseDepth++;
-                m_entered = true;
-                DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_start, m_signature);
-            } else if (g_cs->nextSubcaseStack.size() <= g_cs->currentSubcaseDepth
-                    && g_cs->fullyTraversedSubcases.find(hash(hash(g_cs->subcaseStack, g_cs->currentSubcaseDepth), hash(m_signature)))
-                    == g_cs->fullyTraversedSubcases.end()) {
-                if (checkFilters()) { return; }
-                // This subcase is part of the one to be executed next.
-                g_cs->nextSubcaseStack.clear();
-                g_cs->nextSubcaseStack.insert(g_cs->nextSubcaseStack.end(),
-                    g_cs->subcaseStack.begin(), g_cs->subcaseStack.begin() + g_cs->currentSubcaseDepth);
-                g_cs->nextSubcaseStack.push_back(m_signature);
-            }
-        }
-    }
-
-    DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4996) // std::uncaught_exception is deprecated in C++17
-    DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
-    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
-
-    Subcase::~Subcase() {
-        if (m_entered) {
-            g_cs->currentSubcaseDepth--;
-
-            if (!g_cs->reachedLeaf) {
-                // Leaf.
-                g_cs->fullyTraversedSubcases.insert(hash(g_cs->subcaseStack));
-                g_cs->nextSubcaseStack.clear();
-                g_cs->reachedLeaf = true;
-            } else if (g_cs->nextSubcaseStack.empty()) {
-                // All children are finished.
-                g_cs->fullyTraversedSubcases.insert(hash(g_cs->subcaseStack));
-            }
-
-#if defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
-            if(std::uncaught_exceptions() > 0
-#else
-            if(std::uncaught_exception()
-#endif
-                && g_cs->shouldLogCurrentException) {
-                DOCTEST_ITERATE_THROUGH_REPORTERS(
-                        test_case_exception, {"exception thrown in subcase - will translate later "
-                                                "when the whole test case has been exited (cannot "
-                                                "translate while there is an active exception)",
-                                                false});
-                g_cs->shouldLogCurrentException = false;
-            }
-
-            DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_end, DOCTEST_EMPTY);
-        }
-    }
-
-    DOCTEST_CLANG_SUPPRESS_WARNING_POP
-    DOCTEST_GCC_SUPPRESS_WARNING_POP
-    DOCTEST_MSVC_SUPPRESS_WARNING_POP
-
-    Subcase::operator bool() const { return m_entered; }
-
-    Result::Result(bool passed, const String& decomposition)
-            : m_passed(passed)
-            , m_decomp(decomposition) {}
-
-    ExpressionDecomposer::ExpressionDecomposer(assertType::Enum at)
-            : m_at(at) {}
-
-    TestSuite& TestSuite::operator*(const char* in) {
-        m_test_suite = in;
-        return *this;
-    }
-
-    TestCase::TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite,
-                       const String& type, int template_id) {
-        m_file              = file;
-        m_line              = line;
-        m_name              = nullptr; // will be later overridden in operator*
-        m_test_suite        = test_suite.m_test_suite;
-        m_description       = test_suite.m_description;
-        m_skip              = test_suite.m_skip;
-        m_no_breaks         = test_suite.m_no_breaks;
-        m_no_output         = test_suite.m_no_output;
-        m_may_fail          = test_suite.m_may_fail;
-        m_should_fail       = test_suite.m_should_fail;
-        m_expected_failures = test_suite.m_expected_failures;
-        m_timeout           = test_suite.m_timeout;
-
-        m_test        = test;
-        m_type        = type;
-        m_template_id = template_id;
-    }
-
-    TestCase::TestCase(const TestCase& other)
-            : TestCaseData() {
-        *this = other;
-    }
-
-    DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(26434) // hides a non-virtual function
-    TestCase& TestCase::operator=(const TestCase& other) {
-        TestCaseData::operator=(other);
-        m_test        = other.m_test;
-        m_type        = other.m_type;
-        m_template_id = other.m_template_id;
-        m_full_name   = other.m_full_name;
-
-        if(m_template_id != -1)
-            m_name = m_full_name.c_str();
-        return *this;
-    }
-    DOCTEST_MSVC_SUPPRESS_WARNING_POP
-
-    TestCase& TestCase::operator*(const char* in) {
-        m_name = in;
-        // make a new name with an appended type for templated test case
-        if(m_template_id != -1) {
-            m_full_name = String(m_name) + "<" + m_type + ">";
-            // redirect the name to point to the newly constructed full name
-            m_name = m_full_name.c_str();
-        }
-        return *this;
-    }
-
-    bool TestCase::operator<(const TestCase& other) const {
-        // this will be used only to differentiate between test cases - not relevant for sorting
-        if(m_line != other.m_line)
-            return m_line < other.m_line;
-        const int name_cmp = strcmp(m_name, other.m_name);
-        if(name_cmp != 0)
-            return name_cmp < 0;
-        const int file_cmp = m_file.compare(other.m_file);
-        if(file_cmp != 0)
-            return file_cmp < 0;
-        return m_template_id < other.m_template_id;
-    }
-
-    // all the registered tests
-    std::set<TestCase>& getRegisteredTests() {
-        static std::set<TestCase> data;
-        return data;
-    }
-} // namespace detail
-namespace {
-    using namespace detail;
-    // for sorting tests by file/line
-    bool fileOrderComparator(const TestCase* lhs, const TestCase* rhs) {
-        // this is needed because MSVC gives different case for drive letters
-        // for __FILE__ when evaluated in a header and a source file
-        const int res = lhs->m_file.compare(rhs->m_file, bool(DOCTEST_MSVC));
-        if(res != 0)
-            return res < 0;
-        if(lhs->m_line != rhs->m_line)
-            return lhs->m_line < rhs->m_line;
-        return lhs->m_template_id < rhs->m_template_id;
-    }
-
-    // for sorting tests by suite/file/line
-    bool suiteOrderComparator(const TestCase* lhs, const TestCase* rhs) {
-        const int res = std::strcmp(lhs->m_test_suite, rhs->m_test_suite);
-        if(res != 0)
-            return res < 0;
-        return fileOrderComparator(lhs, rhs);
-    }
-
-    // for sorting tests by name/suite/file/line
-    bool nameOrderComparator(const TestCase* lhs, const TestCase* rhs) {
-        const int res = std::strcmp(lhs->m_name, rhs->m_name);
-        if(res != 0)
-            return res < 0;
-        return suiteOrderComparator(lhs, rhs);
-    }
-
-    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
-    void color_to_stream(std::ostream& s, Color::Enum code) {
-        static_cast<void>(s);    // for DOCTEST_CONFIG_COLORS_NONE or DOCTEST_CONFIG_COLORS_WINDOWS
-        static_cast<void>(code); // for DOCTEST_CONFIG_COLORS_NONE
-#ifdef DOCTEST_CONFIG_COLORS_ANSI
-        if(g_no_colors ||
-           (isatty(STDOUT_FILENO) == false && getContextOptions()->force_colors == false))
-            return;
-
-        auto col = "";
-        // clang-format off
-            switch(code) { //!OCLINT missing break in switch statement / unnecessary default statement in covered switch statement
-                case Color::Red:         col = "[0;31m"; break;
-                case Color::Green:       col = "[0;32m"; break;
-                case Color::Blue:        col = "[0;34m"; break;
-                case Color::Cyan:        col = "[0;36m"; break;
-                case Color::Yellow:      col = "[0;33m"; break;
-                case Color::Grey:        col = "[1;30m"; break;
-                case Color::LightGrey:   col = "[0;37m"; break;
-                case Color::BrightRed:   col = "[1;31m"; break;
-                case Color::BrightGreen: col = "[1;32m"; break;
-                case Color::BrightWhite: col = "[1;37m"; break;
-                case Color::Bright: // invalid
-                case Color::None:
-                case Color::White:
-                default:                 col = "[0m";
-            }
-        // clang-format on
-        s << "\033" << col;
-#endif // DOCTEST_CONFIG_COLORS_ANSI
-
-#ifdef DOCTEST_CONFIG_COLORS_WINDOWS
-        if(g_no_colors ||
-           (_isatty(_fileno(stdout)) == false && getContextOptions()->force_colors == false))
-            return;
-
-        static struct ConsoleHelper {
-            HANDLE stdoutHandle;
-            WORD   origFgAttrs;
-            WORD   origBgAttrs;
-
-            ConsoleHelper() {
-                stdoutHandle = GetStdHandle(STD_OUTPUT_HANDLE);
-                CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
-                GetConsoleScreenBufferInfo(stdoutHandle, &csbiInfo);
-                origFgAttrs = csbiInfo.wAttributes & ~(BACKGROUND_GREEN | BACKGROUND_RED |
-                    BACKGROUND_BLUE | BACKGROUND_INTENSITY);
-                origBgAttrs = csbiInfo.wAttributes & ~(FOREGROUND_GREEN | FOREGROUND_RED |
-                    FOREGROUND_BLUE | FOREGROUND_INTENSITY);
-            }
-        } ch;
-
-#define DOCTEST_SET_ATTR(x) SetConsoleTextAttribute(ch.stdoutHandle, x | ch.origBgAttrs)
-
-        // clang-format off
-        switch (code) {
-            case Color::White:       DOCTEST_SET_ATTR(FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE); break;
-            case Color::Red:         DOCTEST_SET_ATTR(FOREGROUND_RED);                                      break;
-            case Color::Green:       DOCTEST_SET_ATTR(FOREGROUND_GREEN);                                    break;
-            case Color::Blue:        DOCTEST_SET_ATTR(FOREGROUND_BLUE);                                     break;
-            case Color::Cyan:        DOCTEST_SET_ATTR(FOREGROUND_BLUE | FOREGROUND_GREEN);                  break;
-            case Color::Yellow:      DOCTEST_SET_ATTR(FOREGROUND_RED | FOREGROUND_GREEN);                   break;
-            case Color::Grey:        DOCTEST_SET_ATTR(0);                                                   break;
-            case Color::LightGrey:   DOCTEST_SET_ATTR(FOREGROUND_INTENSITY);                                break;
-            case Color::BrightRed:   DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_RED);               break;
-            case Color::BrightGreen: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_GREEN);             break;
-            case Color::BrightWhite: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE); break;
-            case Color::None:
-            case Color::Bright: // invalid
-            default:                 DOCTEST_SET_ATTR(ch.origFgAttrs);
-        }
-            // clang-format on
-#endif // DOCTEST_CONFIG_COLORS_WINDOWS
-    }
-    DOCTEST_CLANG_SUPPRESS_WARNING_POP
-
-    std::vector<const IExceptionTranslator*>& getExceptionTranslators() {
-        static std::vector<const IExceptionTranslator*> data;
-        return data;
-    }
-
-    String translateActiveException() {
-#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
-        String res;
-        auto&  translators = getExceptionTranslators();
-        for(auto& curr : translators)
-            if(curr->translate(res))
-                return res;
-        // clang-format off
-        DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wcatch-value")
-        try {
-            throw;
-        } catch(std::exception& ex) {
-            return ex.what();
-        } catch(std::string& msg) {
-            return msg.c_str();
-        } catch(const char* msg) {
-            return msg;
-        } catch(...) {
-            return "unknown exception";
-        }
-        DOCTEST_GCC_SUPPRESS_WARNING_POP
-// clang-format on
-#else  // DOCTEST_CONFIG_NO_EXCEPTIONS
-        return "";
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
-    }
-} // namespace
-
-namespace detail {
-    // used by the macros for registering tests
-    int regTest(const TestCase& tc) {
-        getRegisteredTests().insert(tc);
-        return 0;
-    }
-
-    // sets the current test suite
-    int setTestSuite(const TestSuite& ts) {
-        doctest_detail_test_suite_ns::getCurrentTestSuite() = ts;
-        return 0;
-    }
-
-#ifdef DOCTEST_IS_DEBUGGER_ACTIVE
-    bool isDebuggerActive() { return DOCTEST_IS_DEBUGGER_ACTIVE(); }
-#else // DOCTEST_IS_DEBUGGER_ACTIVE
-#ifdef DOCTEST_PLATFORM_LINUX
-    class ErrnoGuard {
-    public:
-        ErrnoGuard() : m_oldErrno(errno) {}
-        ~ErrnoGuard() { errno = m_oldErrno; }
-    private:
-        int m_oldErrno;
-    };
-    // See the comments in Catch2 for the reasoning behind this implementation:
-    // https://github.com/catchorg/Catch2/blob/v2.13.1/include/internal/catch_debugger.cpp#L79-L102
-    bool isDebuggerActive() {
-        ErrnoGuard guard;
-        std::ifstream in("/proc/self/status");
-        for(std::string line; std::getline(in, line);) {
-            static const int PREFIX_LEN = 11;
-            if(line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0) {
-                return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
-            }
-        }
-        return false;
-    }
-#elif defined(DOCTEST_PLATFORM_MAC)
-    // The following function is taken directly from the following technical note:
-    // https://developer.apple.com/library/archive/qa/qa1361/_index.html
-    // Returns true if the current process is being debugged (either
-    // running under the debugger or has a debugger attached post facto).
-    bool isDebuggerActive() {
-        int        mib[4];
-        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);
-        if(sysctl(mib, DOCTEST_COUNTOF(mib), &info, &size, 0, 0) != 0) {
-            std::cerr << "\nCall to sysctl failed - unable to determine if debugger is active **\n";
-            return false;
-        }
-        // We're being debugged if the P_TRACED flag is set.
-        return ((info.kp_proc.p_flag & P_TRACED) != 0);
-    }
-#elif DOCTEST_MSVC || defined(__MINGW32__) || defined(__MINGW64__)
-    bool isDebuggerActive() { return ::IsDebuggerPresent() != 0; }
-#else
-    bool isDebuggerActive() { return false; }
-#endif // Platform
-#endif // DOCTEST_IS_DEBUGGER_ACTIVE
-
-    void registerExceptionTranslatorImpl(const IExceptionTranslator* et) {
-        if(std::find(getExceptionTranslators().begin(), getExceptionTranslators().end(), et) ==
-           getExceptionTranslators().end())
-            getExceptionTranslators().push_back(et);
-    }
-
-    DOCTEST_THREAD_LOCAL std::vector<IContextScope*> g_infoContexts; // for logging with INFO()
-
-    ContextScopeBase::ContextScopeBase() {
-        g_infoContexts.push_back(this);
-    }
-
-    ContextScopeBase::ContextScopeBase(ContextScopeBase&& other) noexcept {
-        if (other.need_to_destroy) {
-            other.destroy();
-        }
-        other.need_to_destroy = false;
-        g_infoContexts.push_back(this);
-    }
-
-    DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4996) // std::uncaught_exception is deprecated in C++17
-    DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
-    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
-
-    // destroy cannot be inlined into the destructor because that would mean calling stringify after
-    // ContextScope has been destroyed (base class destructors run after derived class destructors).
-    // Instead, ContextScope calls this method directly from its destructor.
-    void ContextScopeBase::destroy() {
-#if defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
-        if(std::uncaught_exceptions() > 0) {
-#else
-        if(std::uncaught_exception()) {
-#endif
-            std::ostringstream s;
-            this->stringify(&s);
-            g_cs->stringifiedContexts.push_back(s.str().c_str());
-        }
-        g_infoContexts.pop_back();
-    }
-
-    DOCTEST_CLANG_SUPPRESS_WARNING_POP
-    DOCTEST_GCC_SUPPRESS_WARNING_POP
-    DOCTEST_MSVC_SUPPRESS_WARNING_POP
-} // namespace detail
-namespace {
-    using namespace detail;
-
-#if !defined(DOCTEST_CONFIG_POSIX_SIGNALS) && !defined(DOCTEST_CONFIG_WINDOWS_SEH)
-    struct FatalConditionHandler
-    {
-        static void reset() {}
-        static void allocateAltStackMem() {}
-        static void freeAltStackMem() {}
-    };
-#else // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH
-
-    void reportFatal(const std::string&);
-
-#ifdef DOCTEST_PLATFORM_WINDOWS
-
-    struct SignalDefs
-    {
-        DWORD id;
-        const char* name;
-    };
-    // There is no 1-1 mapping between signals and windows exceptions.
-    // Windows can easily distinguish between SO and SigSegV,
-    // but SigInt, SigTerm, etc are handled differently.
-    SignalDefs signalDefs[] = {
-            {static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),
-             "SIGILL - Illegal instruction signal"},
-            {static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow"},
-            {static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION),
-             "SIGSEGV - Segmentation violation signal"},
-            {static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error"},
-    };
-
-    struct FatalConditionHandler
-    {
-        static LONG CALLBACK handleException(PEXCEPTION_POINTERS ExceptionInfo) {
-            // Multiple threads may enter this filter/handler at once. We want the error message to be printed on the
-            // console just once no matter how many threads have crashed.
-            DOCTEST_DECLARE_STATIC_MUTEX(mutex)
-            static bool execute = true;
-            {
-                DOCTEST_LOCK_MUTEX(mutex)
-                if(execute) {
-                    bool reported = false;
-                    for(size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
-                        if(ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
-                            reportFatal(signalDefs[i].name);
-                            reported = true;
-                            break;
-                        }
-                    }
-                    if(reported == false)
-                        reportFatal("Unhandled SEH exception caught");
-                    if(isDebuggerActive() && !g_cs->no_breaks)
-                        DOCTEST_BREAK_INTO_DEBUGGER();
-                }
-                execute = false;
-            }
-            std::exit(EXIT_FAILURE);
-        }
-
-        static void allocateAltStackMem() {}
-        static void freeAltStackMem() {}
-
-        FatalConditionHandler() {
-            isSet = true;
-            // 32k seems enough for doctest to handle stack overflow,
-            // but the value was found experimentally, so there is no strong guarantee
-            guaranteeSize = 32 * 1024;
-            // Register an unhandled exception filter
-            previousTop = SetUnhandledExceptionFilter(handleException);
-            // Pass in guarantee size to be filled
-            SetThreadStackGuarantee(&guaranteeSize);
-
-            // On Windows uncaught exceptions from another thread, exceptions from
-            // destructors, or calls to std::terminate are not a SEH exception
-
-            // The terminal handler gets called when:
-            // - std::terminate is called FROM THE TEST RUNNER THREAD
-            // - an exception is thrown from a destructor FROM THE TEST RUNNER THREAD
-            original_terminate_handler = std::get_terminate();
-            std::set_terminate([]() DOCTEST_NOEXCEPT {
-                reportFatal("Terminate handler called");
-                if(isDebuggerActive() && !g_cs->no_breaks)
-                    DOCTEST_BREAK_INTO_DEBUGGER();
-                std::exit(EXIT_FAILURE); // explicitly exit - otherwise the SIGABRT handler may be called as well
-            });
-
-            // SIGABRT is raised when:
-            // - std::terminate is called FROM A DIFFERENT THREAD
-            // - an exception is thrown from a destructor FROM A DIFFERENT THREAD
-            // - an uncaught exception is thrown FROM A DIFFERENT THREAD
-            prev_sigabrt_handler = std::signal(SIGABRT, [](int signal) DOCTEST_NOEXCEPT {
-                if(signal == SIGABRT) {
-                    reportFatal("SIGABRT - Abort (abnormal termination) signal");
-                    if(isDebuggerActive() && !g_cs->no_breaks)
-                        DOCTEST_BREAK_INTO_DEBUGGER();
-                    std::exit(EXIT_FAILURE);
-                }
-            });
-
-            // The following settings are taken from google test, and more
-            // specifically from UnitTest::Run() inside of gtest.cc
-
-            // the user does not want to see pop-up dialogs about crashes
-            prev_error_mode_1 = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
-                                             SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
-            // This forces the abort message to go to stderr in all circumstances.
-            prev_error_mode_2 = _set_error_mode(_OUT_TO_STDERR);
-            // In the debug version, Visual Studio pops up a separate dialog
-            // offering a choice to debug the aborted program - we want to disable that.
-            prev_abort_behavior = _set_abort_behavior(0x0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
-            // In debug mode, the Windows CRT can crash with an assertion over invalid
-            // input (e.g. passing an invalid file descriptor). The default handling
-            // for these assertions is to pop up a dialog and wait for user input.
-            // Instead ask the CRT to dump such assertions to stderr non-interactively.
-            prev_report_mode = _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-            prev_report_file = _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
-        }
-
-        static void reset() {
-            if(isSet) {
-                // Unregister handler and restore the old guarantee
-                SetUnhandledExceptionFilter(previousTop);
-                SetThreadStackGuarantee(&guaranteeSize);
-                std::set_terminate(original_terminate_handler);
-                std::signal(SIGABRT, prev_sigabrt_handler);
-                SetErrorMode(prev_error_mode_1);
-                _set_error_mode(prev_error_mode_2);
-                _set_abort_behavior(prev_abort_behavior, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
-                static_cast<void>(_CrtSetReportMode(_CRT_ASSERT, prev_report_mode));
-                static_cast<void>(_CrtSetReportFile(_CRT_ASSERT, prev_report_file));
-                isSet = false;
-            }
-        }
-
-        ~FatalConditionHandler() { reset(); }
-
-    private:
-        static UINT         prev_error_mode_1;
-        static int          prev_error_mode_2;
-        static unsigned int prev_abort_behavior;
-        static int          prev_report_mode;
-        static _HFILE       prev_report_file;
-        static void (DOCTEST_CDECL *prev_sigabrt_handler)(int);
-        static std::terminate_handler original_terminate_handler;
-        static bool isSet;
-        static ULONG guaranteeSize;
-        static LPTOP_LEVEL_EXCEPTION_FILTER previousTop;
-    };
-
-    UINT         FatalConditionHandler::prev_error_mode_1;
-    int          FatalConditionHandler::prev_error_mode_2;
-    unsigned int FatalConditionHandler::prev_abort_behavior;
-    int          FatalConditionHandler::prev_report_mode;
-    _HFILE       FatalConditionHandler::prev_report_file;
-    void (DOCTEST_CDECL *FatalConditionHandler::prev_sigabrt_handler)(int);
-    std::terminate_handler FatalConditionHandler::original_terminate_handler;
-    bool FatalConditionHandler::isSet = false;
-    ULONG FatalConditionHandler::guaranteeSize = 0;
-    LPTOP_LEVEL_EXCEPTION_FILTER FatalConditionHandler::previousTop = nullptr;
-
-#else // DOCTEST_PLATFORM_WINDOWS
-
-    struct SignalDefs
-    {
-        int         id;
-        const char* name;
-    };
-    SignalDefs signalDefs[] = {{SIGINT, "SIGINT - Terminal interrupt signal"},
-                               {SIGILL, "SIGILL - Illegal instruction signal"},
-                               {SIGFPE, "SIGFPE - Floating point error signal"},
-                               {SIGSEGV, "SIGSEGV - Segmentation violation signal"},
-                               {SIGTERM, "SIGTERM - Termination request signal"},
-                               {SIGABRT, "SIGABRT - Abort (abnormal termination) signal"}};
-
-    struct FatalConditionHandler
-    {
-        static bool             isSet;
-        static struct sigaction oldSigActions[DOCTEST_COUNTOF(signalDefs)];
-        static stack_t          oldSigStack;
-        static size_t           altStackSize;
-        static char*            altStackMem;
-
-        static void handleSignal(int sig) {
-            const char* name = "<unknown signal>";
-            for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
-                SignalDefs& def = signalDefs[i];
-                if(sig == def.id) {
-                    name = def.name;
-                    break;
-                }
-            }
-            reset();
-            reportFatal(name);
-            raise(sig);
-        }
-
-        static void allocateAltStackMem() {
-            altStackMem = new char[altStackSize];
-        }
-
-        static void freeAltStackMem() {
-            delete[] altStackMem;
-        }
-
-        FatalConditionHandler() {
-            isSet = true;
-            stack_t sigStack;
-            sigStack.ss_sp    = altStackMem;
-            sigStack.ss_size  = altStackSize;
-            sigStack.ss_flags = 0;
-            sigaltstack(&sigStack, &oldSigStack);
-            struct sigaction sa = {};
-            sa.sa_handler       = handleSignal;
-            sa.sa_flags         = SA_ONSTACK;
-            for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
-                sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
-            }
-        }
-
-        ~FatalConditionHandler() { reset(); }
-        static void reset() {
-            if(isSet) {
-                // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
-                for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
-                    sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
-                }
-                // Return the old stack
-                sigaltstack(&oldSigStack, nullptr);
-                isSet = false;
-            }
-        }
-    };
-
-    bool             FatalConditionHandler::isSet = false;
-    struct sigaction FatalConditionHandler::oldSigActions[DOCTEST_COUNTOF(signalDefs)] = {};
-    stack_t          FatalConditionHandler::oldSigStack = {};
-    size_t           FatalConditionHandler::altStackSize = 4 * SIGSTKSZ;
-    char*            FatalConditionHandler::altStackMem = nullptr;
-
-#endif // DOCTEST_PLATFORM_WINDOWS
-#endif // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH
-
-} // namespace
-
-namespace {
-    using namespace detail;
-
-#ifdef DOCTEST_PLATFORM_WINDOWS
-#define DOCTEST_OUTPUT_DEBUG_STRING(text) ::OutputDebugStringA(text)
-#else
-    // TODO: integration with XCode and other IDEs
-#define DOCTEST_OUTPUT_DEBUG_STRING(text)
-#endif // Platform
-
-    void addAssert(assertType::Enum at) {
-        if((at & assertType::is_warn) == 0) //!OCLINT bitwise operator in conditional
-            g_cs->numAssertsCurrentTest_atomic++;
-    }
-
-    void addFailedAssert(assertType::Enum at) {
-        if((at & assertType::is_warn) == 0) //!OCLINT bitwise operator in conditional
-            g_cs->numAssertsFailedCurrentTest_atomic++;
-    }
-
-#if defined(DOCTEST_CONFIG_POSIX_SIGNALS) || defined(DOCTEST_CONFIG_WINDOWS_SEH)
-    void reportFatal(const std::string& message) {
-        g_cs->failure_flags |= TestCaseFailureReason::Crash;
-
-        DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_exception, {message.c_str(), true});
-
-        while (g_cs->subcaseStack.size()) {
-            g_cs->subcaseStack.pop_back();
-            DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_end, DOCTEST_EMPTY);
-        }
-
-        g_cs->finalizeTestCaseData();
-
-        DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_end, *g_cs);
-
-        DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_end, *g_cs);
-    }
-#endif // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH
-} // namespace
-
-AssertData::AssertData(assertType::Enum at, const char* file, int line, const char* expr,
-    const char* exception_type, const StringContains& exception_string)
-    : m_test_case(g_cs->currentTest), m_at(at), m_file(file), m_line(line), m_expr(expr),
-    m_failed(true), m_threw(false), m_threw_as(false), m_exception_type(exception_type),
-    m_exception_string(exception_string) {
-#if DOCTEST_MSVC
-    if (m_expr[0] == ' ') // this happens when variadic macros are disabled under MSVC
-        ++m_expr;
-#endif // MSVC
-}
-
-namespace detail {
-    ResultBuilder::ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
-                                 const char* exception_type, const String& exception_string)
-        : AssertData(at, file, line, expr, exception_type, exception_string) { }
-
-    ResultBuilder::ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
-        const char* exception_type, const Contains& exception_string)
-        : AssertData(at, file, line, expr, exception_type, exception_string) { }
-
-    void ResultBuilder::setResult(const Result& res) {
-        m_decomp = res.m_decomp;
-        m_failed = !res.m_passed;
-    }
-
-    void ResultBuilder::translateException() {
-        m_threw     = true;
-        m_exception = translateActiveException();
-    }
-
-    bool ResultBuilder::log() {
-        if(m_at & assertType::is_throws) { //!OCLINT bitwise operator in conditional
-            m_failed = !m_threw;
-        } else if((m_at & assertType::is_throws_as) && (m_at & assertType::is_throws_with)) { //!OCLINT
-            m_failed = !m_threw_as || !m_exception_string.check(m_exception);
-        } else if(m_at & assertType::is_throws_as) { //!OCLINT bitwise operator in conditional
-            m_failed = !m_threw_as;
-        } else if(m_at & assertType::is_throws_with) { //!OCLINT bitwise operator in conditional
-            m_failed = !m_exception_string.check(m_exception);
-        } else if(m_at & assertType::is_nothrow) { //!OCLINT bitwise operator in conditional
-            m_failed = m_threw;
-        }
-
-        if(m_exception.size())
-            m_exception = "\"" + m_exception + "\"";
-
-        if(is_running_in_test) {
-            addAssert(m_at);
-            DOCTEST_ITERATE_THROUGH_REPORTERS(log_assert, *this);
-
-            if(m_failed)
-                addFailedAssert(m_at);
-        } else if(m_failed) {
-            failed_out_of_a_testing_context(*this);
-        }
-
-        return m_failed && isDebuggerActive() && !getContextOptions()->no_breaks &&
-            (g_cs->currentTest == nullptr || !g_cs->currentTest->m_no_breaks); // break into debugger
-    }
-
-    void ResultBuilder::react() const {
-        if(m_failed && checkIfShouldThrow(m_at))
-            throwException();
-    }
-
-    void failed_out_of_a_testing_context(const AssertData& ad) {
-        if(g_cs->ah)
-            g_cs->ah(ad);
-        else
-            std::abort();
-    }
-
-    bool decomp_assert(assertType::Enum at, const char* file, int line, const char* expr,
-                       const Result& result) {
-        bool failed = !result.m_passed;
-
-        // ###################################################################################
-        // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
-        // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
-        // ###################################################################################
-        DOCTEST_ASSERT_OUT_OF_TESTS(result.m_decomp);
-        DOCTEST_ASSERT_IN_TESTS(result.m_decomp);
-        return !failed;
-    }
-
-    MessageBuilder::MessageBuilder(const char* file, int line, assertType::Enum severity) {
-        m_stream   = tlssPush();
-        m_file     = file;
-        m_line     = line;
-        m_severity = severity;
-    }
-
-    MessageBuilder::~MessageBuilder() {
-        if (!logged)
-            tlssPop();
-    }
-
-    DOCTEST_DEFINE_INTERFACE(IExceptionTranslator)
-
-    bool MessageBuilder::log() {
-        if (!logged) {
-            m_string = tlssPop();
-            logged = true;
-        }
-
-        DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);
-
-        const bool isWarn = m_severity & assertType::is_warn;
-
-        // warn is just a message in this context so we don't treat it as an assert
-        if(!isWarn) {
-            addAssert(m_severity);
-            addFailedAssert(m_severity);
-        }
-
-        return isDebuggerActive() && !getContextOptions()->no_breaks && !isWarn &&
-            (g_cs->currentTest == nullptr || !g_cs->currentTest->m_no_breaks); // break into debugger
-    }
-
-    void MessageBuilder::react() {
-        if(m_severity & assertType::is_require) //!OCLINT bitwise operator in conditional
-            throwException();
-    }
-} // namespace detail
-namespace {
-    using namespace detail;
-
-    // clang-format off
-
-// =================================================================================================
-// The following code has been taken verbatim from Catch2/include/internal/catch_xmlwriter.h/cpp
-// This is done so cherry-picking bug fixes is trivial - even the style/formatting is untouched.
-// =================================================================================================
-
-    class XmlEncode {
-    public:
-        enum ForWhat { ForTextNodes, ForAttributes };
-
-        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
-
-        void encodeTo( std::ostream& os ) const;
-
-        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
-
-    private:
-        std::string m_str;
-        ForWhat m_forWhat;
-    };
-
-    class XmlWriter {
-    public:
-
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer );
-
-            ScopedElement( ScopedElement&& other ) DOCTEST_NOEXCEPT;
-            ScopedElement& operator=( ScopedElement&& other ) DOCTEST_NOEXCEPT;
-
-            ~ScopedElement();
-
-            ScopedElement& writeText( std::string const& text, bool indent = true );
-
-            template<typename T>
-            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
-            }
-
-        private:
-            mutable XmlWriter* m_writer = nullptr;
-        };
-
-#ifndef DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
-        XmlWriter( std::ostream& os = std::cout );
-#else // DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
-        XmlWriter( std::ostream& os );
-#endif // DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
-        ~XmlWriter();
-
-        XmlWriter( XmlWriter const& ) = delete;
-        XmlWriter& operator=( XmlWriter const& ) = delete;
-
-        XmlWriter& startElement( std::string const& name );
-
-        ScopedElement scopedElement( std::string const& name );
-
-        XmlWriter& endElement();
-
-        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
-
-        XmlWriter& writeAttribute( std::string const& name, const char* attribute );
-
-        XmlWriter& writeAttribute( std::string const& name, bool attribute );
-
-        template<typename T>
-        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
-        std::stringstream rss;
-            rss << attribute;
-            return writeAttribute( name, rss.str() );
-        }
-
-        XmlWriter& writeText( std::string const& text, bool indent = true );
-
-        //XmlWriter& writeComment( std::string const& text );
-
-        //void writeStylesheetRef( std::string const& url );
-
-        //XmlWriter& writeBlankLine();
-
-        void ensureTagClosed();
-
-        void writeDeclaration();
-
-    private:
-
-        void newlineIfNecessary();
-
-        bool m_tagIsOpen = false;
-        bool m_needsNewline = false;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream& m_os;
-    };
-
-// =================================================================================================
-// The following code has been taken verbatim from Catch2/include/internal/catch_xmlwriter.h/cpp
-// This is done so cherry-picking bug fixes is trivial - even the style/formatting is untouched.
-// =================================================================================================
-
-using uchar = unsigned char;
-
-namespace {
-
-    size_t trailingBytes(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return 2;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return 3;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return 4;
-        }
-        DOCTEST_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    uint32_t headerValue(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return c & 0x1F;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return c & 0x0F;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return c & 0x07;
-        }
-        DOCTEST_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    void hexEscapeChar(std::ostream& os, unsigned char c) {
-        std::ios_base::fmtflags f(os.flags());
-        os << "\\x"
-            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
-            << static_cast<int>(c);
-        os.flags(f);
-    }
-
-} // anonymous namespace
-
-    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
-    :   m_str( str ),
-        m_forWhat( forWhat )
-    {}
-
-    void XmlEncode::encodeTo( std::ostream& os ) const {
-        // Apostrophe escaping not necessary if we always use " to write attributes
-        // (see: https://www.w3.org/TR/xml/#syntax)
-
-        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
-            uchar c = m_str[idx];
-            switch (c) {
-            case '<':   os << "&lt;"; break;
-            case '&':   os << "&amp;"; break;
-
-            case '>':
-                // See: https://www.w3.org/TR/xml/#syntax
-                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
-                    os << "&gt;";
-                else
-                    os << c;
-                break;
-
-            case '\"':
-                if (m_forWhat == ForAttributes)
-                    os << "&quot;";
-                else
-                    os << c;
-                break;
-
-            default:
-                // Check for control characters and invalid utf-8
-
-                // Escape control characters in standard ascii
-                // see https://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
-                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // Plain ASCII: Write it to stream
-                if (c < 0x7F) {
-                    os << c;
-                    break;
-                }
-
-                // UTF-8 territory
-                // Check if the encoding is valid and if it is not, hex escape bytes.
-                // Important: We do not check the exact decoded values for validity, only the encoding format
-                // First check that this bytes is a valid lead byte:
-                // This means that it is not encoded as 1111 1XXX
-                // Or as 10XX XXXX
-                if (c <  0xC0 ||
-                    c >= 0xF8) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                auto encBytes = trailingBytes(c);
-                // Are there enough bytes left to avoid accessing out-of-bounds memory?
-                if (idx + encBytes - 1 >= m_str.size()) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-                // The header is valid, check data
-                // The next encBytes bytes must together be a valid utf-8
-                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
-                bool valid = true;
-                uint32_t value = headerValue(c);
-                for (std::size_t n = 1; n < encBytes; ++n) {
-                    uchar nc = m_str[idx + n];
-                    valid &= ((nc & 0xC0) == 0x80);
-                    value = (value << 6) | (nc & 0x3F);
-                }
-
-                if (
-                    // Wrong bit pattern of following bytes
-                    (!valid) ||
-                    // Overlong encodings
-                    (value < 0x80) ||
-                    (                 value < 0x800   && encBytes > 2) || // removed "0x80 <= value &&" because redundant
-                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
-                    // Encoded value out of range
-                    (value >= 0x110000)
-                    ) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // If we got here, this is in fact a valid(ish) utf-8 sequence
-                for (std::size_t n = 0; n < encBytes; ++n) {
-                    os << m_str[idx + n];
-                }
-                idx += encBytes - 1;
-                break;
-            }
-        }
-    }
-
-    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
-        xmlEncode.encodeTo( os );
-        return os;
-    }
-
-    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer )
-    :   m_writer( writer )
-    {}
-
-    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) DOCTEST_NOEXCEPT
-    :   m_writer( other.m_writer ){
-        other.m_writer = nullptr;
-    }
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) DOCTEST_NOEXCEPT {
-        if ( m_writer ) {
-            m_writer->endElement();
-        }
-        m_writer = other.m_writer;
-        other.m_writer = nullptr;
-        return *this;
-    }
-
-
-    XmlWriter::ScopedElement::~ScopedElement() {
-        if( m_writer )
-            m_writer->endElement();
-    }
-
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, bool indent ) {
-        m_writer->writeText( text, indent );
-        return *this;
-    }
-
-    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
-    {
-        // writeDeclaration(); // called explicitly by the reporters that use the writer class - see issue #627
-    }
-
-    XmlWriter::~XmlWriter() {
-        while( !m_tags.empty() )
-            endElement();
-    }
-
-    XmlWriter& XmlWriter::startElement( std::string const& name ) {
-        ensureTagClosed();
-        newlineIfNecessary();
-        m_os << m_indent << '<' << name;
-        m_tags.push_back( name );
-        m_indent += "  ";
-        m_tagIsOpen = true;
-        return *this;
-    }
-
-    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name ) {
-        ScopedElement scoped( this );
-        startElement( name );
-        return scoped;
-    }
-
-    XmlWriter& XmlWriter::endElement() {
-        newlineIfNecessary();
-        m_indent = m_indent.substr( 0, m_indent.size()-2 );
-        if( m_tagIsOpen ) {
-            m_os << "/>";
-            m_tagIsOpen = false;
-        }
-        else {
-            m_os << m_indent << "</" << m_tags.back() << ">";
-        }
-        m_os << std::endl;
-        m_tags.pop_back();
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
-        if( !name.empty() && !attribute.empty() )
-            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, const char* attribute ) {
-        if( !name.empty() && attribute && attribute[0] != '\0' )
-            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
-        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeText( std::string const& text, bool indent ) {
-        if( !text.empty() ){
-            bool tagWasOpen = m_tagIsOpen;
-            ensureTagClosed();
-            if( tagWasOpen && indent )
-                m_os << m_indent;
-            m_os << XmlEncode( text );
-            m_needsNewline = true;
-        }
-        return *this;
-    }
-
-    //XmlWriter& XmlWriter::writeComment( std::string const& text ) {
-    //    ensureTagClosed();
-    //    m_os << m_indent << "<!--" << text << "-->";
-    //    m_needsNewline = true;
-    //    return *this;
-    //}
-
-    //void XmlWriter::writeStylesheetRef( std::string const& url ) {
-    //    m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
-    //}
-
-    //XmlWriter& XmlWriter::writeBlankLine() {
-    //    ensureTagClosed();
-    //    m_os << '\n';
-    //    return *this;
-    //}
-
-    void XmlWriter::ensureTagClosed() {
-        if( m_tagIsOpen ) {
-            m_os << ">" << std::endl;
-            m_tagIsOpen = false;
-        }
-    }
-
-    void XmlWriter::writeDeclaration() {
-        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-    }
-
-    void XmlWriter::newlineIfNecessary() {
-        if( m_needsNewline ) {
-            m_os << std::endl;
-            m_needsNewline = false;
-        }
-    }
-
-// =================================================================================================
-// End of copy-pasted code from Catch
-// =================================================================================================
-
-    // clang-format on
-
-    struct XmlReporter : public IReporter
-    {
-        XmlWriter xml;
-        DOCTEST_DECLARE_MUTEX(mutex)
-
-        // caching pointers/references to objects of these types - safe to do
-        const ContextOptions& opt;
-        const TestCaseData*   tc = nullptr;
-
-        XmlReporter(const ContextOptions& co)
-                : xml(*co.cout)
-                , opt(co) {}
-
-        void log_contexts() {
-            int num_contexts = get_num_active_contexts();
-            if(num_contexts) {
-                auto              contexts = get_active_contexts();
-                std::stringstream ss;
-                for(int i = 0; i < num_contexts; ++i) {
-                    contexts[i]->stringify(&ss);
-                    xml.scopedElement("Info").writeText(ss.str());
-                    ss.str("");
-                }
-            }
-        }
-
-        unsigned line(unsigned l) const { return opt.no_line_numbers ? 0 : l; }
-
-        void test_case_start_impl(const TestCaseData& in) {
-            bool open_ts_tag = false;
-            if(tc != nullptr) { // we have already opened a test suite
-                if(std::strcmp(tc->m_test_suite, in.m_test_suite) != 0) {
-                    xml.endElement();
-                    open_ts_tag = true;
-                }
-            }
-            else {
-                open_ts_tag = true; // first test case ==> first test suite
-            }
-
-            if(open_ts_tag) {
-                xml.startElement("TestSuite");
-                xml.writeAttribute("name", in.m_test_suite);
-            }
-
-            tc = &in;
-            xml.startElement("TestCase")
-                    .writeAttribute("name", in.m_name)
-                    .writeAttribute("filename", skipPathFromFilename(in.m_file.c_str()))
-                    .writeAttribute("line", line(in.m_line))
-                    .writeAttribute("description", in.m_description);
-
-            if(Approx(in.m_timeout) != 0)
-                xml.writeAttribute("timeout", in.m_timeout);
-            if(in.m_may_fail)
-                xml.writeAttribute("may_fail", true);
-            if(in.m_should_fail)
-                xml.writeAttribute("should_fail", true);
-        }
-
-        // =========================================================================================
-        // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE
-        // =========================================================================================
-
-        void report_query(const QueryData& in) override {
-            test_run_start();
-            if(opt.list_reporters) {
-                for(auto& curr : getListeners())
-                    xml.scopedElement("Listener")
-                            .writeAttribute("priority", curr.first.first)
-                            .writeAttribute("name", curr.first.second);
-                for(auto& curr : getReporters())
-                    xml.scopedElement("Reporter")
-                            .writeAttribute("priority", curr.first.first)
-                            .writeAttribute("name", curr.first.second);
-            } else if(opt.count || opt.list_test_cases) {
-                for(unsigned i = 0; i < in.num_data; ++i) {
-                    xml.scopedElement("TestCase").writeAttribute("name", in.data[i]->m_name)
-                        .writeAttribute("testsuite", in.data[i]->m_test_suite)
-                        .writeAttribute("filename", skipPathFromFilename(in.data[i]->m_file.c_str()))
-                        .writeAttribute("line", line(in.data[i]->m_line))
-                        .writeAttribute("skipped", in.data[i]->m_skip);
-                }
-                xml.scopedElement("OverallResultsTestCases")
-                        .writeAttribute("unskipped", in.run_stats->numTestCasesPassingFilters);
-            } else if(opt.list_test_suites) {
-                for(unsigned i = 0; i < in.num_data; ++i)
-                    xml.scopedElement("TestSuite").writeAttribute("name", in.data[i]->m_test_suite);
-                xml.scopedElement("OverallResultsTestCases")
-                        .writeAttribute("unskipped", in.run_stats->numTestCasesPassingFilters);
-                xml.scopedElement("OverallResultsTestSuites")
-                        .writeAttribute("unskipped", in.run_stats->numTestSuitesPassingFilters);
-            }
-            xml.endElement();
-        }
-
-        void test_run_start() override {
-            xml.writeDeclaration();
-
-            // remove .exe extension - mainly to have the same output on UNIX and Windows
-            std::string binary_name = skipPathFromFilename(opt.binary_name.c_str());
-#ifdef DOCTEST_PLATFORM_WINDOWS
-            if(binary_name.rfind(".exe") != std::string::npos)
-                binary_name = binary_name.substr(0, binary_name.length() - 4);
-#endif // DOCTEST_PLATFORM_WINDOWS
-
-            xml.startElement("doctest").writeAttribute("binary", binary_name);
-            if(opt.no_version == false)
-                xml.writeAttribute("version", DOCTEST_VERSION_STR);
-
-            // only the consequential ones (TODO: filters)
-            xml.scopedElement("Options")
-                    .writeAttribute("order_by", opt.order_by.c_str())
-                    .writeAttribute("rand_seed", opt.rand_seed)
-                    .writeAttribute("first", opt.first)
-                    .writeAttribute("last", opt.last)
-                    .writeAttribute("abort_after", opt.abort_after)
-                    .writeAttribute("subcase_filter_levels", opt.subcase_filter_levels)
-                    .writeAttribute("case_sensitive", opt.case_sensitive)
-                    .writeAttribute("no_throw", opt.no_throw)
-                    .writeAttribute("no_skip", opt.no_skip);
-        }
-
-        void test_run_end(const TestRunStats& p) override {
-            if(tc) // the TestSuite tag - only if there has been at least 1 test case
-                xml.endElement();
-
-            xml.scopedElement("OverallResultsAsserts")
-                    .writeAttribute("successes", p.numAsserts - p.numAssertsFailed)
-                    .writeAttribute("failures", p.numAssertsFailed);
-
-            xml.startElement("OverallResultsTestCases")
-                    .writeAttribute("successes",
-                                    p.numTestCasesPassingFilters - p.numTestCasesFailed)
-                    .writeAttribute("failures", p.numTestCasesFailed);
-            if(opt.no_skipped_summary == false)
-                xml.writeAttribute("skipped", p.numTestCases - p.numTestCasesPassingFilters);
-            xml.endElement();
-
-            xml.endElement();
-        }
-
-        void test_case_start(const TestCaseData& in) override {
-            test_case_start_impl(in);
-            xml.ensureTagClosed();
-        }
-
-        void test_case_reenter(const TestCaseData&) override {}
-
-        void test_case_end(const CurrentTestCaseStats& st) override {
-            xml.startElement("OverallResultsAsserts")
-                    .writeAttribute("successes",
-                                    st.numAssertsCurrentTest - st.numAssertsFailedCurrentTest)
-                    .writeAttribute("failures", st.numAssertsFailedCurrentTest)
-                    .writeAttribute("test_case_success", st.testCaseSuccess);
-            if(opt.duration)
-                xml.writeAttribute("duration", st.seconds);
-            if(tc->m_expected_failures)
-                xml.writeAttribute("expected_failures", tc->m_expected_failures);
-            xml.endElement();
-
-            xml.endElement();
-        }
-
-        void test_case_exception(const TestCaseException& e) override {
-            DOCTEST_LOCK_MUTEX(mutex)
-
-            xml.scopedElement("Exception")
-                    .writeAttribute("crash", e.is_crash)
-                    .writeText(e.error_string.c_str());
-        }
-
-        void subcase_start(const SubcaseSignature& in) override {
-            xml.startElement("SubCase")
-                    .writeAttribute("name", in.m_name)
-                    .writeAttribute("filename", skipPathFromFilename(in.m_file))
-                    .writeAttribute("line", line(in.m_line));
-            xml.ensureTagClosed();
-        }
-
-        void subcase_end() override { xml.endElement(); }
-
-        void log_assert(const AssertData& rb) override {
-            if(!rb.m_failed && !opt.success)
-                return;
-
-            DOCTEST_LOCK_MUTEX(mutex)
-
-            xml.startElement("Expression")
-                    .writeAttribute("success", !rb.m_failed)
-                    .writeAttribute("type", assertString(rb.m_at))
-                    .writeAttribute("filename", skipPathFromFilename(rb.m_file))
-                    .writeAttribute("line", line(rb.m_line));
-
-            xml.scopedElement("Original").writeText(rb.m_expr);
-
-            if(rb.m_threw)
-                xml.scopedElement("Exception").writeText(rb.m_exception.c_str());
-
-            if(rb.m_at & assertType::is_throws_as)
-                xml.scopedElement("ExpectedException").writeText(rb.m_exception_type);
-            if(rb.m_at & assertType::is_throws_with)
-                xml.scopedElement("ExpectedExceptionString").writeText(rb.m_exception_string.c_str());
-            if((rb.m_at & assertType::is_normal) && !rb.m_threw)
-                xml.scopedElement("Expanded").writeText(rb.m_decomp.c_str());
-
-            log_contexts();
-
-            xml.endElement();
-        }
-
-        void log_message(const MessageData& mb) override {
-            DOCTEST_LOCK_MUTEX(mutex)
-
-            xml.startElement("Message")
-                    .writeAttribute("type", failureString(mb.m_severity))
-                    .writeAttribute("filename", skipPathFromFilename(mb.m_file))
-                    .writeAttribute("line", line(mb.m_line));
-
-            xml.scopedElement("Text").writeText(mb.m_string.c_str());
-
-            log_contexts();
-
-            xml.endElement();
-        }
-
-        void test_case_skipped(const TestCaseData& in) override {
-            if(opt.no_skipped_summary == false) {
-                test_case_start_impl(in);
-                xml.writeAttribute("skipped", "true");
-                xml.endElement();
-            }
-        }
-    };
-
-    DOCTEST_REGISTER_REPORTER("xml", 0, XmlReporter);
-
-    void fulltext_log_assert_to_stream(std::ostream& s, const AssertData& rb) {
-        if((rb.m_at & (assertType::is_throws_as | assertType::is_throws_with)) ==
-            0) //!OCLINT bitwise operator in conditional
-            s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << " ) "
-                << Color::None;
-
-        if(rb.m_at & assertType::is_throws) { //!OCLINT bitwise operator in conditional
-            s << (rb.m_threw ? "threw as expected!" : "did NOT throw at all!") << "\n";
-        } else if((rb.m_at & assertType::is_throws_as) &&
-                    (rb.m_at & assertType::is_throws_with)) { //!OCLINT
-            s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", \""
-                << rb.m_exception_string.c_str()
-                << "\", " << rb.m_exception_type << " ) " << Color::None;
-            if(rb.m_threw) {
-                if(!rb.m_failed) {
-                    s << "threw as expected!\n";
-                } else {
-                    s << "threw a DIFFERENT exception! (contents: " << rb.m_exception << ")\n";
-                }
-            } else {
-                s << "did NOT throw at all!\n";
-            }
-        } else if(rb.m_at &
-                    assertType::is_throws_as) { //!OCLINT bitwise operator in conditional
-            s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", "
-                << rb.m_exception_type << " ) " << Color::None
-                << (rb.m_threw ? (rb.m_threw_as ? "threw as expected!" :
-                                                "threw a DIFFERENT exception: ") :
-                                "did NOT throw at all!")
-                << Color::Cyan << rb.m_exception << "\n";
-        } else if(rb.m_at &
-                    assertType::is_throws_with) { //!OCLINT bitwise operator in conditional
-            s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", \""
-                << rb.m_exception_string.c_str()
-                << "\" ) " << Color::None
-                << (rb.m_threw ? (!rb.m_failed ? "threw as expected!" :
-                                                "threw a DIFFERENT exception: ") :
-                                "did NOT throw at all!")
-                << Color::Cyan << rb.m_exception << "\n";
-        } else if(rb.m_at & assertType::is_nothrow) { //!OCLINT bitwise operator in conditional
-            s << (rb.m_threw ? "THREW exception: " : "didn't throw!") << Color::Cyan
-                << rb.m_exception << "\n";
-        } else {
-            s << (rb.m_threw ? "THREW exception: " :
-                                (!rb.m_failed ? "is correct!\n" : "is NOT correct!\n"));
-            if(rb.m_threw)
-                s << rb.m_exception << "\n";
-            else
-                s << "  values: " << assertString(rb.m_at) << "( " << rb.m_decomp << " )\n";
-        }
-    }
-
-    // TODO:
-    // - log_message()
-    // - respond to queries
-    // - honor remaining options
-    // - more attributes in tags
-    struct JUnitReporter : public IReporter
-    {
-        XmlWriter xml;
-        DOCTEST_DECLARE_MUTEX(mutex)
-        Timer timer;
-        std::vector<String> deepestSubcaseStackNames;
-
-        struct JUnitTestCaseData
-        {
-            static std::string getCurrentTimestamp() {
-                // Beware, this is not reentrant because of backward compatibility issues
-                // Also, UTC only, again because of backward compatibility (%z is C++11)
-                time_t rawtime;
-                std::time(&rawtime);
-                auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-
-                std::tm timeInfo;
-#ifdef DOCTEST_PLATFORM_WINDOWS
-                gmtime_s(&timeInfo, &rawtime);
-#else // DOCTEST_PLATFORM_WINDOWS
-                gmtime_r(&rawtime, &timeInfo);
-#endif // DOCTEST_PLATFORM_WINDOWS
-
-                char timeStamp[timeStampSize];
-                const char* const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-                std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-                return std::string(timeStamp);
-            }
-
-            struct JUnitTestMessage
-            {
-                JUnitTestMessage(const std::string& _message, const std::string& _type, const std::string& _details)
-                    : message(_message), type(_type), details(_details) {}
-
-                JUnitTestMessage(const std::string& _message, const std::string& _details)
-                    : message(_message), type(), details(_details) {}
-
-                std::string message, type, details;
-            };
-
-            struct JUnitTestCase
-            {
-                JUnitTestCase(const std::string& _classname, const std::string& _name)
-                    : classname(_classname), name(_name), time(0), failures() {}
-
-                std::string classname, name;
-                double time;
-                std::vector<JUnitTestMessage> failures, errors;
-            };
-
-            void add(const std::string& classname, const std::string& name) {
-                testcases.emplace_back(classname, name);
-            }
-
-            void appendSubcaseNamesToLastTestcase(std::vector<String> nameStack) {
-                for(auto& curr: nameStack)
-                    if(curr.size())
-                        testcases.back().name += std::string("/") + curr.c_str();
-            }
-
-            void addTime(double time) {
-                if(time < 1e-4)
-                    time = 0;
-                testcases.back().time = time;
-                totalSeconds += time;
-            }
-
-            void addFailure(const std::string& message, const std::string& type, const std::string& details) {
-                testcases.back().failures.emplace_back(message, type, details);
-                ++totalFailures;
-            }
-
-            void addError(const std::string& message, const std::string& details) {
-                testcases.back().errors.emplace_back(message, details);
-                ++totalErrors;
-            }
-
-            std::vector<JUnitTestCase> testcases;
-            double totalSeconds = 0;
-            int totalErrors = 0, totalFailures = 0;
-        };
-
-        JUnitTestCaseData testCaseData;
-
-        // caching pointers/references to objects of these types - safe to do
-        const ContextOptions& opt;
-        const TestCaseData*   tc = nullptr;
-
-        JUnitReporter(const ContextOptions& co)
-                : xml(*co.cout)
-                , opt(co) {}
-
-        unsigned line(unsigned l) const { return opt.no_line_numbers ? 0 : l; }
-
-        // =========================================================================================
-        // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE
-        // =========================================================================================
-
-        void report_query(const QueryData&) override {
-            xml.writeDeclaration();
-        }
-
-        void test_run_start() override {
-            xml.writeDeclaration();
-        }
-
-        void test_run_end(const TestRunStats& p) override {
-            // remove .exe extension - mainly to have the same output on UNIX and Windows
-            std::string binary_name = skipPathFromFilename(opt.binary_name.c_str());
-#ifdef DOCTEST_PLATFORM_WINDOWS
-            if(binary_name.rfind(".exe") != std::string::npos)
-                binary_name = binary_name.substr(0, binary_name.length() - 4);
-#endif // DOCTEST_PLATFORM_WINDOWS
-            xml.startElement("testsuites");
-            xml.startElement("testsuite").writeAttribute("name", binary_name)
-                    .writeAttribute("errors", testCaseData.totalErrors)
-                    .writeAttribute("failures", testCaseData.totalFailures)
-                    .writeAttribute("tests", p.numAsserts);
-            if(opt.no_time_in_output == false) {
-                xml.writeAttribute("time", testCaseData.totalSeconds);
-                xml.writeAttribute("timestamp", JUnitTestCaseData::getCurrentTimestamp());
-            }
-            if(opt.no_version == false)
-                xml.writeAttribute("doctest_version", DOCTEST_VERSION_STR);
-
-            for(const auto& testCase : testCaseData.testcases) {
-                xml.startElement("testcase")
-                    .writeAttribute("classname", testCase.classname)
-                    .writeAttribute("name", testCase.name);
-                if(opt.no_time_in_output == false)
-                    xml.writeAttribute("time", testCase.time);
-                // This is not ideal, but it should be enough to mimic gtest's junit output.
-                xml.writeAttribute("status", "run");
-
-                for(const auto& failure : testCase.failures) {
-                    xml.scopedElement("failure")
-                        .writeAttribute("message", failure.message)
-                        .writeAttribute("type", failure.type)
-                        .writeText(failure.details, false);
-                }
-
-                for(const auto& error : testCase.errors) {
-                    xml.scopedElement("error")
-                        .writeAttribute("message", error.message)
-                        .writeText(error.details);
-                }
-
-                xml.endElement();
-            }
-            xml.endElement();
-            xml.endElement();
-        }
-
-        void test_case_start(const TestCaseData& in) override {
-            testCaseData.add(skipPathFromFilename(in.m_file.c_str()), in.m_name);
-            timer.start();
-        }
-
-        void test_case_reenter(const TestCaseData& in) override {
-            testCaseData.addTime(timer.getElapsedSeconds());
-            testCaseData.appendSubcaseNamesToLastTestcase(deepestSubcaseStackNames);
-            deepestSubcaseStackNames.clear();
-
-            timer.start();
-            testCaseData.add(skipPathFromFilename(in.m_file.c_str()), in.m_name);
-        }
-
-        void test_case_end(const CurrentTestCaseStats&) override {
-            testCaseData.addTime(timer.getElapsedSeconds());
-            testCaseData.appendSubcaseNamesToLastTestcase(deepestSubcaseStackNames);
-            deepestSubcaseStackNames.clear();
-        }
-
-        void test_case_exception(const TestCaseException& e) override {
-            DOCTEST_LOCK_MUTEX(mutex)
-            testCaseData.addError("exception", e.error_string.c_str());
-        }
-
-        void subcase_start(const SubcaseSignature& in) override {
-            deepestSubcaseStackNames.push_back(in.m_name);
-        }
-
-        void subcase_end() override {}
-
-        void log_assert(const AssertData& rb) override {
-            if(!rb.m_failed) // report only failures & ignore the `success` option
-                return;
-
-            DOCTEST_LOCK_MUTEX(mutex)
-
-            std::ostringstream os;
-            os << skipPathFromFilename(rb.m_file) << (opt.gnu_file_line ? ":" : "(")
-              << line(rb.m_line) << (opt.gnu_file_line ? ":" : "):") << std::endl;
-
-            fulltext_log_assert_to_stream(os, rb);
-            log_contexts(os);
-            testCaseData.addFailure(rb.m_decomp.c_str(), assertString(rb.m_at), os.str());
-        }
-
-        void log_message(const MessageData& mb) override {
-            if(mb.m_severity & assertType::is_warn) // report only failures
-                return;
-
-            DOCTEST_LOCK_MUTEX(mutex)
-
-            std::ostringstream os;
-            os << skipPathFromFilename(mb.m_file) << (opt.gnu_file_line ? ":" : "(")
-              << line(mb.m_line) << (opt.gnu_file_line ? ":" : "):") << std::endl;
-
-            os << mb.m_string.c_str() << "\n";
-            log_contexts(os);
-
-            testCaseData.addFailure(mb.m_string.c_str(),
-                mb.m_severity & assertType::is_check ? "FAIL_CHECK" : "FAIL", os.str());
-        }
-
-        void test_case_skipped(const TestCaseData&) override {}
-
-        void log_contexts(std::ostringstream& s) {
-            int num_contexts = get_num_active_contexts();
-            if(num_contexts) {
-                auto contexts = get_active_contexts();
-
-                s << "  logged: ";
-                for(int i = 0; i < num_contexts; ++i) {
-                    s << (i == 0 ? "" : "          ");
-                    contexts[i]->stringify(&s);
-                    s << std::endl;
-                }
-            }
-        }
-    };
-
-    DOCTEST_REGISTER_REPORTER("junit", 0, JUnitReporter);
-
-    struct Whitespace
-    {
-        int nrSpaces;
-        explicit Whitespace(int nr)
-                : nrSpaces(nr) {}
-    };
-
-    std::ostream& operator<<(std::ostream& out, const Whitespace& ws) {
-        if(ws.nrSpaces != 0)
-            out << std::setw(ws.nrSpaces) << ' ';
-        return out;
-    }
-
-    struct ConsoleReporter : public IReporter
-    {
-        std::ostream&                 s;
-        bool                          hasLoggedCurrentTestStart;
-        std::vector<SubcaseSignature> subcasesStack;
-        size_t                        currentSubcaseLevel;
-        DOCTEST_DECLARE_MUTEX(mutex)
-
-        // caching pointers/references to objects of these types - safe to do
-        const ContextOptions& opt;
-        const TestCaseData*   tc;
-
-        ConsoleReporter(const ContextOptions& co)
-                : s(*co.cout)
-                , opt(co) {}
-
-        ConsoleReporter(const ContextOptions& co, std::ostream& ostr)
-                : s(ostr)
-                , opt(co) {}
-
-        // =========================================================================================
-        // WHAT FOLLOWS ARE HELPERS USED BY THE OVERRIDES OF THE VIRTUAL METHODS OF THE INTERFACE
-        // =========================================================================================
-
-        void separator_to_stream() {
-            s << Color::Yellow
-              << "==============================================================================="
-                 "\n";
-        }
-
-        const char* getSuccessOrFailString(bool success, assertType::Enum at,
-                                           const char* success_str) {
-            if(success)
-                return success_str;
-            return failureString(at);
-        }
-
-        Color::Enum getSuccessOrFailColor(bool success, assertType::Enum at) {
-            return success ? Color::BrightGreen :
-                             (at & assertType::is_warn) ? Color::Yellow : Color::Red;
-        }
-
-        void successOrFailColoredStringToStream(bool success, assertType::Enum at,
-                                                const char* success_str = "SUCCESS") {
-            s << getSuccessOrFailColor(success, at)
-              << getSuccessOrFailString(success, at, success_str) << ": ";
-        }
-
-        void log_contexts() {
-            int num_contexts = get_num_active_contexts();
-            if(num_contexts) {
-                auto contexts = get_active_contexts();
-
-                s << Color::None << "  logged: ";
-                for(int i = 0; i < num_contexts; ++i) {
-                    s << (i == 0 ? "" : "          ");
-                    contexts[i]->stringify(&s);
-                    s << "\n";
-                }
-            }
-
-            s << "\n";
-        }
-
-        // this was requested to be made virtual so users could override it
-        virtual void file_line_to_stream(const char* file, int line,
-                                        const char* tail = "") {
-            s << Color::LightGrey << skipPathFromFilename(file) << (opt.gnu_file_line ? ":" : "(")
-            << (opt.no_line_numbers ? 0 : line) // 0 or the real num depending on the option
-            << (opt.gnu_file_line ? ":" : "):") << tail;
-        }
-
-        void logTestStart() {
-            if(hasLoggedCurrentTestStart)
-                return;
-
-            separator_to_stream();
-            file_line_to_stream(tc->m_file.c_str(), tc->m_line, "\n");
-            if(tc->m_description)
-                s << Color::Yellow << "DESCRIPTION: " << Color::None << tc->m_description << "\n";
-            if(tc->m_test_suite && tc->m_test_suite[0] != '\0')
-                s << Color::Yellow << "TEST SUITE: " << Color::None << tc->m_test_suite << "\n";
-            if(strncmp(tc->m_name, "  Scenario:", 11) != 0)
-                s << Color::Yellow << "TEST CASE:  ";
-            s << Color::None << tc->m_name << "\n";
-
-            for(size_t i = 0; i < currentSubcaseLevel; ++i) {
-                if(subcasesStack[i].m_name[0] != '\0')
-                    s << "  " << subcasesStack[i].m_name << "\n";
-            }
-
-            if(currentSubcaseLevel != subcasesStack.size()) {
-                s << Color::Yellow << "\nDEEPEST SUBCASE STACK REACHED (DIFFERENT FROM THE CURRENT ONE):\n" << Color::None;
-                for(size_t i = 0; i < subcasesStack.size(); ++i) {
-                    if(subcasesStack[i].m_name[0] != '\0')
-                        s << "  " << subcasesStack[i].m_name << "\n";
-                }
-            }
-
-            s << "\n";
-
-            hasLoggedCurrentTestStart = true;
-        }
-
-        void printVersion() {
-            if(opt.no_version == false)
-                s << Color::Cyan << "[doctest] " << Color::None << "doctest version is \""
-                  << DOCTEST_VERSION_STR << "\"\n";
-        }
-
-        void printIntro() {
-            if(opt.no_intro == false) {
-                printVersion();
-                s << Color::Cyan << "[doctest] " << Color::None
-                  << "run with \"--" DOCTEST_OPTIONS_PREFIX_DISPLAY "help\" for options\n";
-            }
-        }
-
-        void printHelp() {
-            int sizePrefixDisplay = static_cast<int>(strlen(DOCTEST_OPTIONS_PREFIX_DISPLAY));
-            printVersion();
-            // clang-format off
-            s << Color::Cyan << "[doctest]\n" << Color::None;
-            s << Color::Cyan << "[doctest] " << Color::None;
-            s << "boolean values: \"1/on/yes/true\" or \"0/off/no/false\"\n";
-            s << Color::Cyan << "[doctest] " << Color::None;
-            s << "filter  values: \"str1,str2,str3\" (comma separated strings)\n";
-            s << Color::Cyan << "[doctest]\n" << Color::None;
-            s << Color::Cyan << "[doctest] " << Color::None;
-            s << "filters use wildcards for matching strings\n";
-            s << Color::Cyan << "[doctest] " << Color::None;
-            s << "something passes a filter if any of the strings in a filter matches\n";
-#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
-            s << Color::Cyan << "[doctest]\n" << Color::None;
-            s << Color::Cyan << "[doctest] " << Color::None;
-            s << "ALL FLAGS, OPTIONS AND FILTERS ALSO AVAILABLE WITH A \"" DOCTEST_CONFIG_OPTIONS_PREFIX "\" PREFIX!!!\n";
-#endif
-            s << Color::Cyan << "[doctest]\n" << Color::None;
-            s << Color::Cyan << "[doctest] " << Color::None;
-            s << "Query flags - the program quits after them. Available:\n\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "?,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "help, -" DOCTEST_OPTIONS_PREFIX_DISPLAY "h                      "
-              << Whitespace(sizePrefixDisplay*0) <<  "prints this message\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "v,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "version                       "
-              << Whitespace(sizePrefixDisplay*1) << "prints the version\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "c,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "count                         "
-              << Whitespace(sizePrefixDisplay*1) << "prints the number of matching tests\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ltc, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-test-cases               "
-              << Whitespace(sizePrefixDisplay*1) << "lists all matching tests by name\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "lts, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-test-suites              "
-              << Whitespace(sizePrefixDisplay*1) << "lists all matching test suites\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "lr,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-reporters                "
-              << Whitespace(sizePrefixDisplay*1) << "lists all registered reporters\n\n";
-            // ================================================================================== << 79
-            s << Color::Cyan << "[doctest] " << Color::None;
-            s << "The available <int>/<string> options/filters are:\n\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tc,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-case=<filters>           "
-              << Whitespace(sizePrefixDisplay*1) << "filters     tests by their name\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tce, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-case-exclude=<filters>   "
-              << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their name\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sf,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "source-file=<filters>         "
-              << Whitespace(sizePrefixDisplay*1) << "filters     tests by their file\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sfe, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "source-file-exclude=<filters> "
-              << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their file\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ts,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-suite=<filters>          "
-              << Whitespace(sizePrefixDisplay*1) << "filters     tests by their test suite\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tse, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-suite-exclude=<filters>  "
-              << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their test suite\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sc,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase=<filters>             "
-              << Whitespace(sizePrefixDisplay*1) << "filters     subcases by their name\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sce, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase-exclude=<filters>     "
-              << Whitespace(sizePrefixDisplay*1) << "filters OUT subcases by their name\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "r,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "reporters=<filters>           "
-              << Whitespace(sizePrefixDisplay*1) << "reporters to use (console is default)\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "o,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "out=<string>                  "
-              << Whitespace(sizePrefixDisplay*1) << "output filename\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ob,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "order-by=<string>             "
-              << Whitespace(sizePrefixDisplay*1) << "how the tests should be ordered\n";
-            s << Whitespace(sizePrefixDisplay*3) << "                                       <string> - [file/suite/name/rand/none]\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "rs,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "rand-seed=<int>               "
-              << Whitespace(sizePrefixDisplay*1) << "seed for random ordering\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "f,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "first=<int>                   "
-              << Whitespace(sizePrefixDisplay*1) << "the first test passing the filters to\n";
-            s << Whitespace(sizePrefixDisplay*3) << "                                       execute - for range-based execution\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "l,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "last=<int>                    "
-              << Whitespace(sizePrefixDisplay*1) << "the last test passing the filters to\n";
-            s << Whitespace(sizePrefixDisplay*3) << "                                       execute - for range-based execution\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "aa,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "abort-after=<int>             "
-              << Whitespace(sizePrefixDisplay*1) << "stop after <int> failed assertions\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "scfl,--" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase-filter-levels=<int>   "
-              << Whitespace(sizePrefixDisplay*1) << "apply filters for the first <int> levels\n";
-            s << Color::Cyan << "\n[doctest] " << Color::None;
-            s << "Bool options - can be used like flags and true is assumed. Available:\n\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "s,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "success=<bool>                "
-              << Whitespace(sizePrefixDisplay*1) << "include successful assertions in output\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "cs,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "case-sensitive=<bool>         "
-              << Whitespace(sizePrefixDisplay*1) << "filters being treated as case sensitive\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "e,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "exit=<bool>                   "
-              << Whitespace(sizePrefixDisplay*1) << "exits after the tests finish\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "d,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "duration=<bool>               "
-              << Whitespace(sizePrefixDisplay*1) << "prints the time duration of each test\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "m,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "minimal=<bool>                "
-              << Whitespace(sizePrefixDisplay*1) << "minimal console output (only failures)\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "q,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "quiet=<bool>                  "
-              << Whitespace(sizePrefixDisplay*1) << "no console output\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nt,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-throw=<bool>               "
-              << Whitespace(sizePrefixDisplay*1) << "skips exceptions-related assert checks\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ne,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-exitcode=<bool>            "
-              << Whitespace(sizePrefixDisplay*1) << "returns (or exits) always with success\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nr,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-run=<bool>                 "
-              << Whitespace(sizePrefixDisplay*1) << "skips all runtime doctest operations\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ni,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-intro=<bool>               "
-              << Whitespace(sizePrefixDisplay*1) << "omit the framework intro in the output\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nv,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-version=<bool>             "
-              << Whitespace(sizePrefixDisplay*1) << "omit the framework version in the output\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nc,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-colors=<bool>              "
-              << Whitespace(sizePrefixDisplay*1) << "disables colors in output\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "fc,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "force-colors=<bool>           "
-              << Whitespace(sizePrefixDisplay*1) << "use colors even when not in a tty\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nb,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-breaks=<bool>              "
-              << Whitespace(sizePrefixDisplay*1) << "disables breakpoints in debuggers\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ns,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-skip=<bool>                "
-              << Whitespace(sizePrefixDisplay*1) << "don't skip test cases marked as skip\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "gfl, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "gnu-file-line=<bool>          "
-              << Whitespace(sizePrefixDisplay*1) << ":n: vs (n): for line numbers in output\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "npf, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-path-filenames=<bool>      "
-              << Whitespace(sizePrefixDisplay*1) << "only filenames and no paths in output\n";
-            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nln, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-line-numbers=<bool>        "
-              << Whitespace(sizePrefixDisplay*1) << "0 instead of real line numbers in output\n";
-            // ================================================================================== << 79
-            // clang-format on
-
-            s << Color::Cyan << "\n[doctest] " << Color::None;
-            s << "for more information visit the project documentation\n\n";
-        }
-
-        void printRegisteredReporters() {
-            printVersion();
-            auto printReporters = [this] (const reporterMap& reporters, const char* type) {
-                if(reporters.size()) {
-                    s << Color::Cyan << "[doctest] " << Color::None << "listing all registered " << type << "\n";
-                    for(auto& curr : reporters)
-                        s << "priority: " << std::setw(5) << curr.first.first
-                          << " name: " << curr.first.second << "\n";
-                }
-            };
-            printReporters(getListeners(), "listeners");
-            printReporters(getReporters(), "reporters");
-        }
-
-        // =========================================================================================
-        // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE
-        // =========================================================================================
-
-        void report_query(const QueryData& in) override {
-            if(opt.version) {
-                printVersion();
-            } else if(opt.help) {
-                printHelp();
-            } else if(opt.list_reporters) {
-                printRegisteredReporters();
-            } else if(opt.count || opt.list_test_cases) {
-                if(opt.list_test_cases) {
-                    s << Color::Cyan << "[doctest] " << Color::None
-                      << "listing all test case names\n";
-                    separator_to_stream();
-                }
-
-                for(unsigned i = 0; i < in.num_data; ++i)
-                    s << Color::None << in.data[i]->m_name << "\n";
-
-                separator_to_stream();
-
-                s << Color::Cyan << "[doctest] " << Color::None
-                  << "unskipped test cases passing the current filters: "
-                  << g_cs->numTestCasesPassingFilters << "\n";
-
-            } else if(opt.list_test_suites) {
-                s << Color::Cyan << "[doctest] " << Color::None << "listing all test suites\n";
-                separator_to_stream();
-
-                for(unsigned i = 0; i < in.num_data; ++i)
-                    s << Color::None << in.data[i]->m_test_suite << "\n";
-
-                separator_to_stream();
-
-                s << Color::Cyan << "[doctest] " << Color::None
-                  << "unskipped test cases passing the current filters: "
-                  << g_cs->numTestCasesPassingFilters << "\n";
-                s << Color::Cyan << "[doctest] " << Color::None
-                  << "test suites with unskipped test cases passing the current filters: "
-                  << g_cs->numTestSuitesPassingFilters << "\n";
-            }
-        }
-
-        void test_run_start() override {
-            if(!opt.minimal)
-                printIntro();
-        }
-
-        void test_run_end(const TestRunStats& p) override {
-            if(opt.minimal && p.numTestCasesFailed == 0)
-                return;
-
-            separator_to_stream();
-            s << std::dec;
-
-            auto totwidth = int(std::ceil(log10(static_cast<double>(std::max(p.numTestCasesPassingFilters, static_cast<unsigned>(p.numAsserts))) + 1)));
-            auto passwidth = int(std::ceil(log10(static_cast<double>(std::max(p.numTestCasesPassingFilters - p.numTestCasesFailed, static_cast<unsigned>(p.numAsserts - p.numAssertsFailed))) + 1)));
-            auto failwidth = int(std::ceil(log10(static_cast<double>(std::max(p.numTestCasesFailed, static_cast<unsigned>(p.numAssertsFailed))) + 1)));
-            const bool anythingFailed = p.numTestCasesFailed > 0 || p.numAssertsFailed > 0;
-            s << Color::Cyan << "[doctest] " << Color::None << "test cases: " << std::setw(totwidth)
-              << p.numTestCasesPassingFilters << " | "
-              << ((p.numTestCasesPassingFilters == 0 || anythingFailed) ? Color::None :
-                                                                          Color::Green)
-              << std::setw(passwidth) << p.numTestCasesPassingFilters - p.numTestCasesFailed << " passed"
-              << Color::None << " | " << (p.numTestCasesFailed > 0 ? Color::Red : Color::None)
-              << std::setw(failwidth) << p.numTestCasesFailed << " failed" << Color::None << " |";
-            if(opt.no_skipped_summary == false) {
-                const int numSkipped = p.numTestCases - p.numTestCasesPassingFilters;
-                s << " " << (numSkipped == 0 ? Color::None : Color::Yellow) << numSkipped
-                  << " skipped" << Color::None;
-            }
-            s << "\n";
-            s << Color::Cyan << "[doctest] " << Color::None << "assertions: " << std::setw(totwidth)
-              << p.numAsserts << " | "
-              << ((p.numAsserts == 0 || anythingFailed) ? Color::None : Color::Green)
-              << std::setw(passwidth) << (p.numAsserts - p.numAssertsFailed) << " passed" << Color::None
-              << " | " << (p.numAssertsFailed > 0 ? Color::Red : Color::None) << std::setw(failwidth)
-              << p.numAssertsFailed << " failed" << Color::None << " |\n";
-            s << Color::Cyan << "[doctest] " << Color::None
-              << "Status: " << (p.numTestCasesFailed > 0 ? Color::Red : Color::Green)
-              << ((p.numTestCasesFailed > 0) ? "FAILURE!" : "SUCCESS!") << Color::None << std::endl;
-        }
-
-        void test_case_start(const TestCaseData& in) override {
-            hasLoggedCurrentTestStart = false;
-            tc                        = &in;
-            subcasesStack.clear();
-            currentSubcaseLevel = 0;
-        }
-
-        void test_case_reenter(const TestCaseData&) override {
-            subcasesStack.clear();
-        }
-
-        void test_case_end(const CurrentTestCaseStats& st) override {
-            if(tc->m_no_output)
-                return;
-
-            // log the preamble of the test case only if there is something
-            // else to print - something other than that an assert has failed
-            if(opt.duration ||
-               (st.failure_flags && st.failure_flags != static_cast<int>(TestCaseFailureReason::AssertFailure)))
-                logTestStart();
-
-            if(opt.duration)
-                s << Color::None << std::setprecision(6) << std::fixed << st.seconds
-                  << " s: " << tc->m_name << "\n";
-
-            if(st.failure_flags & TestCaseFailureReason::Timeout)
-                s << Color::Red << "Test case exceeded time limit of " << std::setprecision(6)
-                  << std::fixed << tc->m_timeout << "!\n";
-
-            if(st.failure_flags & TestCaseFailureReason::ShouldHaveFailedButDidnt) {
-                s << Color::Red << "Should have failed but didn't! Marking it as failed!\n";
-            } else if(st.failure_flags & TestCaseFailureReason::ShouldHaveFailedAndDid) {
-                s << Color::Yellow << "Failed as expected so marking it as not failed\n";
-            } else if(st.failure_flags & TestCaseFailureReason::CouldHaveFailedAndDid) {
-                s << Color::Yellow << "Allowed to fail so marking it as not failed\n";
-            } else if(st.failure_flags & TestCaseFailureReason::DidntFailExactlyNumTimes) {
-                s << Color::Red << "Didn't fail exactly " << tc->m_expected_failures
-                  << " times so marking it as failed!\n";
-            } else if(st.failure_flags & TestCaseFailureReason::FailedExactlyNumTimes) {
-                s << Color::Yellow << "Failed exactly " << tc->m_expected_failures
-                  << " times as expected so marking it as not failed!\n";
-            }
-            if(st.failure_flags & TestCaseFailureReason::TooManyFailedAsserts) {
-                s << Color::Red << "Aborting - too many failed asserts!\n";
-            }
-            s << Color::None; // lgtm [cpp/useless-expression]
-        }
-
-        void test_case_exception(const TestCaseException& e) override {
-            DOCTEST_LOCK_MUTEX(mutex)
-            if(tc->m_no_output)
-                return;
-
-            logTestStart();
-
-            file_line_to_stream(tc->m_file.c_str(), tc->m_line, " ");
-            successOrFailColoredStringToStream(false, e.is_crash ? assertType::is_require :
-                                                                   assertType::is_check);
-            s << Color::Red << (e.is_crash ? "test case CRASHED: " : "test case THREW exception: ")
-              << Color::Cyan << e.error_string << "\n";
-
-            int num_stringified_contexts = get_num_stringified_contexts();
-            if(num_stringified_contexts) {
-                auto stringified_contexts = get_stringified_contexts();
-                s << Color::None << "  logged: ";
-                for(int i = num_stringified_contexts; i > 0; --i) {
-                    s << (i == num_stringified_contexts ? "" : "          ")
-                      << stringified_contexts[i - 1] << "\n";
-                }
-            }
-            s << "\n" << Color::None;
-        }
-
-        void subcase_start(const SubcaseSignature& subc) override {
-            subcasesStack.push_back(subc);
-            ++currentSubcaseLevel;
-            hasLoggedCurrentTestStart = false;
-        }
-
-        void subcase_end() override {
-            --currentSubcaseLevel;
-            hasLoggedCurrentTestStart = false;
-        }
-
-        void log_assert(const AssertData& rb) override {
-            if((!rb.m_failed && !opt.success) || tc->m_no_output)
-                return;
-
-            DOCTEST_LOCK_MUTEX(mutex)
-
-            logTestStart();
-
-            file_line_to_stream(rb.m_file, rb.m_line, " ");
-            successOrFailColoredStringToStream(!rb.m_failed, rb.m_at);
-
-            fulltext_log_assert_to_stream(s, rb);
-
-            log_contexts();
-        }
-
-        void log_message(const MessageData& mb) override {
-            if(tc->m_no_output)
-                return;
-
-            DOCTEST_LOCK_MUTEX(mutex)
-
-            logTestStart();
-
-            file_line_to_stream(mb.m_file, mb.m_line, " ");
-            s << getSuccessOrFailColor(false, mb.m_severity)
-              << getSuccessOrFailString(mb.m_severity & assertType::is_warn, mb.m_severity,
-                                        "MESSAGE") << ": ";
-            s << Color::None << mb.m_string << "\n";
-            log_contexts();
-        }
-
-        void test_case_skipped(const TestCaseData&) override {}
-    };
-
-    DOCTEST_REGISTER_REPORTER("console", 0, ConsoleReporter);
-
-#ifdef DOCTEST_PLATFORM_WINDOWS
-    struct DebugOutputWindowReporter : public ConsoleReporter
-    {
-        DOCTEST_THREAD_LOCAL static std::ostringstream oss;
-
-        DebugOutputWindowReporter(const ContextOptions& co)
-                : ConsoleReporter(co, oss) {}
-
-#define DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(func, type, arg)                                    \
-    void func(type arg) override {                                                                 \
-        bool with_col = g_no_colors;                                                               \
-        g_no_colors   = false;                                                                     \
-        ConsoleReporter::func(arg);                                                                \
-        if(oss.tellp() != std::streampos{}) {                                                      \
-            DOCTEST_OUTPUT_DEBUG_STRING(oss.str().c_str());                                        \
-            oss.str("");                                                                           \
-        }                                                                                          \
-        g_no_colors = with_col;                                                                    \
-    }
-
-        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_run_start, DOCTEST_EMPTY, DOCTEST_EMPTY)
-        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_run_end, const TestRunStats&, in)
-        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_start, const TestCaseData&, in)
-        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_reenter, const TestCaseData&, in)
-        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_end, const CurrentTestCaseStats&, in)
-        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_exception, const TestCaseException&, in)
-        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(subcase_start, const SubcaseSignature&, in)
-        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(subcase_end, DOCTEST_EMPTY, DOCTEST_EMPTY)
-        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(log_assert, const AssertData&, in)
-        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(log_message, const MessageData&, in)
-        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_skipped, const TestCaseData&, in)
-    };
-
-    DOCTEST_THREAD_LOCAL std::ostringstream DebugOutputWindowReporter::oss;
-#endif // DOCTEST_PLATFORM_WINDOWS
-
-    // the implementation of parseOption()
-    bool parseOptionImpl(int argc, const char* const* argv, const char* pattern, String* value) {
-        // going from the end to the beginning and stopping on the first occurrence from the end
-        for(int i = argc; i > 0; --i) {
-            auto index = i - 1;
-            auto temp = std::strstr(argv[index], pattern);
-            if(temp && (value || strlen(temp) == strlen(pattern))) { //!OCLINT prefer early exits and continue
-                // eliminate matches in which the chars before the option are not '-'
-                bool noBadCharsFound = true;
-                auto curr            = argv[index];
-                while(curr != temp) {
-                    if(*curr++ != '-') {
-                        noBadCharsFound = false;
-                        break;
-                    }
-                }
-                if(noBadCharsFound && argv[index][0] == '-') {
-                    if(value) {
-                        // parsing the value of an option
-                        temp += strlen(pattern);
-                        const unsigned len = strlen(temp);
-                        if(len) {
-                            *value = temp;
-                            return true;
-                        }
-                    } else {
-                        // just a flag - no value
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
-
-    // parses an option and returns the string after the '=' character
-    bool parseOption(int argc, const char* const* argv, const char* pattern, String* value = nullptr,
-                     const String& defaultVal = String()) {
-        if(value)
-            *value = defaultVal;
-#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
-        // offset (normally 3 for "dt-") to skip prefix
-        if(parseOptionImpl(argc, argv, pattern + strlen(DOCTEST_CONFIG_OPTIONS_PREFIX), value))
-            return true;
-#endif // DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
-        return parseOptionImpl(argc, argv, pattern, value);
-    }
-
-    // locates a flag on the command line
-    bool parseFlag(int argc, const char* const* argv, const char* pattern) {
-        return parseOption(argc, argv, pattern);
-    }
-
-    // parses a comma separated list of words after a pattern in one of the arguments in argv
-    bool parseCommaSepArgs(int argc, const char* const* argv, const char* pattern,
-                           std::vector<String>& res) {
-        String filtersString;
-        if(parseOption(argc, argv, pattern, &filtersString)) {
-            // tokenize with "," as a separator, unless escaped with backslash
-            std::ostringstream s;
-            auto flush = [&s, &res]() {
-                auto string = s.str();
-                if(string.size() > 0) {
-                    res.push_back(string.c_str());
-                }
-                s.str("");
-            };
-
-            bool seenBackslash = false;
-            const char* current = filtersString.c_str();
-            const char* end = current + strlen(current);
-            while(current != end) {
-                char character = *current++;
-                if(seenBackslash) {
-                    seenBackslash = false;
-                    if(character == ',' || character == '\\') {
-                        s.put(character);
-                        continue;
-                    }
-                    s.put('\\');
-                }
-                if(character == '\\') {
-                    seenBackslash = true;
-                } else if(character == ',') {
-                    flush();
-                } else {
-                    s.put(character);
-                }
-            }
-
-            if(seenBackslash) {
-                s.put('\\');
-            }
-            flush();
-            return true;
-        }
-        return false;
-    }
-
-    enum optionType
-    {
-        option_bool,
-        option_int
-    };
-
-    // parses an int/bool option from the command line
-    bool parseIntOption(int argc, const char* const* argv, const char* pattern, optionType type,
-                        int& res) {
-        String parsedValue;
-        if(!parseOption(argc, argv, pattern, &parsedValue))
-            return false;
-
-        if(type) {
-            // integer
-            // TODO: change this to use std::stoi or something else! currently it uses undefined behavior - assumes '0' on failed parse...
-            int theInt = std::atoi(parsedValue.c_str());
-            if (theInt != 0) {
-                res = theInt; //!OCLINT parameter reassignment
-                return true;
-            }
-        } else {
-            // boolean
-            const char positive[][5] = { "1", "true", "on", "yes" };  // 5 - strlen("true") + 1
-            const char negative[][6] = { "0", "false", "off", "no" }; // 6 - strlen("false") + 1
-
-            // if the value matches any of the positive/negative possibilities
-            for (unsigned i = 0; i < 4; i++) {
-                if (parsedValue.compare(positive[i], true) == 0) {
-                    res = 1; //!OCLINT parameter reassignment
-                    return true;
-                }
-                if (parsedValue.compare(negative[i], true) == 0) {
-                    res = 0; //!OCLINT parameter reassignment
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-} // namespace
-
-Context::Context(int argc, const char* const* argv)
-        : p(new detail::ContextState) {
-    parseArgs(argc, argv, true);
-    if(argc)
-        p->binary_name = argv[0];
-}
-
-Context::~Context() {
-    if(g_cs == p)
-        g_cs = nullptr;
-    delete p;
-}
-
-void Context::applyCommandLine(int argc, const char* const* argv) {
-    parseArgs(argc, argv);
-    if(argc)
-        p->binary_name = argv[0];
-}
-
-// parses args
-void Context::parseArgs(int argc, const char* const* argv, bool withDefaults) {
-    using namespace detail;
-
-    // clang-format off
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "source-file=",        p->filters[0]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sf=",                 p->filters[0]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "source-file-exclude=",p->filters[1]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sfe=",                p->filters[1]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-suite=",         p->filters[2]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "ts=",                 p->filters[2]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-suite-exclude=", p->filters[3]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tse=",                p->filters[3]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-case=",          p->filters[4]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tc=",                 p->filters[4]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-case-exclude=",  p->filters[5]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tce=",                p->filters[5]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "subcase=",            p->filters[6]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sc=",                 p->filters[6]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "subcase-exclude=",    p->filters[7]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sce=",                p->filters[7]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "reporters=",          p->filters[8]);
-    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "r=",                  p->filters[8]);
-    // clang-format on
-
-    int    intRes = 0;
-    String strRes;
-
-#define DOCTEST_PARSE_AS_BOOL_OR_FLAG(name, sname, var, default)                                   \
-    if(parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", option_bool, intRes) ||  \
-       parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", option_bool, intRes))   \
-        p->var = static_cast<bool>(intRes);                                                        \
-    else if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name) ||                           \
-            parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname))                            \
-        p->var = true;                                                                             \
-    else if(withDefaults)                                                                          \
-    p->var = default
-
-#define DOCTEST_PARSE_INT_OPTION(name, sname, var, default)                                        \
-    if(parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", option_int, intRes) ||   \
-       parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", option_int, intRes))    \
-        p->var = intRes;                                                                           \
-    else if(withDefaults)                                                                          \
-    p->var = default
-
-#define DOCTEST_PARSE_STR_OPTION(name, sname, var, default)                                        \
-    if(parseOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", &strRes, default) ||        \
-       parseOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", &strRes, default) ||       \
-       withDefaults)                                                                               \
-    p->var = strRes
-
-    // clang-format off
-    DOCTEST_PARSE_STR_OPTION("out", "o", out, "");
-    DOCTEST_PARSE_STR_OPTION("order-by", "ob", order_by, "file");
-    DOCTEST_PARSE_INT_OPTION("rand-seed", "rs", rand_seed, 0);
-
-    DOCTEST_PARSE_INT_OPTION("first", "f", first, 0);
-    DOCTEST_PARSE_INT_OPTION("last", "l", last, UINT_MAX);
-
-    DOCTEST_PARSE_INT_OPTION("abort-after", "aa", abort_after, 0);
-    DOCTEST_PARSE_INT_OPTION("subcase-filter-levels", "scfl", subcase_filter_levels, INT_MAX);
-
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("success", "s", success, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("case-sensitive", "cs", case_sensitive, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("exit", "e", exit, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("duration", "d", duration, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("minimal", "m", minimal, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("quiet", "q", quiet, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-throw", "nt", no_throw, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-exitcode", "ne", no_exitcode, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-run", "nr", no_run, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-intro", "ni", no_intro, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-version", "nv", no_version, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-colors", "nc", no_colors, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("force-colors", "fc", force_colors, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-breaks", "nb", no_breaks, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-skip", "ns", no_skip, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("gnu-file-line", "gfl", gnu_file_line, !bool(DOCTEST_MSVC));
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-path-filenames", "npf", no_path_in_filenames, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-line-numbers", "nln", no_line_numbers, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-debug-output", "ndo", no_debug_output, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-skipped-summary", "nss", no_skipped_summary, false);
-    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-time-in-output", "ntio", no_time_in_output, false);
-    // clang-format on
-
-    if(withDefaults) {
-        p->help             = false;
-        p->version          = false;
-        p->count            = false;
-        p->list_test_cases  = false;
-        p->list_test_suites = false;
-        p->list_reporters   = false;
-    }
-    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "help") ||
-       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "h") ||
-       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "?")) {
-        p->help = true;
-        p->exit = true;
-    }
-    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "version") ||
-       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "v")) {
-        p->version = true;
-        p->exit    = true;
-    }
-    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "count") ||
-       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "c")) {
-        p->count = true;
-        p->exit  = true;
-    }
-    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-test-cases") ||
-       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "ltc")) {
-        p->list_test_cases = true;
-        p->exit            = true;
-    }
-    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-test-suites") ||
-       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "lts")) {
-        p->list_test_suites = true;
-        p->exit             = true;
-    }
-    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-reporters") ||
-       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "lr")) {
-        p->list_reporters = true;
-        p->exit           = true;
-    }
-}
-
-// allows the user to add procedurally to the filters from the command line
-void Context::addFilter(const char* filter, const char* value) { setOption(filter, value); }
-
-// allows the user to clear all filters from the command line
-void Context::clearFilters() {
-    for(auto& curr : p->filters)
-        curr.clear();
-}
-
-// allows the user to override procedurally the bool options from the command line
-void Context::setOption(const char* option, bool value) {
-    setOption(option, value ? "true" : "false");
-}
-
-// allows the user to override procedurally the int options from the command line
-void Context::setOption(const char* option, int value) {
-    setOption(option, toString(value).c_str());
-}
-
-// allows the user to override procedurally the string options from the command line
-void Context::setOption(const char* option, const char* value) {
-    auto argv   = String("-") + option + "=" + value;
-    auto lvalue = argv.c_str();
-    parseArgs(1, &lvalue);
-}
-
-// users should query this in their main() and exit the program if true
-bool Context::shouldExit() { return p->exit; }
-
-void Context::setAsDefaultForAssertsOutOfTestCases() { g_cs = p; }
-
-void Context::setAssertHandler(detail::assert_handler ah) { p->ah = ah; }
-
-void Context::setCout(std::ostream* out) { p->cout = out; }
-
-static class DiscardOStream : public std::ostream
-{
-private:
-    class : public std::streambuf
-    {
-    private:
-        // allowing some buffering decreases the amount of calls to overflow
-        char buf[1024];
-
-    protected:
-        std::streamsize xsputn(const char_type*, std::streamsize count) override { return count; }
-
-        int_type overflow(int_type ch) override {
-            setp(std::begin(buf), std::end(buf));
-            return traits_type::not_eof(ch);
-        }
-    } discardBuf;
-
-public:
-    DiscardOStream()
-            : std::ostream(&discardBuf) {}
-} discardOut;
-
-// the main function that does all the filtering and test running
-int Context::run() {
-    using namespace detail;
-
-    // save the old context state in case such was setup - for using asserts out of a testing context
-    auto old_cs = g_cs;
-    // this is the current contest
-    g_cs               = p;
-    is_running_in_test = true;
-
-    g_no_colors = p->no_colors;
-    p->resetRunData();
-
-    std::fstream fstr;
-    if(p->cout == nullptr) {
-        if(p->quiet) {
-            p->cout = &discardOut;
-        } else if(p->out.size()) {
-            // to a file if specified
-            fstr.open(p->out.c_str(), std::fstream::out);
-            p->cout = &fstr;
-        } else {
-#ifndef DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
-            // stdout by default
-            p->cout = &std::cout;
-#else // DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
-            return EXIT_FAILURE;
-#endif // DOCTEST_CONFIG_NO_INCLUDE_IOSTREAM
-        }
-    }
-
-    FatalConditionHandler::allocateAltStackMem();
-
-    auto cleanup_and_return = [&]() {
-        FatalConditionHandler::freeAltStackMem();
-
-        if(fstr.is_open())
-            fstr.close();
-
-        // restore context
-        g_cs               = old_cs;
-        is_running_in_test = false;
-
-        // we have to free the reporters which were allocated when the run started
-        for(auto& curr : p->reporters_currently_used)
-            delete curr;
-        p->reporters_currently_used.clear();
-
-        if(p->numTestCasesFailed && !p->no_exitcode)
-            return EXIT_FAILURE;
-        return EXIT_SUCCESS;
-    };
-
-    // setup default reporter if none is given through the command line
-    if(p->filters[8].empty())
-        p->filters[8].push_back("console");
-
-    // check to see if any of the registered reporters has been selected
-    for(auto& curr : getReporters()) {
-        if(matchesAny(curr.first.second.c_str(), p->filters[8], false, p->case_sensitive))
-            p->reporters_currently_used.push_back(curr.second(*g_cs));
-    }
-
-    // TODO: check if there is nothing in reporters_currently_used
-
-    // prepend all listeners
-    for(auto& curr : getListeners())
-        p->reporters_currently_used.insert(p->reporters_currently_used.begin(), curr.second(*g_cs));
-
-#ifdef DOCTEST_PLATFORM_WINDOWS
-    if(isDebuggerActive() && p->no_debug_output == false)
-        p->reporters_currently_used.push_back(new DebugOutputWindowReporter(*g_cs));
-#endif // DOCTEST_PLATFORM_WINDOWS
-
-    // handle version, help and no_run
-    if(p->no_run || p->version || p->help || p->list_reporters) {
-        DOCTEST_ITERATE_THROUGH_REPORTERS(report_query, QueryData());
-
-        return cleanup_and_return();
-    }
-
-    std::vector<const TestCase*> testArray;
-    for(auto& curr : getRegisteredTests())
-        testArray.push_back(&curr);
-    p->numTestCases = testArray.size();
-
-    // sort the collected records
-    if(!testArray.empty()) {
-        if(p->order_by.compare("file", true) == 0) {
-            std::sort(testArray.begin(), testArray.end(), fileOrderComparator);
-        } else if(p->order_by.compare("suite", true) == 0) {
-            std::sort(testArray.begin(), testArray.end(), suiteOrderComparator);
-        } else if(p->order_by.compare("name", true) == 0) {
-            std::sort(testArray.begin(), testArray.end(), nameOrderComparator);
-        } else if(p->order_by.compare("rand", true) == 0) {
-            std::srand(p->rand_seed);
-
-            // random_shuffle implementation
-            const auto first = &testArray[0];
-            for(size_t i = testArray.size() - 1; i > 0; --i) {
-                int idxToSwap = std::rand() % (i + 1);
-
-                const auto temp = first[i];
-
-                first[i]         = first[idxToSwap];
-                first[idxToSwap] = temp;
-            }
-        } else if(p->order_by.compare("none", true) == 0) {
-            // means no sorting - beneficial for death tests which call into the executable
-            // with a specific test case in mind - we don't want to slow down the startup times
-        }
-    }
-
-    std::set<String> testSuitesPassingFilt;
-
-    bool                             query_mode = p->count || p->list_test_cases || p->list_test_suites;
-    std::vector<const TestCaseData*> queryResults;
-
-    if(!query_mode)
-        DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_start, DOCTEST_EMPTY);
-
-    // invoke the registered functions if they match the filter criteria (or just count them)
-    for(auto& curr : testArray) {
-        const auto& tc = *curr;
-
-        bool skip_me = false;
-        if(tc.m_skip && !p->no_skip)
-            skip_me = true;
-
-        if(!matchesAny(tc.m_file.c_str(), p->filters[0], true, p->case_sensitive))
-            skip_me = true;
-        if(matchesAny(tc.m_file.c_str(), p->filters[1], false, p->case_sensitive))
-            skip_me = true;
-        if(!matchesAny(tc.m_test_suite, p->filters[2], true, p->case_sensitive))
-            skip_me = true;
-        if(matchesAny(tc.m_test_suite, p->filters[3], false, p->case_sensitive))
-            skip_me = true;
-        if(!matchesAny(tc.m_name, p->filters[4], true, p->case_sensitive))
-            skip_me = true;
-        if(matchesAny(tc.m_name, p->filters[5], false, p->case_sensitive))
-            skip_me = true;
-
-        if(!skip_me)
-            p->numTestCasesPassingFilters++;
-
-        // skip the test if it is not in the execution range
-        if((p->last < p->numTestCasesPassingFilters && p->first <= p->last) ||
-           (p->first > p->numTestCasesPassingFilters))
-            skip_me = true;
-
-        if(skip_me) {
-            if(!query_mode)
-                DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_skipped, tc);
-            continue;
-        }
-
-        // do not execute the test if we are to only count the number of filter passing tests
-        if(p->count)
-            continue;
-
-        // print the name of the test and don't execute it
-        if(p->list_test_cases) {
-            queryResults.push_back(&tc);
-            continue;
-        }
-
-        // print the name of the test suite if not done already and don't execute it
-        if(p->list_test_suites) {
-            if((testSuitesPassingFilt.count(tc.m_test_suite) == 0) && tc.m_test_suite[0] != '\0') {
-                queryResults.push_back(&tc);
-                testSuitesPassingFilt.insert(tc.m_test_suite);
-                p->numTestSuitesPassingFilters++;
-            }
-            continue;
-        }
-
-        // execute the test if it passes all the filtering
-        {
-            p->currentTest = &tc;
-
-            p->failure_flags = TestCaseFailureReason::None;
-            p->seconds       = 0;
-
-            // reset atomic counters
-            p->numAssertsFailedCurrentTest_atomic = 0;
-            p->numAssertsCurrentTest_atomic       = 0;
-
-            p->fullyTraversedSubcases.clear();
-
-            DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_start, tc);
-
-            p->timer.start();
-
-            bool run_test = true;
-
-            do {
-                // reset some of the fields for subcases (except for the set of fully passed ones)
-                p->reachedLeaf = false;
-                // May not be empty if previous subcase exited via exception.
-                p->subcaseStack.clear();
-                p->currentSubcaseDepth = 0;
-
-                p->shouldLogCurrentException = true;
-
-                // reset stuff for logging with INFO()
-                p->stringifiedContexts.clear();
-
-#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
-                try {
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
-// MSVC 2015 diagnoses fatalConditionHandler as unused (because reset() is a static method)
-DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4101) // unreferenced local variable
-                    FatalConditionHandler fatalConditionHandler; // Handle signals
-                    // execute the test
-                    tc.m_test();
-                    fatalConditionHandler.reset();
-DOCTEST_MSVC_SUPPRESS_WARNING_POP
-#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
-                } catch(const TestFailureException&) {
-                    p->failure_flags |= TestCaseFailureReason::AssertFailure;
-                } catch(...) {
-                    DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_exception,
-                                                      {translateActiveException(), false});
-                    p->failure_flags |= TestCaseFailureReason::Exception;
-                }
-#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
-
-                // exit this loop if enough assertions have failed - even if there are more subcases
-                if(p->abort_after > 0 &&
-                   p->numAssertsFailed + p->numAssertsFailedCurrentTest_atomic >= p->abort_after) {
-                    run_test = false;
-                    p->failure_flags |= TestCaseFailureReason::TooManyFailedAsserts;
-                }
-
-                if(!p->nextSubcaseStack.empty() && run_test)
-                    DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_reenter, tc);
-                if(p->nextSubcaseStack.empty())
-                    run_test = false;
-            } while(run_test);
-
-            p->finalizeTestCaseData();
-
-            DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_end, *g_cs);
-
-            p->currentTest = nullptr;
-
-            // stop executing tests if enough assertions have failed
-            if(p->abort_after > 0 && p->numAssertsFailed >= p->abort_after)
-                break;
-        }
-    }
-
-    if(!query_mode) {
-        DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_end, *g_cs);
-    } else {
-        QueryData qdata;
-        qdata.run_stats = g_cs;
-        qdata.data      = queryResults.data();
-        qdata.num_data  = unsigned(queryResults.size());
-        DOCTEST_ITERATE_THROUGH_REPORTERS(report_query, qdata);
-    }
-
-    return cleanup_and_return();
-}
-
-DOCTEST_DEFINE_INTERFACE(IReporter)
-
-int IReporter::get_num_active_contexts() { return detail::g_infoContexts.size(); }
-const IContextScope* const* IReporter::get_active_contexts() {
-    return get_num_active_contexts() ? &detail::g_infoContexts[0] : nullptr;
-}
-
-int IReporter::get_num_stringified_contexts() { return detail::g_cs->stringifiedContexts.size(); }
-const String* IReporter::get_stringified_contexts() {
-    return get_num_stringified_contexts() ? &detail::g_cs->stringifiedContexts[0] : nullptr;
-}
-
-namespace detail {
-    void registerReporterImpl(const char* name, int priority, reporterCreatorFunc c, bool isReporter) {
-        if(isReporter)
-            getReporters().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
-        else
-            getListeners().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
-    }
-} // namespace detail
-
-} // namespace doctest
-
-#endif // DOCTEST_CONFIG_DISABLE
-
-#ifdef DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
-DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4007) // 'function' : must be 'attribute' - see issue #182
-int main(int argc, char** argv) { return doctest::Context(argc, argv).run(); }
-DOCTEST_MSVC_SUPPRESS_WARNING_POP
-#endif // DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
-
-DOCTEST_CLANG_SUPPRESS_WARNING_POP
-DOCTEST_MSVC_SUPPRESS_WARNING_POP
-DOCTEST_GCC_SUPPRESS_WARNING_POP
-
-DOCTEST_SUPPRESS_COMMON_WARNINGS_POP
-
-#endif // DOCTEST_LIBRARY_IMPLEMENTATION
-#endif // DOCTEST_CONFIG_IMPLEMENT
-
-#ifdef DOCTEST_UNDEF_WIN32_LEAN_AND_MEAN
-#undef WIN32_LEAN_AND_MEAN
-#undef DOCTEST_UNDEF_WIN32_LEAN_AND_MEAN
-#endif // DOCTEST_UNDEF_WIN32_LEAN_AND_MEAN
-
-#ifdef DOCTEST_UNDEF_NOMINMAX
-#undef NOMINMAX
-#undef DOCTEST_UNDEF_NOMINMAX
-#endif // DOCTEST_UNDEF_NOMINMAX
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/ArithmeticTypesLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/ArithmeticTypesLoggingTest.cpp
deleted file mode 100644
index 91e6982..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/ArithmeticTypesLoggingTest.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("arithmetic_types_logging")
-{
-  static constexpr char const* filename = "arithmetic_types_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  BackendOptions bo;
-  bo.error_notifier = [](std::string const&) {};
-  Backend::start(bo);
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    bool b = true;
-    LOG_INFO(logger, "v [{}]", b);
-
-    char c = 'a';
-    LOG_INFO(logger, "c [{}]", c);
-
-    short int si = -12;
-    LOG_INFO(logger, "si [{}]", si);
-
-    int i = -123;
-    LOG_INFO(logger, "i [{}]", i);
-
-    long int li = 9876;
-    LOG_INFO(logger, "li [{}]", li);
-
-    long long int lli = 321;
-    LOG_INFO(logger, "lli [{}]", lli);
-
-    unsigned short int usi = 15;
-    LOG_INFO(logger, "usi [{}]", usi);
-
-    unsigned int ui = 123;
-    LOG_INFO(logger, "ui [{}]", ui);
-
-    unsigned long int uli = 2876;
-    LOG_INFO(logger, "uli [{}]", uli);
-
-    unsigned long long int ulli = 1321;
-    LOG_INFO(logger, "ulli [{}]", ulli);
-
-    float f = 323.31f;
-    LOG_INFO(logger, "f [{}]", f);
-
-    double d = 3213213.123;
-    LOG_INFO(logger, "d [{}]", d);
-
-    int const& cri = i;
-    LOG_INFO(logger, "cri [{}]", cri);
-
-    int& ci = i;
-    LOG_INFO(logger, "ci [{}]", ci);
-
-    LOG_INFO(logger, "invalid format [{%f}]", 321.1);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-  REQUIRE_FALSE(Backend::is_running());
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       v [true]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c [a]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       si [-12]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       i [-123]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       li [9876]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       lli [321]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       usi [15]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ui [123]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uli [2876]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ulli [1321]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       f [323.31]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       d [3213213.123]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cri [-123]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_INFO      " + logger_name +
-                "       [Could not format log statement. message: \"invalid format [{%f}]\""}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/BackendExceptionNotifierTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/BackendExceptionNotifierTest.cpp
deleted file mode 100644
index ab805d1..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/BackendExceptionNotifierTest.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-#if !defined(QUILL_NO_EXCEPTIONS)
-
-/***/
-TEST_CASE("backend_exception_notifier")
-{
-  static constexpr char const* filename = "backend_exception_notifier.log";
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger("logger", std::move(file_sink));
-
-  // counter to check our error handler was invoked
-  // atomic because we check this value on this thread, but the backend worker thread updates it
-  std::atomic<size_t> error_notifier_invoked{0};
-
-  // Set invalid thread name
-  BackendOptions backend_options;
-
-  // Setting to an invalid CPU. When we call quill::start() our error handler will be invoked and an error will be logged
-  backend_options.backend_cpu_affinity = static_cast<uint16_t>(std::numeric_limits<uint16_t>::max() - 1);
-
-  backend_options.thread_name =
-    "Lorem_ipsum_dolor_sit_amet_consectetur_adipiscing_elit_sed_do_eiusmod_tempor_incididunt_ut_"
-    "labore_et_dolore_magna_aliqua";
-
-  backend_options.error_notifier = [logger, &error_notifier_invoked](std::string const& error_message)
-  {
-    // Log inside the function from the backend thread, for testing
-
-    // Note that this log is asynchronous here which means when error_notifier_invoked is
-    // incremented does not mean we have logged this yet
-
-    // flush_log() is not permitted inside this callback
-    LOG_WARNING(logger, "error handler invoked {}", error_message);
-
-    error_notifier_invoked.fetch_add(1);
-  };
-
-  Backend::start(backend_options);
-
-  // Log a message and wait for it to get processed, that way we know the backend thread has started
-  LOG_INFO(logger, "frontend");
-  logger->flush_log();
-
-  // Check our handler was invoked since either set_backend_thread_name or set_backend_thread_cpu_affinity should have failed
-  REQUIRE_GE(error_notifier_invoked.load(), 1);
-
-  // Now we can try to get another exception by calling LOG_BACKTRACE without calling init first
-  error_notifier_invoked.store(0);
-
-  LOG_BACKTRACE(logger, "Backtrace message");
-  logger->flush_log();
-
-  // Check our handler was invoked
-  REQUIRE_EQ(error_notifier_invoked.load(), 1);
-
-  // Pass an invalid fmt format and see if it throws
-  error_notifier_invoked.store(0);
-
-  LOG_INFO(logger, "Format {:>321.}", 321.3);
-  logger->flush_log();
-
-  // Check our handler was invoked
-  REQUIRE_EQ(error_notifier_invoked.load(), 1);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // After the backend has stopped, all messages include the async ones from the notifier will
-  // be in the log file. At this point we can safely check it
-
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_GE(file_contents.size(), 5);
-
-  // Look for the async errors
-  std::string const expected_string_1 = "error handler invoked Failed to set cpu affinity ";
-  std::string const expected_string_2 = "error handler invoked Failed to set thread name ";
-
-  bool const has_any_error = quill::testing::file_contains(file_contents, expected_string_1) ||
-    quill::testing::file_contains(file_contents, expected_string_2);
-
-  REQUIRE(has_any_error);
-
-  std::string const expected_string_3 = "error handler invoked logger->init_backtrace(...)";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_3));
-
-  std::string const expected_string_4 = "error handler invoked [Could not format log statement.";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_4));
-
-  testing::remove_file(filename);
-}
-
-#endif
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/BackendLongSleepAndNotifyTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/BackendLongSleepAndNotifyTest.cpp
deleted file mode 100644
index 87e42e0..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/BackendLongSleepAndNotifyTest.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <thread>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("backend_long_sleep_and_notify")
-{
-  static constexpr size_t number_of_messages = 100u;
-  static constexpr size_t number_of_threads = 4;
-  static constexpr char const* filename = "log_backend_long_sleep_and_notify.log";
-  static std::string const logger_name_prefix = "logger_";
-
-  // Start the backend thread
-  BackendOptions backend_options;
-  backend_options.sleep_duration = std::chrono::hours{24};
-  Backend::start(backend_options);
-
-  std::vector<std::thread> threads;
-  for (size_t i = 0; i < number_of_threads; ++i)
-  {
-    threads.emplace_back(
-      [i]() mutable
-      {
-        // Also use preallocate
-        Frontend::preallocate();
-
-        // Set writing logging to a file
-        auto file_sink = Frontend::create_or_get_sink<FileSink>(
-          filename,
-          []()
-          {
-            FileSinkConfig cfg;
-            cfg.set_open_mode('w');
-            return cfg;
-          }(),
-          FileEventNotifier{});
-
-        Logger* logger =
-          Frontend::create_or_get_logger(logger_name_prefix + std::to_string(i), std::move(file_sink));
-
-        for (size_t j = 0; j < number_of_messages; ++j)
-        {
-          LOG_INFO(logger, "Hello from thread {thread_index} this is message {message_num}", i, j);
-        }
-      });
-  }
-
-  for (auto& elem : threads)
-  {
-    elem.join();
-  }
-
-  // The backend worker is still sleeping here so no file should exist
-  REQUIRE_EQ(testing::file_contents(filename).size(), 0);
-
-  // Notify the backend to wake up and process
-  Backend::notify();
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), number_of_messages * number_of_threads);
-
-  for (size_t i = 0; i < number_of_threads; ++i)
-  {
-    // for each thread
-    for (size_t j = 0; j < number_of_messages; ++j)
-    {
-      std::string expected_string = logger_name_prefix + std::to_string(i) +
-        "     Hello from thread " + std::to_string(i) + " this is message " + std::to_string(j);
-
-      REQUIRE(testing::file_contains(file_contents, expected_string));
-    }
-  }
-
-  testing::remove_file(filename);
-}
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/BackendTransitBufferHardLimitTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/BackendTransitBufferHardLimitTest.cpp
deleted file mode 100644
index 1ff41b8..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/BackendTransitBufferHardLimitTest.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <thread>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("backend_transit_buffer_hard_limit")
-{
-  static constexpr size_t number_of_messages = 500u;
-  static constexpr size_t number_of_threads = 10;
-  static constexpr char const* filename = "backend_transit_buffer_hard_limit.log";
-  static std::string const logger_name_prefix = "logger_";
-
-  // Start the backend thread
-  BackendOptions backend_options;
-  backend_options.transit_events_hard_limit = 0;
-  backend_options.transit_event_buffer_initial_capacity = 0;
-  Backend::start(backend_options);
-
-  std::vector<std::thread> threads;
-
-  for (size_t i = 0; i < number_of_threads; ++i)
-  {
-    threads.emplace_back(
-      [i]() mutable
-      {
-        // Set writing logging to a file
-        auto file_sink = Frontend::create_or_get_sink<FileSink>(
-          filename,
-          []()
-          {
-            FileSinkConfig cfg;
-            cfg.set_open_mode('w');
-            return cfg;
-          }(),
-          FileEventNotifier{});
-
-        Logger* logger =
-          Frontend::create_or_get_logger(logger_name_prefix + std::to_string(i), std::move(file_sink));
-
-        for (size_t j = 0; j < number_of_messages; ++j)
-        {
-          LOG_INFO(logger, "Hello from thread {thread_index} this is message {message_num}", i, j);
-        }
-      });
-  }
-
-  for (auto& elem : threads)
-  {
-    elem.join();
-  }
-
-  // flush all log and remove all loggers
-  for (Logger* logger : Frontend::get_all_loggers())
-  {
-    logger->flush_log();
-    Frontend::remove_logger(logger);
-  }
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-
-  REQUIRE_EQ(file_contents.size(), number_of_messages * number_of_threads);
-
-  for (size_t i = 0; i < number_of_threads; ++i)
-  {
-    // for each thread
-    for (size_t j = 0; j < number_of_messages; ++j)
-    {
-      std::string expected_string = logger_name_prefix + std::to_string(i) +
-        "     Hello from thread " + std::to_string(i) + " this is message " + std::to_string(j);
-
-      REQUIRE(testing::file_contains(file_contents, expected_string));
-    }
-  }
-
-  testing::remove_file(filename);
-}
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/BackendTransitBufferSoftLimitTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/BackendTransitBufferSoftLimitTest.cpp
deleted file mode 100644
index 4fe69d1..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/BackendTransitBufferSoftLimitTest.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <thread>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("backend_transit_buffer_soft_limit")
-{
-  static constexpr char const* filename = "backend_transit_buffer_soft_limit.log";
-  static std::string const logger_name = "logger";
-  size_t constexpr soft_limit = 100;
-
-  // First log some messages and then start the backend worker thread so that the soft limit is hit
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  for (size_t i = 0; i < soft_limit * 2; ++i)
-  {
-    // log all messages
-    LOG_INFO(logger, "Message num {}", i);
-  }
-
-  // Start the backend thread
-  BackendOptions backend_options;
-  backend_options.transit_events_soft_limit = soft_limit;
-  Backend::start(backend_options);
-
-  // log more messages after the backend started
-  for (size_t i = soft_limit * 2; i < soft_limit * 4; ++i)
-  {
-    // log all messages
-    LOG_INFO(logger, "Message num {}", i);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-
-  size_t const total_messages = soft_limit * 4;
-  REQUIRE_EQ(file_contents.size(), total_messages);
-
-  for (size_t i = 0; i < total_messages; ++i)
-  {
-    REQUIRE(quill::testing::file_contains(
-      file_contents, std::string{"LOG_INFO      " + logger_name + "       Message num "} + std::to_string(i)));
-  }
-
-  testing::remove_file(filename);
-}
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceDynamicLogLevelTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceDynamicLogLevelTest.cpp
deleted file mode 100644
index eda22f6..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceDynamicLogLevelTest.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("backtrace_dynamic_log_level")
-{
-  static constexpr char const* filename = "backtrace_dynamic_log_level.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  // Enable backtrace for 2 messages for error
-  logger->init_backtrace(2, LogLevel::Error);
-
-  // log using dynamic log level and flush on warning instead
-  LOG_DYNAMIC(logger, LogLevel::Info, "Before dynamic backtrace log");
-  for (size_t i = 100; i < 120; ++i)
-  {
-#if defined(__aarch64__) || ((__ARM_ARCH >= 6) || defined(_M_ARM64))
-    // On ARM we add a small delay because log messages can get the same timestamp from rdtsc
-    // when in this loop and make the test unstable
-    std::this_thread::sleep_for(std::chrono::microseconds{200});
-#endif
-    LOG_DYNAMIC(logger, LogLevel::Backtrace, "Dynamic backtrace log {}", i);
-  }
-
-  LOG_DYNAMIC(logger, LogLevel::Error, "After dynamic error");
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE_EQ(file_contents.size(), 4);
-
-  std::string expected_string_1 =
-    "LOG_INFO      " + logger_name + "       Before dynamic backtrace log";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_1));
-
-  std::string expected_string_2 = "LOG_ERROR     " + logger_name + "       After dynamic error";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_2));
-
-  std::string expected_string_3 =
-    "LOG_BACKTRACE " + logger_name + "       Dynamic backtrace log 118";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_3));
-
-  std::string expected_string_4 =
-    "LOG_BACKTRACE " + logger_name + "       Dynamic backtrace log 119";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_4));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceFlushOnErrorTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceFlushOnErrorTest.cpp
deleted file mode 100644
index 88a326a..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceFlushOnErrorTest.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("backtrace_flush_on_error")
-{
-  static constexpr char const* filename = "backtrace_flush_on_error.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  // Enable backtrace for 2 messages for error
-  logger->init_backtrace(2, LogLevel::Error);
-
-  // flush backtrace on error
-  LOG_INFO(logger, "Before backtrace log");
-  for (size_t i = 0; i < 12; ++i)
-  {
-#if defined(__aarch64__) || ((__ARM_ARCH >= 6) || defined(_M_ARM64))
-    // On ARM we add a small delay because log messages can get the same timestamp from rdtsc
-    // when in this loop and make the test unstable
-    std::this_thread::sleep_for(std::chrono::microseconds{200});
-#endif
-    LOG_BACKTRACE(logger, "Backtrace log {}", i);
-  }
-  LOG_ERROR(logger, "After error");
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE_EQ(file_contents.size(), 4);
-
-  std::string expected_string_1 = "LOG_INFO      " + logger_name + "       Before backtrace log";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_1));
-
-  std::string expected_string_2 = "LOG_ERROR     " + logger_name + "       After error";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_2));
-
-  std::string expected_string_3 = "LOG_BACKTRACE " + logger_name + "       Backtrace log 10";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_3));
-
-  std::string expected_string_4 = "LOG_BACKTRACE " + logger_name + "       Backtrace log 11";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_4));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceManualFlushTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceManualFlushTest.cpp
deleted file mode 100644
index 9f1c577..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceManualFlushTest.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("backtrace_manual_flush")
-{
-  static constexpr char const* filename = "backtrace_manual_flush.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  // Enable backtrace for 2 messages for error
-  logger->init_backtrace(2, LogLevel::Error);
-
-  // flush backtrace on error
-  LOG_INFO(logger, "Before backtrace log");
-  for (size_t i = 0; i < 12; ++i)
-  {
-#if defined(__aarch64__) || ((__ARM_ARCH >= 6) || defined(_M_ARM64))
-    // On ARM we add a small delay because log messages can get the same timestamp from rdtsc
-    // when in this loop and make the test unstable
-    std::this_thread::sleep_for(std::chrono::microseconds{200});
-#endif
-    LOG_BACKTRACE(logger, "Backtrace log {}", i);
-  }
-
-  logger->flush_backtrace();
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE_EQ(file_contents.size(), 3);
-
-  std::string expected_string_1 = "LOG_INFO      " + logger_name + "       Before backtrace log";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_1));
-
-  std::string expected_string_3 = "LOG_BACKTRACE " + logger_name + "       Backtrace log 10";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_3));
-
-  std::string expected_string_4 = "LOG_BACKTRACE " + logger_name + "       Backtrace log 11";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_4));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceNoFlushTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceNoFlushTest.cpp
deleted file mode 100644
index 8508dd7..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceNoFlushTest.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("backtrace_no_flush")
-{
-  static constexpr char const* filename = "backtrace_no_flush.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  // Enable backtrace for 2 messages for warning
-  logger->init_backtrace(2, LogLevel::Error);
-
-  // try with LOG_WARNING and expect no flush
-  LOG_INFO(logger, "Before backtrace log retry");
-  for (size_t i = 0; i < 12; ++i)
-  {
-    LOG_BACKTRACE(logger, "Backtrace log {}", i);
-  }
-  LOG_WARNING(logger, "After backtrace log retry");
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE_EQ(file_contents.size(), 2);
-
-  std::string expected_string_1 =
-    "LOG_INFO      " + logger_name + "       Before backtrace log retry";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_1));
-
-  std::string expected_string_2 =
-    "LOG_WARNING   " + logger_name + "       After backtrace log retry";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_2));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceTerminatedThreadFlushTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceTerminatedThreadFlushTest.cpp
deleted file mode 100644
index a28e9b6..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/BacktraceTerminatedThreadFlushTest.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("backtrace_terminated_thread_flush")
-{
-  // In this test we store in backtrace from one thread that terminates
-  // then we log that backtrace from a different thread
-
-  static constexpr char const* filename = "backtrace_terminated_thread_flush.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  std::thread thread_a(
-    []()
-    {
-      // Set writing logging to a file
-      auto file_sink = Frontend::create_or_get_sink<FileSink>(
-        filename,
-        []()
-        {
-          FileSinkConfig cfg;
-          cfg.set_open_mode('w');
-          return cfg;
-        }(),
-        FileEventNotifier{});
-
-      // Get a logger and enable backtrace
-      Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-      // Enable backtrace for 2 messages
-      logger->init_backtrace(2, LogLevel::Error);
-
-      LOG_INFO(logger, "Before backtrace log");
-      for (uint32_t i = 0; i < 12; ++i)
-      {
-        LOG_BACKTRACE(logger, "Backtrace message {}", i);
-      }
-    });
-
-  thread_a.join();
-
-  // thread_a logged something in backtrace and finished.
-  // Now we spawn a different thread and LOG_ERROR
-  // we expect to see the backtrace from the previous thread
-  std::thread thread_b(
-    []()
-    {
-      // Set writing logging to a file
-      auto file_sink = Frontend::create_or_get_sink<FileSink>(
-        filename,
-        []()
-        {
-          FileSinkConfig cfg;
-          cfg.set_open_mode('w');
-          return cfg;
-        }(),
-        FileEventNotifier{});
-
-      // Get a logger and enable backtrace
-      Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-      LOG_ERROR(logger, "After error");
-
-      logger->flush_log();
-      Frontend::remove_logger(logger);
-    });
-
-  thread_b.join();
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE_EQ(file_contents.size(), 4);
-
-  std::string expected_string_1 = "LOG_INFO      " + logger_name + "       Before backtrace log";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_1));
-
-  std::string expected_string_2 = "LOG_ERROR     " + logger_name + "       After error";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_2));
-
-  std::string expected_string_3 = "LOG_BACKTRACE " + logger_name + "       Backtrace message 10";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_3));
-
-  std::string expected_string_4 = "LOG_BACKTRACE " + logger_name + "       Backtrace message 11";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string_4));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/BoundedBlockingQueueTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/BoundedBlockingQueueTest.cpp
deleted file mode 100644
index 45cddc0..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/BoundedBlockingQueueTest.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-// Define custom Frontend Options
-struct CustomFrontendOptions
-{
-  static constexpr quill::QueueType queue_type = quill::QueueType::BoundedBlocking;
-  static constexpr uint32_t initial_queue_capacity = 131'072;
-  static constexpr uint32_t blocking_queue_retry_interval_ns = 800;
-  static constexpr bool huge_pages_enabled = false;
-};
-
-using CustomFrontend = FrontendImpl<CustomFrontendOptions>;
-using CustomLogger = LoggerImpl<CustomFrontendOptions>;
-
-TEST_CASE("bounded_blocking_queue")
-{
-  static constexpr char const* filename = "bounded_blocking_queue.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  auto file_sink = CustomFrontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  CustomLogger* logger = CustomFrontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  for (int i = 0; i < 5000; ++i)
-  {
-    LOG_INFO(logger, "Log something to fulfill the bound queue {}", i);
-    LOG_WARNING(logger, "Log something to fulfill the bound queue {}", i);
-    LOG_ERROR(logger, "Log something to fulfill the bound queue {}", i);
-  }
-
-  logger->flush_log();
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check the first messages as we can't if some were dropped
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-
-  for (int i = 0; i < 5000; ++i)
-  {
-    std::string expected_string_1 = "LOG_INFO      " + logger_name +
-      "       Log something to fulfill the bound queue " + std::to_string(i);
-
-    std::string expected_string_2 = "LOG_WARNING   " + logger_name +
-      "       Log something to fulfill the bound queue " + std::to_string(i);
-
-    std::string expected_string_3 = "LOG_ERROR     " + logger_name +
-      "       Log something to fulfill the bound queue " + std::to_string(i);
-
-    REQUIRE(testing::file_contains(file_contents, expected_string_1));
-    REQUIRE(testing::file_contains(file_contents, expected_string_2));
-    REQUIRE(testing::file_contains(file_contents, expected_string_3));
-  }
-
-  testing::remove_file(filename);
-}
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/BoundedDroppingQueueTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/BoundedDroppingQueueTest.cpp
deleted file mode 100644
index d1712eb..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/BoundedDroppingQueueTest.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-// Define custom Frontend Options
-struct CustomFrontendOptions
-{
-  static constexpr quill::QueueType queue_type = quill::QueueType::BoundedDropping;
-  static constexpr uint32_t initial_queue_capacity = 131'072;
-  static constexpr uint32_t blocking_queue_retry_interval_ns = 800;
-  static constexpr bool huge_pages_enabled = false;
-};
-
-using CustomFrontend = FrontendImpl<CustomFrontendOptions>;
-using CustomLogger = LoggerImpl<CustomFrontendOptions>;
-
-TEST_CASE("bounded_dropping_queue")
-{
-  static constexpr char const* filename = "bounded_dropping_queue.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  auto file_sink = CustomFrontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  CustomLogger* logger = CustomFrontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  for (int i = 0; i < 5000; ++i)
-  {
-    LOG_INFO(logger, "Log something to fulfill the bound queue {}", i);
-    LOG_WARNING(logger, "Log something to fulfill the bound queue {}", i);
-    LOG_ERROR(logger, "Log something to fulfill the bound queue {}", i);
-  }
-
-  logger->flush_log();
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check the first messages as we can't if some were dropped
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-
-  for (int i = 0; i < 100; ++i)
-  {
-    std::string expected_string_1 = "LOG_INFO      " + logger_name +
-      "       Log something to fulfill the bound queue " + std::to_string(i);
-
-    std::string expected_string_2 = "LOG_WARNING   " + logger_name +
-      "       Log something to fulfill the bound queue " + std::to_string(i);
-
-    std::string expected_string_3 = "LOG_ERROR     " + logger_name +
-      "       Log something to fulfill the bound queue " + std::to_string(i);
-
-    REQUIRE(testing::file_contains(file_contents, expected_string_1));
-    REQUIRE(testing::file_contains(file_contents, expected_string_2));
-    REQUIRE(testing::file_contains(file_contents, expected_string_3));
-  }
-
-  testing::remove_file(filename);
-}
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/CMakeLists.txt b/subprojects/quill-4.2.0/quill/test/integration_tests/CMakeLists.txt
deleted file mode 100644
index 617c538..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/CMakeLists.txt
+++ /dev/null
@@ -1,109 +0,0 @@
-function(quill_add_test TEST_NAME SOURCES)
-    set(HEADER_FILES
-            ${PROJECT_SOURCE_DIR}/quill/test/bundled/doctest/doctest.h
-            ${PROJECT_SOURCE_DIR}/quill/test/misc/TestUtilities.h
-    )
-
-    set(ADD_SOURCE_FILES
-            ${PROJECT_SOURCE_DIR}/quill/test/misc/TestMain.cpp
-            ${PROJECT_SOURCE_DIR}/quill/test/misc/TestUtilities.cpp
-            ${PROJECT_SOURCE_DIR}/quill/test/misc/DocTestExtensions.cpp)
-
-    list(APPEND SOURCES ${ADD_SOURCE_FILES})
-
-    # Create a test executable
-    add_executable(${TEST_NAME} "")
-
-    set_common_compile_options(${TEST_NAME})
-
-    # Add sources
-    target_sources(${TEST_NAME} PRIVATE ${SOURCES} ${HEADER_FILES})
-
-    # include dirs
-    target_include_directories(${TEST_NAME}
-            PUBLIC
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/quill/test/misc>
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/quill/test/bundled>
-            $<INSTALL_INTERFACE:include>
-            PRIVATE
-            ${PROJECT_SOURCE_DIR}/quill/test)
-
-    # Link dependencies
-    target_link_libraries(${TEST_NAME} quill)
-
-    # Do not decay cxx standard if not specified
-    set_property(TARGET ${TEST_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
-
-    # Set output test directory
-    set_target_properties(${TEST_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/build/test)
-
-    # Add this target to the post build unit tests
-    doctest_discover_tests(${TEST_NAME})
-endfunction()
-
-include(${PROJECT_SOURCE_DIR}/cmake/doctest.cmake)
-
-quill_add_test(TEST_ArithmeticTypesLogging ArithmeticTypesLoggingTest.cpp)
-quill_add_test(TEST_BackendExceptionNotifier BackendExceptionNotifierTest.cpp)
-quill_add_test(TEST_BackendLongSleepAndNotify BackendLongSleepAndNotifyTest.cpp)
-quill_add_test(TEST_BackendTransitBufferHardLimit BackendTransitBufferHardLimitTest.cpp)
-quill_add_test(TEST_BackendTransitBufferSoftLimit BackendTransitBufferSoftLimitTest.cpp)
-quill_add_test(TEST_BacktraceDynamicLogLevel BacktraceDynamicLogLevelTest.cpp)
-quill_add_test(TEST_BacktraceFlushOnError BacktraceFlushOnErrorTest.cpp)
-quill_add_test(TEST_BacktraceManualFlush BacktraceManualFlushTest.cpp)
-quill_add_test(TEST_BacktraceNoFlush BacktraceNoFlushTest.cpp)
-quill_add_test(TEST_BacktraceTerminatedThreadFlush BacktraceTerminatedThreadFlushTest.cpp)
-quill_add_test(TEST_BoundedBlockingQueue BoundedBlockingQueueTest.cpp)
-quill_add_test(TEST_BoundedDroppingQueue BoundedDroppingQueueTest.cpp)
-quill_add_test(TEST_ConsoleSinkStderrMultipleFormats ConsoleSinkStderrMultipleFormatsTest.cpp)
-quill_add_test(TEST_ConsoleSinkStdoutMultipleFormats ConsoleSinkStdoutMultipleFormatsTest.cpp)
-quill_add_test(TEST_LoggerAddRemoveGet LoggerAddRemoveGetTest.cpp)
-quill_add_test(TEST_EnumLogging EnumLoggingTest.cpp)
-quill_add_test(TEST_FlushWithoutAnyLog FlushWithoutAnyLog.cpp)
-quill_add_test(TEST_JsonConsoleLoggingTest JsonConsoleLoggingTest.cpp)
-quill_add_test(TEST_JsonFileLogging JsonFileLoggingTest.cpp)
-quill_add_test(TEST_LogArgumentsEvaluation LogArgumentsEvaluationTest.cpp)
-quill_add_test(TEST_LogFlushWithSoftLimit LogFlushWithSoftLimitTest.cpp)
-quill_add_test(TEST_MultiFrontendThreads MultiFrontendThreadsTest.cpp)
-quill_add_test(TEST_MultipleSinksSameLogger MultipleSinksSameLoggerTest.cpp)
-quill_add_test(TEST_RotatingSinkDailyRotation RotatingSinkDailyRotationTest.cpp)
-quill_add_test(TEST_RotatingSinkKeepOldest RotatingSinkKeepOldestTest.cpp)
-quill_add_test(TEST_RotatingSinkOverwriteOldest RotatingSinkOverwriteOldestTest.cpp)
-quill_add_test(TEST_SignalHandler SignalHandlerTest.cpp)
-quill_add_test(TEST_SingleFrontendThread SingleFrontendThreadTest.cpp)
-quill_add_test(TEST_SinkFilter SinkFilterTest.cpp)
-quill_add_test(TEST_StdArrayLogging StdArrayLoggingTest.cpp)
-quill_add_test(TEST_StdDequeLogging StdDequeLoggingTest.cpp)
-quill_add_test(TEST_StdFilesystemPathLogging StdFilesystemPathLoggingTest.cpp)
-quill_add_test(TEST_StdForwardListLogging StdForwardListLoggingTest.cpp)
-quill_add_test(TEST_StdListLogging StdListLoggingTest.cpp)
-quill_add_test(TEST_StdMapLogging StdMapLoggingTest.cpp)
-quill_add_test(TEST_StdMultiMapLogging StdMultiMapLoggingTest.cpp)
-quill_add_test(TEST_StdMultiSetLogging StdMultiSetLoggingTest.cpp)
-quill_add_test(TEST_StdOptionalLogging StdOptionalLoggingTest.cpp)
-quill_add_test(TEST_StdPairLogging StdPairLoggingTest.cpp)
-quill_add_test(TEST_StdSetLogging StdSetLoggingTest.cpp)
-quill_add_test(TEST_StdTupleLogging StdTupleLoggingTest.cpp)
-quill_add_test(TEST_StdUnorderedMapLogging StdUnorderedMapLoggingTest.cpp)
-quill_add_test(TEST_StdUnorderedMultiMapLogging StdUnorderedMultiMapLoggingTest.cpp)
-quill_add_test(TEST_StdUnorderedMultiSetLogging StdUnorderedMultiSetLoggingTest.cpp)
-quill_add_test(TEST_StdUnorderedSetLogging StdUnorderedSetLoggingTest.cpp)
-quill_add_test(TEST_StdVectorLogging StdVectorLoggingTest.cpp)
-quill_add_test(TEST_SinkLogLevelFilter SinkLogLevelFilterTest.cpp)
-quill_add_test(TEST_StringLargeLogging StringLargeLoggingTest.cpp)
-quill_add_test(TEST_StringLoggingDynamicLogLevel StringLoggingDynamicLogLevelTest.cpp)
-quill_add_test(TEST_StringLogging StringLoggingTest.cpp)
-quill_add_test(TEST_StringRandomLargeLogging StringRandomLargeLoggingTest.cpp)
-quill_add_test(TEST_StringRandomLogging StringRandomLoggingTest.cpp)
-quill_add_test(TEST_StringRandomSmallLogging StringRandomSmallLoggingTest.cpp)
-quill_add_test(TEST_TagsLogging TagsLoggingTest.cpp)
-quill_add_test(TEST_UserClockSource UserClockSourceTest.cpp)
-quill_add_test(TEST_UserDefinedTypeLogging UserDefinedTypeLoggingTest.cpp)
-
-quill_add_test(TEST_CompileActiveLogLevel CompileActiveLogLevelTest.cpp)
-target_compile_definitions(TEST_CompileActiveLogLevel PRIVATE -DQUILL_COMPILE_ACTIVE_LOG_LEVEL=QUILL_COMPILE_ACTIVE_LOG_LEVEL_WARNING)
-
-if (WIN32)
-    quill_add_test(TEST_WideStdTypesLogging WideStdTypesLoggingTest.cpp)
-    quill_add_test(TEST_WideStringLogging WideStringLoggingTest.cpp)
-endif ()
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/CompileActiveLogLevelTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/CompileActiveLogLevelTest.cpp
deleted file mode 100644
index 4e39e45..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/CompileActiveLogLevelTest.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("compile_active_log_level")
-{
-  // we build this target with
-  // add_compile_definitions(-DQUILL_COMPILE_ACTIVE_LOG_LEVEL=QUILL_COMPILE_ACTIVE_LOG_LEVEL_WARNING)
-  static constexpr char const* filename = "compile_active_log_level.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-  logger->set_log_level(quill::LogLevel::TraceL3);
-  REQUIRE_EQ(logger->get_log_level(), quill::LogLevel::TraceL3);
-
-  LOG_TRACE_L3(logger, "This is a log trace l3 example {}", 1);
-  LOG_TRACE_L2(logger, "This is a log trace l2 example {} {}", 2, 2.3);
-  LOG_TRACE_L1(logger, "This is a log trace l1 {} example", "string");
-  LOG_DEBUG(logger, "This is a log debug example {}", 4);
-  LOG_INFO(logger, "This is a log info example {}", 21);
-  LOG_WARNING(logger, "This is a log warning example {}", 11);
-  LOG_ERROR(logger, "This is a log error example {}", 3212);
-  LOG_CRITICAL(logger, "This is a log critical example {}", 321);
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check, we only except statements above warning
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), 3);
-
-  REQUIRE(quill::testing::file_contains(file_contents, std::string{"This is a log warning example 11"}));
-
-  REQUIRE(quill::testing::file_contains(file_contents, std::string{"This is a log error example 3212"}));
-
-  REQUIRE(quill::testing::file_contains(file_contents, std::string{"This is a log critical example 321"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/ConsoleSinkStderrMultipleFormatsTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/ConsoleSinkStderrMultipleFormatsTest.cpp
deleted file mode 100644
index 292a390..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/ConsoleSinkStderrMultipleFormatsTest.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/bundled/fmt/format.h"
-#include "quill/bundled/fmt/ranges.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <cstdio>
-#include <sstream>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("console_sink_stderr_multiple_formats")
-{
-  static std::string const logger_name_a = "logger_a";
-  static std::string const logger_name_b = "logger_b";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  quill::testing::CaptureStderr();
-
-  // Set writing logging to a file
-  bool const using_colours = false;
-  std::string const stream = "stderr";
-  auto console_sink = Frontend::create_or_get_sink<ConsoleSink>("console_sink", using_colours, stream);
-
-  Logger* logger_a = Frontend::create_or_get_logger(logger_name_a, console_sink);
-  Logger* logger_b = Frontend::create_or_get_logger(logger_name_b, console_sink,
-                                                    "%(logger) - %(message) (%(caller_function))");
-
-  console_sink.reset();
-
-  // log a few messages so we rotate files
-  for (size_t i = 0; i < 20; ++i)
-  {
-    if (i % 2 == 0)
-    {
-      LOG_INFO(logger_a, "Hello log num {}", i);
-    }
-    else
-    {
-      LOG_INFO(logger_b, "Hello log num {}", i);
-    }
-  }
-
-  // flush all log and remove all loggers
-  for (Logger* logger : Frontend::get_all_loggers())
-  {
-    logger->flush_log();
-    Frontend::remove_logger(logger);
-  }
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // convert result to vector
-  std::string results = quill::testing::GetCapturedStderr();
-  std::stringstream data(results);
-
-  std::string line;
-  std::vector<std::string> result_arr;
-  while (std::getline(data, line, '\n'))
-  {
-    result_arr.push_back(line);
-  }
-
-  for (uint32_t i = 0; i < 20; ++i)
-  {
-    if (i % 2 == 0)
-    {
-      std::string expected_string =
-        "LOG_INFO      " + logger_name_a + "     Hello log num " + std::to_string(i);
-
-      if (!quill::testing::file_contains(result_arr, expected_string))
-      {
-        FAIL(fmtquill::format("expected [{}] is not in results [{}]", expected_string, result_arr).data());
-      }
-    }
-    else
-    {
-      std::string expected_string =
-        logger_name_b + " - Hello log num " + std::to_string(i) + " (DOCTEST_ANON_FUNC_2)";
-
-      if (!quill::testing::file_contains(result_arr, expected_string))
-      {
-        FAIL(fmtquill::format("expected [{}] is not in results [{}]", expected_string, result_arr).data());
-      }
-    }
-  }
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/ConsoleSinkStdoutMultipleFormatsTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/ConsoleSinkStdoutMultipleFormatsTest.cpp
deleted file mode 100644
index dee257b..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/ConsoleSinkStdoutMultipleFormatsTest.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/bundled/fmt/format.h"
-#include "quill/bundled/fmt/ranges.h"
-#include "quill/sinks/ConsoleSink.h"
-
-#include <cstdio>
-#include <sstream>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("console_sink_stdout_multiple_formats")
-{
-  static std::string const logger_name_a = "logger_a";
-  static std::string const logger_name_b = "logger_b";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  quill::testing::CaptureStdout();
-
-  // Set writing logging to a file
-  bool const using_colours = false;
-  std::string const stream = "stdout";
-  auto console_sink = Frontend::create_or_get_sink<ConsoleSink>("console_sink", using_colours, stream);
-
-  Logger* logger_a = Frontend::create_or_get_logger(logger_name_a, console_sink);
-  Logger* logger_b = Frontend::create_or_get_logger(logger_name_b, console_sink,
-                                                    "%(logger) - %(message) (%(caller_function))");
-
-  console_sink.reset();
-
-  // log a few messages so we rotate files
-  for (size_t i = 0; i < 20; ++i)
-  {
-    if (i % 2 == 0)
-    {
-      LOG_INFO(logger_a, "Hello log num {}", i);
-    }
-    else
-    {
-      LOG_INFO(logger_b, "Hello log num {}", i);
-    }
-  }
-
-  // flush all log and remove all loggers
-  for (Logger* logger : Frontend::get_all_loggers())
-  {
-    logger->flush_log();
-    Frontend::remove_logger(logger);
-  }
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // convert result to vector
-  std::string results = quill::testing::GetCapturedStdout();
-  std::stringstream data(results);
-
-  std::string line;
-  std::vector<std::string> result_arr;
-  while (std::getline(data, line, '\n'))
-  {
-    result_arr.push_back(line);
-  }
-
-  for (uint32_t i = 0; i < 20; ++i)
-  {
-    if (i % 2 == 0)
-    {
-      std::string expected_string =
-        "LOG_INFO      " + logger_name_a + "     Hello log num " + std::to_string(i);
-
-      if (!quill::testing::file_contains(result_arr, expected_string))
-      {
-        FAIL(fmtquill::format("expected [{}] is not in results [{}]", expected_string, result_arr).data());
-      }
-    }
-    else
-    {
-      std::string expected_string =
-        logger_name_b + " - Hello log num " + std::to_string(i) + " (DOCTEST_ANON_FUNC_2)";
-
-      if (!quill::testing::file_contains(result_arr, expected_string))
-      {
-        FAIL(fmtquill::format("expected [{}] is not in results [{}]", expected_string, result_arr).data());
-      }
-    }
-  }
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/EnumLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/EnumLoggingTest.cpp
deleted file mode 100644
index 0d02c7d..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/EnumLoggingTest.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/bundled/fmt/format.h"
-#include "quill/bundled/fmt/ostream.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-enum TestEnum : int
-{
-  Test1 = 1,
-  Test2 = 2,
-  Test3 = 3
-};
-
-std::ostream& operator<<(std::ostream& os, TestEnum const& test_enum)
-{
-  switch (test_enum)
-  {
-  case TestEnum::Test1:
-    os << "Test1";
-    break;
-  case TestEnum::Test2:
-    os << "Test2";
-    break;
-  case TestEnum::Test3:
-    os << "Test3";
-    break;
-  default:
-    os << "Unknown";
-    break;
-  }
-  return os;
-}
-
-template <>
-struct fmtquill::formatter<TestEnum> : fmtquill::ostream_formatter
-{
-};
-
-enum class TestEnumClass : uint64_t
-{
-  Test4 = 4,
-  Test5 = 5,
-  Test6 = 6
-};
-
-std::ostream& operator<<(std::ostream& os, const TestEnumClass& test_enum_class)
-{
-  switch (test_enum_class)
-  {
-  case TestEnumClass::Test4:
-    os << "Test4";
-    break;
-  case TestEnumClass::Test5:
-    os << "Test5";
-    break;
-  case TestEnumClass::Test6:
-    os << "Test6";
-    break;
-  default:
-    os << "Unknown";
-    break;
-  }
-  return os;
-}
-
-template <>
-struct fmtquill::formatter<TestEnumClass> : fmtquill::ostream_formatter
-{
-};
-
-/***/
-TEST_CASE("enum_logging")
-{
-  static constexpr char const* filename = "enum_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  LOG_INFO(logger, "{} -> {}, {} -> {}", TestEnum::Test1, static_cast<int>(TestEnum::Test1),
-           TestEnumClass::Test4, static_cast<uint64_t>(TestEnumClass::Test4));
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  std::string expected_string = "LOG_INFO      " + logger_name + "       Test1 -> 1, Test4 -> 4";
-  REQUIRE(quill::testing::file_contains(file_contents, expected_string));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/FlushWithoutAnyLog.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/FlushWithoutAnyLog.cpp
deleted file mode 100644
index 8b4e8d4..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/FlushWithoutAnyLog.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("flush_without_any_log")
-{
-  static constexpr char const* filename = "flush_without_any_log.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-  std::atomic<bool> is_flush_done = false;
-
-  std::thread watcher(
-    [&is_flush_done]()
-    {
-      uint32_t try_count = 2000;
-      while (!is_flush_done.load() && try_count--)
-      {
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
-      }
-      REQUIRE_EQ(is_flush_done.load(), true);
-    });
-
-  logger->flush_log();
-  is_flush_done = true;
-
-  watcher.join();
-  Backend::stop();
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/JsonConsoleLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/JsonConsoleLoggingTest.cpp
deleted file mode 100644
index e5d93f2..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/JsonConsoleLoggingTest.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/JsonConsoleSink.h"
-
-#include "quill/bundled/fmt/format.h"
-
-#include <cstdio>
-#include <sstream>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("json_console_logging")
-{
-  static constexpr size_t number_of_messages = 50;
-  static std::string const logger_name_a = "logger_a";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  quill::testing::CaptureStdout();
-
-  // Set writing logging to a file
-  auto console_sink = Frontend::create_or_get_sink<JsonConsoleSink>("json_console");
-  Logger* logger_a = Frontend::create_or_get_logger(logger_name_a, console_sink);
-
-  // log a few messages
-  for (size_t i = 0; i < number_of_messages; ++i)
-  {
-    LOG_INFO(logger_a, "Hello log num [{num}, {multiply}, {add}]", i, i * i, i + i);
-  }
-
-  // flush all log and remove all loggers
-  for (Logger* logger : Frontend::get_all_loggers())
-  {
-    logger->flush_log();
-    Frontend::remove_logger(logger);
-  }
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // convert result to vector
-  std::string results = quill::testing::GetCapturedStdout();
-  std::stringstream data(results);
-
-  std::string line;
-  std::vector<std::string> file_contents;
-  while (std::getline(data, line, '\n'))
-  {
-    file_contents.push_back(line);
-  }
-
-  REQUIRE_EQ(file_contents.size(), number_of_messages);
-
-  for (size_t i = 0; i < number_of_messages; ++i)
-  {
-    std::string const expected_format =
-      R"("logger_a","log_level":"INFO","message":"Hello log num [{{num}}, {{multiply}}, {{add}}]","num":"{}","multiply":"{}","add":"{}")";
-    std::string const expected_string =
-      fmtquill::format(fmtquill::runtime(expected_format), i, i * i, i + i);
-
-    REQUIRE(testing::file_contains(file_contents, expected_string));
-  }
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/JsonFileLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/JsonFileLoggingTest.cpp
deleted file mode 100644
index 467e548..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/JsonFileLoggingTest.cpp
+++ /dev/null
@@ -1,180 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/bundled/fmt/format.h"
-#include "quill/bundled/fmt/ostream.h"
-#include "quill/sinks/JsonFileSink.h"
-
-#include <cstdio>
-#include <optional>
-#include <string>
-#include <thread>
-#include <vector>
-
-using namespace quill;
-
-class UserDefinedType
-{
-public:
-  UserDefinedType() = default;
-  UserDefinedType(size_t i, std::string const& s) : _i(i), _s(s) {}
-
-  virtual ~UserDefinedType() = default;
-
-  friend std::ostream& operator<<(std::ostream& os, UserDefinedType const& obj)
-  {
-    if (obj._i && obj._s)
-    {
-      os << "i: " << *obj._i << ", s: " << *obj._s;
-    }
-
-    return os;
-  }
-
-private:
-  std::optional<size_t> _i;
-  std::optional<std::string> _s;
-};
-
-template <>
-struct fmtquill::formatter<UserDefinedType> : fmtquill::ostream_formatter
-{
-};
-
-/***/
-TEST_CASE("json_file_logging")
-{
-  static constexpr size_t number_of_messages = 500u;
-  static constexpr size_t number_of_threads = 6;
-  static constexpr char const* json_filename = "json_file_logging.json";
-  static constexpr char const* filename = "json_file_logging_file.log";
-  static std::string const logger_name_prefix = "logger_";
-
-  // Start the logging backend thread
-  BackendOptions bo;
-  bo.error_notifier = [](std::string const&) {};
-  Backend::start(bo);
-
-  std::vector<std::thread> threads;
-
-  for (size_t i = 0; i < number_of_threads; ++i)
-  {
-    threads.emplace_back(
-      [i]() mutable
-      {
-        // log to json
-        auto json_file_sink = Frontend::create_or_get_sink<JsonFileSink>(
-          json_filename,
-          []()
-          {
-            JsonFileSinkConfig cfg;
-            cfg.set_open_mode('w');
-            return cfg;
-          }(),
-          FileEventNotifier{});
-
-        auto file_sink = Frontend::create_or_get_sink<FileSink>(
-          filename,
-          []()
-          {
-            FileSinkConfig cfg;
-            cfg.set_open_mode('w');
-            return cfg;
-          }(),
-          FileEventNotifier{});
-
-        Logger* logger = Frontend::create_or_get_logger(
-          logger_name_prefix + std::to_string(i),
-          std::initializer_list<std::shared_ptr<Sink>>{std::move(json_file_sink), std::move(file_sink)},
-          "%(time) [%(thread_id)] %(short_source_location:<28) LOG_%(log_level:<9) %(logger:<12) "
-          "%(message) [%(named_args)]");
-
-        if (i == 0)
-        {
-          // log a message without any args, only from the first thread
-          LOG_INFO(logger, "Hello from thread");
-        }
-
-        for (size_t j = 0; j < number_of_messages; ++j)
-        {
-          LOG_INFO(logger,
-                   "Hello from thread {thread_index} this is message {message_num} [{custom}]", i,
-                   j, fmtquill::format("{}", UserDefinedType{j, std::to_string(j)}));
-        }
-
-        if (i == 0)
-        {
-          // log an invalid format for testing, only from the first thread
-          LOG_INFO(logger, "invalid format [{%f}]", 321.1);
-        }
-      });
-  }
-
-  for (auto& elem : threads)
-  {
-    elem.join();
-  }
-
-  // flush all log and remove all loggers
-  for (Logger* logger : Frontend::get_all_loggers())
-  {
-    logger->flush_log();
-    Frontend::remove_logger(logger);
-  }
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(json_filename);
-  std::vector<std::string> const file_contents_s = quill::testing::file_contents(filename);
-
-  REQUIRE_EQ(file_contents.size(), number_of_messages * number_of_threads + 2);
-  REQUIRE_EQ(file_contents_s.size(), number_of_messages * number_of_threads + 2);
-
-  for (size_t i = 0; i < number_of_threads; ++i)
-  {
-    // for each thread
-    for (size_t j = 0; j < number_of_messages; ++j)
-    {
-      // check json log
-      std::string expected_json_string = std::string{"\"logger\":\""} + logger_name_prefix +
-        std::to_string(i) +
-        std::string{
-          "\",\"log_level\":\"INFO\",\"message\":\"Hello from thread {thread_index} this is "
-          "message {message_num} [{custom}]\","} +
-        std::string{"\"thread_index\":\""} + std::to_string(i) +
-        std::string{"\",\"message_num\":\""} + std::to_string(j) +
-        std::string{"\",\"custom\":\"i: "} + std::to_string(j) + ", s: " + std::to_string(j) +
-        std::string{"\""};
-
-      REQUIRE(quill::testing::file_contains(file_contents, expected_json_string));
-
-      // check standard log
-      // for each thread [i: 0, s: 0]
-      std::string expected_string = logger_name_prefix + std::to_string(i) +
-        "     Hello from thread " + std::to_string(i) + " this is message " + std::to_string(j) +
-        +" [i: " + std::to_string(j) + ", s: " + std::to_string(j) +
-        "] [thread_index: " + std::to_string(i) + ", message_num: " + std::to_string(j) + ", ";
-
-      REQUIRE(quill::testing::file_contains(file_contents_s, expected_string));
-    }
-
-    std::string expected_no_args_json = "\"log_level\":\"INFO\",\"message\":\"Hello from thread\"";
-    std::string expected_no_args_fmt = "Hello from thread";
-    REQUIRE(quill::testing::file_contains(file_contents, expected_no_args_json));
-    REQUIRE(quill::testing::file_contains(file_contents_s, expected_no_args_fmt));
-
-    std::string expected_invalid_fmt_json =
-      "\"log_level\":\"INFO\",\"message\":\"invalid format [{%f}]\"";
-    std::string expected_invalid_fmt = "invalid format [{%f}]\", location: \"";
-    REQUIRE(quill::testing::file_contains(file_contents, expected_invalid_fmt_json));
-    REQUIRE(quill::testing::file_contains(file_contents_s, expected_invalid_fmt));
-  }
-
-  testing::remove_file(json_filename);
-  testing::remove_file(filename);
-}
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/LogArgumentsEvaluationTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/LogArgumentsEvaluationTest.cpp
deleted file mode 100644
index 8312c4f..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/LogArgumentsEvaluationTest.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("log_arguments_evaluation")
-{
-  static constexpr char const* filename = "log_arguments_evaluation.log";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  std::string const logger_name = "logger";
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  size_t cnt{0};
-  auto arg_str = [&cnt]()
-  {
-    ++cnt;
-    return "expensive_calculation";
-  };
-
-  // 1. checks that log arguments are not evaluated when we don't log
-  logger->set_log_level(quill::LogLevel::Info);
-  LOG_DEBUG(logger, "Test log arguments {}", arg_str());
-  LOG_TRACE_L1(logger, "Test log arguments {}", arg_str());
-  REQUIRE_EQ(cnt, 0);
-
-  // 2. checks that log arguments are evaluated only once per log statement
-  LOG_INFO(logger, "Test log arguments {}", arg_str());
-  REQUIRE_EQ(cnt, 1);
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), 1);
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/LogFlushWithSoftLimitTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/LogFlushWithSoftLimitTest.cpp
deleted file mode 100644
index ca3bf7f..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/LogFlushWithSoftLimitTest.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <thread>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("log_flush_with_soft_limit_test")
-{
-  static constexpr char const* filename = "log_flush_with_soft_limit_test.log";
-  static std::string const logger_name = "logger";
-  static size_t constexpr soft_limit = 100;
-
-  // make sure we at least x 100 the soft limit to make sure we are testing what we want
-  // to not reduce this number. Increasing is fine
-  static size_t constexpr number_of_messages = soft_limit * 100;
-  static constexpr size_t number_of_threads = 4;
-
-  // When hitting the transit_events_soft_limit several events are processed in the backend at the
-  // same time If all of them are processed there is a chance to miss messages that where in the
-  // queues but never buffered result in example issuing the flush_log() earlier than it should
-
-  // Start the backend thread
-  BackendOptions backend_options;
-  backend_options.transit_events_soft_limit = soft_limit;
-  Backend::start(backend_options);
-
-  std::vector<std::thread> threads;
-  for (size_t i = 0; i < number_of_threads; ++i)
-  {
-    threads.emplace_back(
-      [i]() mutable
-      {
-        Frontend::preallocate();
-
-        // Set writing logging to a file
-        auto file_sink = Frontend::create_or_get_sink<FileSink>(
-          filename,
-          []()
-          {
-            FileSinkConfig cfg;
-            cfg.set_open_mode('w');
-            cfg.set_do_fsync(true);
-            return cfg;
-          }(),
-          FileEventNotifier{});
-
-        Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-        for (size_t j = 0; j < number_of_messages; ++j)
-        {
-          LOG_INFO(logger, "Hello from thread {} this is message {}", i, j);
-        }
-      });
-  }
-
-  for (auto& elem : threads)
-  {
-    elem.join();
-  }
-
-  Frontend::get_valid_logger()->flush_log();
-
-  // Now check we have all messages in the file after the flush statement
-
-  size_t const total_messages = number_of_messages * number_of_threads;
-  // Read file and check
-  REQUIRE_EQ(testing::file_contents(filename).size(), total_messages);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check again, nothing else was logged
-  REQUIRE_EQ(testing::file_contents(filename).size(), total_messages);
-
-  testing::remove_file(filename);
-}
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/LoggerAddRemoveGetTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/LoggerAddRemoveGetTest.cpp
deleted file mode 100644
index 2533dcb..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/LoggerAddRemoveGetTest.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/**
- * A test class example that is using the logger
- */
-class LoggingTestClass
-{
-public:
-  LoggingTestClass(std::string const& filename, std::string const& logger_name)
-  {
-    // create a new logger in the ctor
-    auto file_sink = Frontend::create_or_get_sink<FileSink>(
-      filename,
-      []()
-      {
-        FileSinkConfig cfg;
-        cfg.set_open_mode('w');
-        cfg.set_do_fsync(true);
-        return cfg;
-      }(),
-      FileEventNotifier{});
-
-    quill::Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-    _logger = logger;
-  }
-
-  ~LoggingTestClass()
-  {
-    _logger->flush_log();
-    Frontend::remove_logger(_logger);
-  }
-
-  /**
-   * Use logger in const function
-   */
-  void use_logger_const() const noexcept { LOG_INFO(_logger, "Test message for test class const"); }
-
-  /**
-   * Use logger in normal function
-   */
-  void use_logger() const { LOG_INFO(_logger, "Test message for test class non const"); }
-
-private:
-  quill::Logger* _logger{nullptr};
-};
-
-/***/
-TEST_CASE("logger_add_remove_get")
-{
-  // Verifies logging behavior adding, removing and getting loggers
-  // and logging from const member functions while dynamically creating and
-  // removing loggers and reusing the same file after removal.
-  static constexpr size_t iterations = 100;
-  static constexpr char const* filename = "logger_add_remove_get.log";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  for (size_t i = 0; i < iterations; ++i)
-  {
-    std::string const logger_a_name = "logger_a" + std::to_string(i);
-    std::string const logger_b_name = "logger_b" + std::to_string(i);
-
-    {
-      // log for class a
-      LoggingTestClass logging_test_class_a{filename, logger_a_name};
-      logging_test_class_a.use_logger_const();
-      logging_test_class_a.use_logger();
-
-      // log again for class b
-      LoggingTestClass const logging_test_class_b{filename, logger_b_name};
-      logging_test_class_b.use_logger_const();
-    }
-
-    // Test that get_all_loggers() works and also it should be empty after removing the loggers
-    REQUIRE(Frontend::get_all_loggers().empty());
-    REQUIRE(!Frontend::get_logger(logger_a_name));
-    REQUIRE(!Frontend::get_logger(logger_b_name));
-
-    // The only safe way to know that the loggers are really removed is currently this
-    while (Frontend::get_number_of_loggers())
-    {
-      // wait for all the to be removed first by the backend thread first then repeat the test
-      std::this_thread::sleep_for(std::chrono::milliseconds{1});
-    }
-
-    // Read file and check
-    std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-    REQUIRE_EQ(file_contents.size(), 3);
-
-    testing::remove_file(filename);
-  }
-
-  Backend::stop();
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/MultiFrontendThreadsTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/MultiFrontendThreadsTest.cpp
deleted file mode 100644
index ac6929f..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/MultiFrontendThreadsTest.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdint>
-#include <string>
-#include <thread>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("multi_frontend_threads")
-{
-  static constexpr size_t number_of_messages = 1000;
-  static constexpr size_t number_of_threads = 10;
-  static constexpr char const* filename = "multi_frontend_threads.log";
-  static std::string const logger_name_prefix = "logger_";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  std::vector<std::thread> threads;
-
-  for (size_t i = 0; i < number_of_threads; ++i)
-  {
-    threads.emplace_back(
-      [i]() mutable
-      {
-        Frontend::preallocate();
-
-        // Set writing logging to a file
-        auto file_sink = Frontend::create_or_get_sink<FileSink>(
-          filename,
-          []()
-          {
-            FileSinkConfig cfg;
-            cfg.set_open_mode('w');
-            return cfg;
-          }(),
-          FileEventNotifier{});
-
-        Logger* logger = Frontend::create_or_get_logger(
-          logger_name_prefix + std::to_string(i), std::move(file_sink),
-          "%(time) [%(thread_id)] %(short_source_location:<28) LOG_%(log_level:<9) %(logger:<12) "
-          "%(message)",
-          "%Y-%m-%d %H:%M:%S.%Qns", Timezone::GmtTime, ClockSourceType::System);
-
-        for (size_t j = 0; j < number_of_messages; ++j)
-        {
-          LOG_INFO(logger, "Hello from thread {} this is message {}", i, j);
-        }
-      });
-  }
-
-  for (auto& elem : threads)
-  {
-    elem.join();
-  }
-
-  // flush all log and remove all loggers
-  for (Logger* logger : Frontend::get_all_loggers())
-  {
-    logger->flush_log();
-    Frontend::remove_logger(logger);
-  }
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), number_of_messages * number_of_threads);
-
-  for (size_t i = 0; i < number_of_threads; ++i)
-  {
-    // for each thread
-    for (size_t j = 0; j < number_of_messages; ++j)
-    {
-      std::string expected_string = logger_name_prefix + std::to_string(i) +
-        "     Hello from thread " + std::to_string(i) + " this is message " + std::to_string(j);
-
-      REQUIRE(testing::file_contains(file_contents, expected_string));
-    }
-  }
-
-  // Check log file is timestamp ordered
-  REQUIRE(quill::testing::is_timestamp_ordered(file_contents));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/MultipleSinksSameLoggerTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/MultipleSinksSameLoggerTest.cpp
deleted file mode 100644
index 3e94a9a..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/MultipleSinksSameLoggerTest.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/ConsoleSink.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <sstream>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("multiple_sinks_same_logger")
-{
-  static constexpr size_t number_of_messages = 10000;
-  static constexpr char const* filename = "multiple_sinks_same_logger.log";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  quill::testing::CaptureStdout();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  bool const using_colours = false;
-  std::string const stream = "stdout";
-  auto console_sink = Frontend::create_or_get_sink<ConsoleSink>("console_sink", using_colours, stream);
-
-  std::string const logger_name = "logger";
-  Logger* logger =
-    Frontend::create_or_get_logger(logger_name, {std::move(file_sink), std::move(console_sink)});
-
-  for (size_t i = 0; i < number_of_messages; ++i)
-  {
-    LOG_INFO(logger, "This is message {}", i);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  {
-    // Read file and check
-    std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-    REQUIRE_EQ(file_contents.size(), number_of_messages);
-
-    for (size_t i = 0; i < number_of_messages; ++i)
-    {
-      std::string expected_string = logger_name + "       This is message " + std::to_string(i);
-      REQUIRE(quill::testing::file_contains(file_contents, expected_string));
-    }
-  }
-
-  {
-    // convert stdout result to vector
-    std::string results = quill::testing::GetCapturedStdout();
-    std::stringstream data(results);
-
-    std::string line;
-    std::vector<std::string> file_contents;
-    while (std::getline(data, line, '\n'))
-    {
-      file_contents.push_back(line);
-    }
-
-    REQUIRE_EQ(file_contents.size(), number_of_messages);
-
-    for (size_t i = 0; i < number_of_messages; ++i)
-    {
-      std::string expected_string = "logger       This is message " + std::to_string(i);
-      REQUIRE(quill::testing::file_contains(file_contents, expected_string));
-    }
-  }
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/RotatingSinkDailyRotationTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/RotatingSinkDailyRotationTest.cpp
deleted file mode 100644
index 81a38ac..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/RotatingSinkDailyRotationTest.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/RotatingFileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("rotating_sink_daily_rotation")
-{
-  // This test has 2 loggers that they logged to different rotating file handlers
-  static char const* base_filename = "rotating_sink_daily_rotation.log";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  // Create a rotating file handler
-  std::shared_ptr<quill::Sink> rotating_file_sink_a =
-    Frontend::create_or_get_sink<RotatingFileSink>(base_filename,
-                                                   []()
-                                                   {
-                                                     RotatingFileSinkConfig rfh_cfg;
-                                                     rfh_cfg.set_rotation_time_daily("00:00");
-                                                     rfh_cfg.set_open_mode('w');
-                                                     return rfh_cfg;
-                                                   }());
-
-  // Get the same instance back - we search it again (for testing only)
-  quill::Logger* logger = Frontend::create_or_get_logger("logger", std::move(rotating_file_sink_a));
-
-  // log a few messages so we rotate files
-  for (uint32_t i = 0; i < 20; ++i)
-  {
-    LOG_INFO(logger, "Hello daily file log num {}", i);
-  }
-
-  // flush all log and remove all loggers
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(base_filename);
-  REQUIRE_EQ(file_contents.size(), 20);
-
-  testing::remove_file(base_filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/RotatingSinkKeepOldestTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/RotatingSinkKeepOldestTest.cpp
deleted file mode 100644
index 693ac51..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/RotatingSinkKeepOldestTest.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/RotatingFileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("rotating_sink_keep_oldest")
-{
-  // This test has 2 loggers that they logged to different rotating file handlers
-  static char const* base_filename_a = "rotating_sink_keep_oldest_a.log";
-  static constexpr char const* base_filename_a_1 = "rotating_sink_keep_oldest_a.1.log";
-  static constexpr char const* base_filename_a_2 = "rotating_sink_keep_oldest_a.2.log";
-
-  static char const* base_filename_b = "rotating_sink_keep_oldest_b.log";
-  static constexpr char const* base_filename_b_1 = "rotating_sink_keep_oldest_b.1.log";
-
-  static constexpr size_t max_file_size = 900;
-
-  // Start the logging backend thread
-  Backend::start();
-
-  // Create a rotating file handler
-  std::shared_ptr<quill::Sink> rotating_file_sink_a =
-    Frontend::create_or_get_sink<RotatingFileSink>(base_filename_a,
-                                                   []()
-                                                   {
-                                                     RotatingFileSinkConfig rfh_cfg;
-                                                     rfh_cfg.set_rotation_max_file_size(max_file_size);
-                                                     rfh_cfg.set_max_backup_files(2);
-                                                     rfh_cfg.set_overwrite_rolled_files(false);
-                                                     rfh_cfg.set_open_mode('w');
-                                                     return rfh_cfg;
-                                                   }());
-
-  // Get the same instance back - we search it again (for testing only)
-  quill::Logger* logger_a = Frontend::create_or_get_logger("logger_a", std::move(rotating_file_sink_a));
-
-  // Another rotating logger to another file with max backup count 1 this time. Here we rotate only once
-  std::shared_ptr<quill::Sink> rotating_file_sink_b =
-    Frontend::create_or_get_sink<RotatingFileSink>(base_filename_b,
-                                                   []()
-                                                   {
-                                                     RotatingFileSinkConfig rfh_cfg;
-                                                     rfh_cfg.set_rotation_max_file_size(max_file_size);
-                                                     rfh_cfg.set_max_backup_files(1);
-                                                     rfh_cfg.set_overwrite_rolled_files(false);
-                                                     rfh_cfg.set_open_mode('w');
-                                                     return rfh_cfg;
-                                                   }());
-
-  quill::Logger* logger_b = Frontend::create_or_get_logger("logger_b", std::move(rotating_file_sink_b));
-
-  // log a few messages so we rotate files
-  for (uint32_t i = 0; i < 20; ++i)
-  {
-    LOG_INFO(logger_a, "Hello rotating file log num {}", i);
-    LOG_INFO(logger_b, "Hello rotating file log num {}", i);
-  }
-
-  // flush all log and remove all loggers
-  for (Logger* logger : Frontend::get_all_loggers())
-  {
-    logger->flush_log();
-    Frontend::remove_logger(logger);
-  }
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(base_filename_a);
-  REQUIRE_GE(file_contents.size(), 3);
-
-  std::vector<std::string> const file_contents_1 = quill::testing::file_contents(base_filename_a_1);
-  REQUIRE_GE(file_contents_1.size(), 7);
-
-  std::vector<std::string> const file_contents_2 = quill::testing::file_contents(base_filename_a_2);
-  REQUIRE_GE(file_contents_2.size(), 7);
-
-  // File from 2nd logger
-  std::vector<std::string> const file_contents_3 = quill::testing::file_contents(base_filename_b);
-  REQUIRE_GE(file_contents_3.size(), 11);
-
-  std::vector<std::string> const file_contents_4 = quill::testing::file_contents(base_filename_b_1);
-  REQUIRE_GE(file_contents_4.size(), 7);
-
-  // Remove filenames
-  testing::remove_file(base_filename_a);
-  testing::remove_file(base_filename_a_1);
-  testing::remove_file(base_filename_a_2);
-  testing::remove_file(base_filename_b);
-  testing::remove_file(base_filename_b_1);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/RotatingSinkOverwriteOldestTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/RotatingSinkOverwriteOldestTest.cpp
deleted file mode 100644
index 7cb9622..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/RotatingSinkOverwriteOldestTest.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/RotatingFileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("rotating_sink_overwrite_oldest")
-{
-  // This test has 2 loggers that they logged to different rotating file handlers
-  static char const* base_filename_a = "rotating_sink_overwrite_oldest_a.log";
-  static constexpr char const* base_filename_a_1 = "rotating_sink_overwrite_oldest_a.1.log";
-  static constexpr char const* base_filename_a_2 = "rotating_sink_overwrite_oldest_a.2.log";
-
-  static char const* base_filename_b = "rotating_sink_overwrite_oldest_b.log";
-  static constexpr char const* base_filename_b_1 = "rotating_sink_overwrite_oldest_b.1.log";
-
-  static constexpr size_t max_file_size = 900;
-
-  // Start the logging backend thread
-  Backend::start();
-
-  // Create a rotating file handler
-  std::shared_ptr<quill::Sink> rotating_file_sink_a =
-    Frontend::create_or_get_sink<RotatingFileSink>(base_filename_a,
-                                                   []()
-                                                   {
-                                                     RotatingFileSinkConfig rfh_cfg;
-                                                     rfh_cfg.set_rotation_max_file_size(max_file_size);
-                                                     rfh_cfg.set_max_backup_files(2);
-                                                     rfh_cfg.set_overwrite_rolled_files(true);
-                                                     rfh_cfg.set_open_mode('w');
-                                                     return rfh_cfg;
-                                                   }());
-
-  // Get the same instance back - we search it again (for testing only)
-  quill::Logger* logger_a = Frontend::create_or_get_logger("logger_a", std::move(rotating_file_sink_a));
-
-  // Another rotating logger to another file with max backup count 1 this time. Here we rotate only once
-  std::shared_ptr<quill::Sink> rotating_file_sink_b =
-    Frontend::create_or_get_sink<RotatingFileSink>(base_filename_b,
-                                                   []()
-                                                   {
-                                                     RotatingFileSinkConfig rfh_cfg;
-                                                     rfh_cfg.set_rotation_max_file_size(max_file_size);
-                                                     rfh_cfg.set_max_backup_files(1);
-                                                     rfh_cfg.set_overwrite_rolled_files(true);
-                                                     rfh_cfg.set_open_mode('w');
-                                                     return rfh_cfg;
-                                                   }());
-
-  quill::Logger* logger_b = Frontend::create_or_get_logger("logger_b", std::move(rotating_file_sink_b));
-
-  // log a few messages so we rotate files
-  for (uint32_t i = 0; i < 20; ++i)
-  {
-    LOG_INFO(logger_a, "Hello rotating file log num {}", i);
-    LOG_INFO(logger_b, "Hello rotating file log num {}", i);
-  }
-
-  // flush all log and remove all loggers
-  for (Logger* logger : Frontend::get_all_loggers())
-  {
-    logger->flush_log();
-    Frontend::remove_logger(logger);
-  }
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-  
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(base_filename_a);
-  REQUIRE_GE(file_contents.size(), 3);
-
-  std::vector<std::string> const file_contents_1 = quill::testing::file_contents(base_filename_a_1);
-  REQUIRE_GE(file_contents_1.size(), 7);
-
-  std::vector<std::string> const file_contents_2 = quill::testing::file_contents(base_filename_a_2);
-  REQUIRE_GE(file_contents_2.size(), 7);
-
-  // File from 2nd logger
-  std::vector<std::string> const file_contents_3 = quill::testing::file_contents(base_filename_b);
-  REQUIRE_GE(file_contents_3.size(), 4);
-
-  std::vector<std::string> const file_contents_4 = quill::testing::file_contents(base_filename_b_1);
-  REQUIRE_GE(file_contents_4.size(), 7);
-
-  // Remove filenames
-  testing::remove_file(base_filename_a);
-  testing::remove_file(base_filename_a_1);
-  testing::remove_file(base_filename_a_2);
-  testing::remove_file(base_filename_b);
-  testing::remove_file(base_filename_b_1);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/SignalHandlerTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/SignalHandlerTest.cpp
deleted file mode 100644
index eaf64dc..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/SignalHandlerTest.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("signal_handler")
-{
-  static constexpr char const* filename = "signal_handler.log";
-  static std::string const logger_name = "logger";
-  static constexpr size_t number_of_messages = 10;
-  static constexpr size_t number_of_threads = 10;
-  static std::string const logger_name_prefix = "logger_";
-
-  // Start the logging backend thread, we expect the signal handler to catch the signal,
-  // flush the log and raise the signal back
-  Backend::start_with_signal_handler<FrontendOptions>(BackendOptions{},
-                                                      std::initializer_list<int>{SIGABRT}, 40);
-
-  // For testing purposes we want to keep the application running, we do not reraise the signal
-  detail::SignalHandlerContext::instance().should_reraise_signal.store(false);
-
-  quill::Frontend::preallocate();
-
-  std::vector<std::thread> threads;
-
-  for (size_t i = 0; i < number_of_threads; ++i)
-  {
-    threads.emplace_back(
-      [i]() mutable
-      {
-#if defined(_WIN32)
-        // NOTE: On windows the signal handler must be installed on each new thread
-        quill::init_signal_handler<quill::FrontendOptions>();
-#endif
-
-        // Set writing logging to a file
-        auto file_sink = Frontend::create_or_get_sink<FileSink>(
-          filename,
-          []()
-          {
-            FileSinkConfig cfg;
-            cfg.set_open_mode('w');
-            cfg.set_do_fsync(true);
-            return cfg;
-          }(),
-          FileEventNotifier{});
-
-        Logger* logger =
-          Frontend::create_or_get_logger(logger_name_prefix + std::to_string(i), std::move(file_sink));
-
-        for (size_t j = 0; j < number_of_messages; ++j)
-        {
-          LOG_INFO(logger, "{} {} {}", i, j,
-                   "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor "
-                   "incididunt ut labore et dolore magna aliqua.");
-        }
-      });
-  }
-
-  for (auto& elem : threads)
-  {
-    elem.join();
-  }
-
-  // Now raise a signal
-  std::raise(SIGABRT);
-
-  {
-    // Except the log and the signal handler in the logs
-    std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-    for (size_t i = 0; i < number_of_threads; ++i)
-    {
-      // for each thread
-      for (size_t j = 0; j < number_of_messages; ++j)
-      {
-        std::string expected_string = logger_name_prefix + std::to_string(i) + "     " +
-          std::to_string(i) + " " + std::to_string(j) +
-          " Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor "
-          "incididunt ut labore et dolore magna aliqua.";
-
-        REQUIRE(testing::file_contains(file_contents, expected_string));
-      }
-    }
-
-#if defined(_WIN32)
-    REQUIRE(quill::testing::file_contains(file_contents, std::string{"Received signal: 22 (signum: 22)"}));
-#elif defined(__apple_build_version__)
-    REQUIRE(quill::testing::file_contains(file_contents, std::string{"Received signal: Abort trap: 6 (signum: 6)"}));
-#else
-    REQUIRE(quill::testing::file_contains(file_contents, std::string{"Received signal: Aborted (signum: 6)"}));
-#endif
-  }
-
-  // Wait until the backend thread stops for test stability
-  for (Logger* logger : Frontend::get_all_loggers())
-  {
-    logger->flush_log();
-    Frontend::remove_logger(logger);
-  }
-
-  Backend::stop();
-  REQUIRE_FALSE(Backend::is_running());
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/SingleFrontendThreadTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/SingleFrontendThreadTest.cpp
deleted file mode 100644
index 3cd76d7..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/SingleFrontendThreadTest.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("single_frontend_thread")
-{
-  static constexpr size_t number_of_messages = 10000;
-  static constexpr char const* filename = "single_frontend_thread.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  for (size_t i = 0; i < number_of_messages; ++i)
-  {
-    LOG_INFO(logger, "This is message {}", i);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), number_of_messages);
-
-  for (size_t i = 0; i < number_of_messages; ++i)
-  {
-    std::string expected_string = logger_name + "       This is message " + std::to_string(i);
-    REQUIRE(quill::testing::file_contains(file_contents, expected_string));
-  }
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/SinkFilterTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/SinkFilterTest.cpp
deleted file mode 100644
index ac12cfb..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/SinkFilterTest.cpp
+++ /dev/null
@@ -1,132 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/**
- * Filter class for our file handler
- */
-class FileFilterA : public Filter
-{
-public:
-  FileFilterA() : Filter("FileFilterA") {}
-
-  QUILL_NODISCARD bool filter(MacroMetadata const* log_metadata, uint64_t log_timestamp, std::string_view thread_id,
-                              std::string_view thread_name, std::string_view logger_name,
-                              LogLevel log_level, std::string_view log_message) noexcept override
-  {
-    if (log_metadata->log_level() < LogLevel::Warning)
-    {
-      return true;
-    }
-    return false;
-  }
-};
-
-/**
- * Filter for the stdout handler
- */
-class FileFilterB : public Filter
-{
-public:
-  FileFilterB() : Filter("FileFilterB") {}
-
-  QUILL_NODISCARD bool filter(MacroMetadata const* log_metadata, uint64_t log_timestamp, std::string_view thread_id,
-                              std::string_view thread_name, std::string_view logger_name,
-                              LogLevel log_level, std::string_view log_message) noexcept override
-  {
-    if (log_metadata->log_level() >= LogLevel::Warning)
-    {
-      return true;
-    }
-    return false;
-  }
-};
-
-/***/
-TEST_CASE("sink_filter")
-{
-  static constexpr char const* filename_a = "sink_filter_a.log";
-  static constexpr char const* filename_b = "sink_filter_b.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  // Set writing logging to a file
-  auto file_sink_a = Frontend::create_or_get_sink<FileSink>(
-    filename_a,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  // log to filename_a anything below warning
-  std::unique_ptr<Filter> filter_a = std::make_unique<FileFilterA>();
-
-  // Also test get_filter_name()
-  REQUIRE_EQ(filter_a->get_filter_name(), std::string_view{"FileFilterA"});
-
-  // Add the filter
-  file_sink_a->add_filter(std::move(filter_a));
-
-  // Try to add the same again (same name)
-  std::unique_ptr<Filter> filter_a_2 = std::make_unique<FileFilterA>();
-  REQUIRE_EQ(filter_a_2->get_filter_name(), std::string_view{"FileFilterA"});
-  REQUIRE_THROWS_AS(file_sink_a->add_filter(std::move(filter_a_2)), QuillError);
-
-  auto file_sink_b = Frontend::create_or_get_sink<FileSink>(
-    filename_b,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  // log to filename_b warning, error, critical
-  file_sink_b->add_filter(std::make_unique<FileFilterB>());
-
-  Logger* logger =
-    Frontend::create_or_get_logger(logger_name, {std::move(file_sink_a), std::move(file_sink_b)});
-
-  LOG_INFO(logger, "Lorem ipsum dolor sit amet, consectetur adipiscing elit");
-  LOG_ERROR(logger, "Nulla tempus, libero at dignissim viverra, lectus libero finibus ante");
-
-  // Let all log get flushed to the file
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents_a = quill::testing::file_contents(filename_a);
-  REQUIRE_EQ(file_contents_a.size(), 1);
-  REQUIRE(quill::testing::file_contains(
-    file_contents_a,
-    std::string{"LOG_INFO      " + logger_name + "       Lorem ipsum dolor sit amet, consectetur adipiscing elit"}));
-
-  std::vector<std::string> const file_contents_b = quill::testing::file_contents(filename_b);
-  REQUIRE_EQ(file_contents_b.size(), 1);
-  REQUIRE(quill::testing::file_contains(
-    file_contents_b,
-    std::string{"LOG_ERROR     " + logger_name +
-                "       Nulla tempus, libero at dignissim viverra, lectus libero finibus ante"}));
-
-  testing::remove_file(filename_a);
-  testing::remove_file(filename_b);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/SinkLogLevelFilterTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/SinkLogLevelFilterTest.cpp
deleted file mode 100644
index aa9a7cb..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/SinkLogLevelFilterTest.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("sink_log_level_filter")
-{
-  static constexpr char const* filename_a = "sink_log_level_filter_a.log";
-  static constexpr char const* filename_b = "sink_log_level_filter_b.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  // Set writing logging to a file
-  auto file_sink_a = Frontend::create_or_get_sink<FileSink>(
-    filename_a,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  // Set filters to our handlers
-  REQUIRE_EQ(file_sink_a->get_log_level_filter(), LogLevel::TraceL3);
-  file_sink_a->set_log_level_filter(LogLevel::Info);
-  REQUIRE_EQ(file_sink_a->get_log_level_filter(), LogLevel::Info);
-
-  auto file_sink_b = Frontend::create_or_get_sink<FileSink>(
-    filename_b,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  // log to filename_b warning, error, critical
-  REQUIRE_EQ(file_sink_b->get_log_level_filter(), LogLevel::TraceL3);
-  file_sink_b->set_log_level_filter(LogLevel::Error);
-  REQUIRE_EQ(file_sink_b->get_log_level_filter(), LogLevel::Error);
-
-  Logger* logger =
-    Frontend::create_or_get_logger(logger_name, {std::move(file_sink_a), std::move(file_sink_b)});
-
-  LOG_INFO(logger, "Lorem ipsum dolor sit amet, consectetur adipiscing elit");
-  LOG_ERROR(logger, "Nulla tempus, libero at dignissim viverra, lectus libero finibus ante");
-
-  // Let all log get flushed to the file
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents_a = quill::testing::file_contents(filename_a);
-  REQUIRE_EQ(file_contents_a.size(), 2);
-  REQUIRE(quill::testing::file_contains(
-    file_contents_a,
-    std::string{"LOG_INFO      " + logger_name + "       Lorem ipsum dolor sit amet, consectetur adipiscing elit"}));
-  REQUIRE(quill::testing::file_contains(
-    file_contents_a,
-    std::string{"LOG_ERROR     " + logger_name +
-                "       Nulla tempus, libero at dignissim viverra, lectus libero finibus ante"}));
-
-  std::vector<std::string> const file_contents_b = quill::testing::file_contents(filename_b);
-  REQUIRE_EQ(file_contents_b.size(), 1);
-  REQUIRE(quill::testing::file_contains(
-    file_contents_b,
-    std::string{"LOG_ERROR     " + logger_name +
-                "       Nulla tempus, libero at dignissim viverra, lectus libero finibus ante"}));
-
-  testing::remove_file(filename_a);
-  testing::remove_file(filename_b);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdArrayLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdArrayLoggingTest.cpp
deleted file mode 100644
index 8ae4193..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdArrayLoggingTest.cpp
+++ /dev/null
@@ -1,209 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/std/Array.h"
-
-#include <array>
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("std_array_logging")
-{
-  static constexpr char const* filename = "std_array_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::array<bool, 2> b = {true, false};
-    LOG_INFO(logger, "v {}", b);
-
-    std::array<char, 2> c = {'a', 'c'};
-    LOG_INFO(logger, "c {}", c);
-
-    std::array<short, 2> si = {-12, 10};
-    LOG_INFO(logger, "si {}", si);
-
-    std::array<int, 2> i = {-123, 1};
-    LOG_INFO(logger, "i {}", i);
-
-    std::array<long, 2> li = {9876, 1232};
-    LOG_INFO(logger, "li {}", li);
-
-    std::array<long long, 2> lli = {321, 231};
-    LOG_INFO(logger, "lli {}", lli);
-
-    std::array<unsigned short, 2> usi = {15, 2};
-    LOG_INFO(logger, "usi {}", usi);
-
-    std::array<unsigned int, 2> ui = {123, 2};
-    LOG_INFO(logger, "ui {}", ui);
-
-    std::array<unsigned long, 2> uli = {3213, 2876};
-    LOG_INFO(logger, "uli {}", uli);
-
-    std::array<unsigned long long, 2> ulli = {321, 1321};
-    LOG_INFO(logger, "ulli {}", ulli);
-
-    std::array<float, 2> f = {111.1f, 323.31f};
-    LOG_INFO(logger, "f {}", f);
-
-    std::array<double, 2> d = {12.1, 3213213.123};
-    LOG_INFO(logger, "d {}", d);
-
-    std::array<int, 2> const& cri = i;
-    LOG_INFO(logger, "cri {}", cri);
-
-    std::array<int, 2>& ci = i;
-    LOG_INFO(logger, "ci {}", ci);
-
-    std::array<std::string, 2> sa = {"test", "string"};
-    LOG_INFO(logger, "sa {}", sa);
-
-    std::array<std::string_view, 2> sva = {"test", "string_view"};
-    LOG_INFO(logger, "sva {}", sva);
-
-    std::array<char const*, 4> scva = {"c style", "string test", "test", "log"};
-    LOG_INFO(logger, "scva {}", scva);
-
-    std::array<std::array<int, 2>, 3> aai = {{{321, 123}, {444, 333}, {111, 222}}};
-    LOG_INFO(logger, "aai {}", aai);
-
-    std::array<std::array<char const*, 2>, 3> aacs = {
-      {{"one", "two"}, {"three", "four"}, {"five", "six"}}};
-    LOG_INFO(logger, "aacs {}", aacs);
-
-    std::array<std::array<std::array<char const*, 2>, 2>, 3> aaacs = {
-      {{{{"one", "two"}, {"three", "four"}}},
-       {{{"five", "six"}, {"seven", "eight"}}},
-       {{{"nine", "ten"}, {"eleven", "twelve"}}}}};
-    LOG_INFO(logger, "aaacs {}", aaacs);
-
-    std::array<std::array<std::array<std::string, 2>, 2>, 3> aaabcs = {
-      {{{{"std_one", "two"}, {"three", "four"}}},
-       {{{"five", "six"}, {"seven", "eight"}}},
-       {{{"std_nine", "ten"}, {"eleven", "twelve"}}}}};
-    LOG_INFO(logger, "aaabcs {}", aaabcs);
-
-    std::array<std::array<std::array<std::string_view, 2>, 2>, 3> aaaccs = {
-      {{{{"std_one", "two"}, {"three_std", "four"}}},
-       {{{"five", "six"}, {"seven_std", "eight"}}},
-       {{{"std_nine", "ten"}, {"eleven", "twelve"}}}}};
-    LOG_INFO(logger, "aaaccs {}", aaaccs);
-
-    LOG_INFO(logger, "scva {} sa {} ulli {} scva {} sa {} aaacs {} aai {}", scva, sa, ulli, scva, sa, aaacs, aai);
-
-    std::array<int, 4> empt{};
-    LOG_INFO(logger, "empt {}", empt);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       v [true, false]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c ['a', 'c']"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       si [-12, 10]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       i [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       li [9876, 1232]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       lli [321, 231]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       usi [15, 2]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ui [123, 2]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uli [3213, 2876]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ulli [321, 1321]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       f [111.1, 323.31]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       d [12.1, 3213213.123]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cri [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ci [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sa [\"test\", \"string\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sva [\"test\", \"string_view\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva [\"c style\", \"string test\", \"test\", \"log\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aai [[321, 123], [444, 333], [111, 222]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_INFO      " + logger_name +
-                "       aacs [[\"one\", \"two\"], [\"three\", \"four\"], [\"five\", \"six\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aaabcs [[[\"std_one\", \"two\"], [\"three\", \"four\"]], [[\"five\", \"six\"], [\"seven\", \"eight\"]], [[\"std_nine\", \"ten\"], [\"eleven\", \"twelve\"]]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aaaccs [[[\"std_one\", \"two\"], [\"three_std\", \"four\"]], [[\"five\", \"six\"], [\"seven_std\", \"eight\"]], [[\"std_nine\", \"ten\"], [\"eleven\", \"twelve\"]]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aaacs [[[\"one\", \"two\"], [\"three\", \"four\"]], [[\"five\", \"six\"], [\"seven\", \"eight\"]], [[\"nine\", \"ten\"], [\"eleven\", \"twelve\"]]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva [\"c style\", \"string test\", \"test\", \"log\"] sa [\"test\", \"string\"] ulli [321, 1321] scva [\"c style\", \"string test\", \"test\", \"log\"] sa [\"test\", \"string\"] aaacs [[[\"one\", \"two\"], [\"three\", \"four\"]], [[\"five\", \"six\"], [\"seven\", \"eight\"]], [[\"nine\", \"ten\"], [\"eleven\", \"twelve\"]]] aai [[321, 123], [444, 333], [111, 222]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empt [0, 0, 0, 0]"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdDequeLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdDequeLoggingTest.cpp
deleted file mode 100644
index 1f4262e..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdDequeLoggingTest.cpp
+++ /dev/null
@@ -1,250 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/std/Deque.h"
-
-#include <cstdio>
-#include <deque>
-#include <string>
-#include <string_view>
-
-using namespace quill;
-
-/***/
-TEST_CASE("std_deque_logging")
-{
-  static constexpr char const* filename = "std_deque_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::deque<char> c = {'a', 'c'};
-    LOG_INFO(logger, "c {}", c);
-
-    std::deque<short> si = {-12, 10};
-    LOG_INFO(logger, "si {}", si);
-
-    std::deque<int> i = {-123, 1};
-    LOG_INFO(logger, "i {}", i);
-
-    std::deque<long> li = {9876, 1232};
-    LOG_INFO(logger, "li {}", li);
-
-    std::deque<long long> lli = {321, 231};
-    LOG_INFO(logger, "lli {}", lli);
-
-    std::deque<unsigned short> usi = {15, 2};
-    LOG_INFO(logger, "usi {}", usi);
-
-    std::deque<unsigned int> ui = {123, 2};
-    LOG_INFO(logger, "ui {}", ui);
-
-    std::deque<unsigned long> uli = {3213, 2876};
-    LOG_INFO(logger, "uli {}", uli);
-
-    std::deque<unsigned long long> ulli = {321, 1321};
-    LOG_INFO(logger, "ulli {}", ulli);
-
-    std::deque<float> f = {111.1f, 323.31f};
-    LOG_INFO(logger, "f {}", f);
-
-    std::deque<double> d = {12.1, 3213213.123};
-    LOG_INFO(logger, "d {}", d);
-
-    std::deque<int> const& cri = i;
-    LOG_INFO(logger, "cri {}", cri);
-
-    std::deque<int>& ci = i;
-    LOG_INFO(logger, "ci {}", ci);
-
-    std::deque<std::string> sa = {"test", "string"};
-    LOG_INFO(logger, "sa {}", sa);
-
-    std::deque<std::string_view> sva = {"test", "string_view"};
-    LOG_INFO(logger, "sva {}", sva);
-
-    std::deque<char const*> scva = {"c style", "string test", "test", "log"};
-    LOG_INFO(logger, "scva {}", scva);
-
-    std::deque<std::deque<int>> aai = {{{321, 123}, {444, 333}, {111, 222}}};
-    LOG_INFO(logger, "aai {}", aai);
-
-    std::deque<std::deque<char const*>> aacs = {
-      {{"one", "two"}, {"three", "four"}, {"five", "six"}}};
-    LOG_INFO(logger, "aacs {}", aacs);
-
-    std::deque<std::deque<std::deque<char const*>>> aaacs = {
-      {{{{"one", "two"}, {"three", "four"}}},
-       {{{"five", "six"}, {"seven", "eight"}}},
-       {{{"nine", "ten"}, {"eleven", "twelve"}}}}};
-    LOG_INFO(logger, "aaacs {}", aaacs);
-
-    {
-      std::deque<std::deque<std::deque<std::string>>> aaabcs;
-
-      // First outer deque
-      std::deque<std::deque<std::string>> first_outer = {{"std_one", "two"}, {"three", "four"}};
-
-      // Second outer deque
-      std::deque<std::deque<std::string>> second_outer = {{"five", "six"}, {"seven", "eight"}};
-
-      // Third outer deque
-      std::deque<std::deque<std::string>> third_outer = {{"std_nine", "ten"}, {"eleven", "twelve"}};
-
-      aaabcs.push_back(first_outer);
-      aaabcs.push_back(second_outer);
-      aaabcs.push_back(third_outer);
-
-      LOG_INFO(logger, "aaabcs {}", aaabcs);
-    }
-
-    {
-      std::deque<std::deque<std::deque<std::string>>> aaaccs;
-
-      // First outer deque
-      std::deque<std::deque<std::string>> first_outer = {{"std_one", "two"}, {"three_std", "four"}};
-
-      // Second outer deque
-      std::deque<std::deque<std::string>> second_outer = {{"five", "six"}, {"seven_std", "eight"}};
-
-      // Third outer deque
-      std::deque<std::deque<std::string>> third_outer = {{"std_nine", "ten"}, {"eleven", "twelve"}};
-
-      aaaccs.push_back(first_outer);
-      aaaccs.push_back(second_outer);
-      aaaccs.push_back(third_outer);
-
-      LOG_INFO(logger, "aaaccs {}", aaaccs);
-    }
-
-    LOG_INFO(logger, "scva {} sa {} ulli {} scva {} sa {} aaacs {} aai {}", scva, sa, ulli, scva, sa, aaacs, aai);
-
-    std::deque<int> loopv;
-    for (int iter = 0; iter < 100; ++iter)
-    {
-      loopv.push_back(iter);
-    }
-
-    LOG_INFO(logger, "loopv {}", loopv);
-
-    std::deque<std::string> loopsv;
-    for (int iter = 0; iter < 100; ++iter)
-    {
-      loopsv.push_back(std::to_string(iter));
-    }
-
-    LOG_INFO(logger, "loopsv {}", loopsv);
-
-    std::deque<int> empt;
-    LOG_INFO(logger, "empt {}", empt);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c ['a', 'c']"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       si [-12, 10]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       i [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       li [9876, 1232]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       lli [321, 231]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       usi [15, 2]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ui [123, 2]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uli [3213, 2876]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ulli [321, 1321]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       f [111.1, 323.31]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       d [12.1, 3213213.123]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cri [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ci [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sa [\"test\", \"string\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sva [\"test\", \"string_view\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva [\"c style\", \"string test\", \"test\", \"log\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aai [[321, 123], [444, 333], [111, 222]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_INFO      " + logger_name +
-                "       aacs [[\"one\", \"two\"], [\"three\", \"four\"], [\"five\", \"six\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aaabcs [[[\"std_one\", \"two\"], [\"three\", \"four\"]], [[\"five\", \"six\"], [\"seven\", \"eight\"]], [[\"std_nine\", \"ten\"], [\"eleven\", \"twelve\"]]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aaaccs [[[\"std_one\", \"two\"], [\"three_std\", \"four\"]], [[\"five\", \"six\"], [\"seven_std\", \"eight\"]], [[\"std_nine\", \"ten\"], [\"eleven\", \"twelve\"]]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aaacs [[[\"one\", \"two\"], [\"three\", \"four\"]], [[\"five\", \"six\"], [\"seven\", \"eight\"]], [[\"nine\", \"ten\"], [\"eleven\", \"twelve\"]]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva [\"c style\", \"string test\", \"test\", \"log\"] sa [\"test\", \"string\"] ulli [321, 1321] scva [\"c style\", \"string test\", \"test\", \"log\"] sa [\"test\", \"string\"] aaacs [[[\"one\", \"two\"], [\"three\", \"four\"]], [[\"five\", \"six\"], [\"seven\", \"eight\"]], [[\"nine\", \"ten\"], [\"eleven\", \"twelve\"]]] aai [[321, 123], [444, 333], [111, 222]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopv [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 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, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopsv [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"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\", \"36\", \"37\", \"38\", \"39\", \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\", \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\", \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\", \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\", \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\", \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empt []"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdFilesystemPathLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdFilesystemPathLoggingTest.cpp
deleted file mode 100644
index 17d54a8..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdFilesystemPathLoggingTest.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/core/Filesystem.h"
-#include "quill/sinks/FileSink.h"
-
-#include "quill/std/FilesystemPath.h"
-
-#include <array>
-#include <cstdio>
-#include <filesystem>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("std_filesystem_path_logging")
-{
-  static constexpr char const* filename = "std_filesystem_path_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    fs::path sp{"/usr/local/bin"};
-    LOG_INFO(logger, "sp {} {} {}", sp, sp, sp);
-    LOG_INFO(logger, "sp_2 {} {} {}", sp, sp, sp);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sp /usr/local/bin /usr/local/bin /usr/local/bin"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sp_2 /usr/local/bin /usr/local/bin /usr/local/bin"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdForwardListLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdForwardListLoggingTest.cpp
deleted file mode 100644
index a0da3a8..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdForwardListLoggingTest.cpp
+++ /dev/null
@@ -1,161 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/std/ForwardList.h"
-
-#include <cstdio>
-#include <forward_list>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("std_forward_list_logging")
-{
-  static constexpr char const* filename = "std_forward_list_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::forward_list<char> c = {'a', 'c'};
-    LOG_INFO(logger, "c {}", c);
-
-    std::forward_list<short> si = {-12, 10};
-    LOG_INFO(logger, "si {}", si);
-
-    std::forward_list<int> i = {-123, 1};
-    LOG_INFO(logger, "i {}", i);
-
-    std::forward_list<long> li = {9876, 1232};
-    LOG_INFO(logger, "li {}", li);
-
-    std::forward_list<long long> lli = {321, 231};
-    LOG_INFO(logger, "lli {}", lli);
-
-    std::forward_list<unsigned short> usi = {15, 2};
-    LOG_INFO(logger, "usi {}", usi);
-
-    std::forward_list<unsigned int> ui = {123, 2};
-    LOG_INFO(logger, "ui {}", ui);
-
-    std::forward_list<unsigned long> uli = {3213, 2876};
-    LOG_INFO(logger, "uli {}", uli);
-
-    std::forward_list<unsigned long long> ulli = {321, 1321};
-    LOG_INFO(logger, "ulli {}", ulli);
-
-    std::forward_list<float> f = {111.1f, 323.31f};
-    LOG_INFO(logger, "f {}", f);
-
-    std::forward_list<double> d = {12.1, 3213213.123};
-    LOG_INFO(logger, "d {}", d);
-
-    std::forward_list<int> const& cri = i;
-    LOG_INFO(logger, "cri {}", cri);
-
-    std::forward_list<int>& ci = i;
-    LOG_INFO(logger, "ci {}", ci);
-
-    std::forward_list<std::string> sa = {"test", "string"};
-    LOG_INFO(logger, "sa {}", sa);
-
-    std::forward_list<std::string_view> sva = {"test", "string_view"};
-    LOG_INFO(logger, "sva {}", sva);
-
-    std::forward_list<char const*> scva = {"c style", "string test", "test", "log"};
-    LOG_INFO(logger, "scva {}", scva);
-
-    LOG_INFO(logger, "scva {} sa {} ulli {} scva {} sa {}", scva, sa, ulli, scva, sa);
-
-    std::forward_list<int> empt;
-    LOG_INFO(logger, "empt {}", empt);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c ['a', 'c']"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       si [-12, 10]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       i [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       li [9876, 1232]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       lli [321, 231]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       usi [15, 2]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ui [123, 2]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uli [3213, 2876]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ulli [321, 1321]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       f [111.1, 323.31]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       d [12.1, 3213213.123]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cri [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ci [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sa [\"test\", \"string\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sva [\"test\", \"string_view\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva [\"c style\", \"string test\", \"test\", \"log\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva [\"c style\", \"string test\", \"test\", \"log\"] sa [\"test\", \"string\"] ulli [321, 1321] scva [\"c style\", \"string test\", \"test\", \"log\"] sa [\"test\", \"string\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empt []"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdListLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdListLoggingTest.cpp
deleted file mode 100644
index 22f4099..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdListLoggingTest.cpp
+++ /dev/null
@@ -1,161 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/std/List.h"
-
-#include <cstdio>
-#include <list>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("std_list_logging")
-{
-  static constexpr char const* filename = "std_list_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::list<char> c = {'a', 'c'};
-    LOG_INFO(logger, "c {}", c);
-
-    std::list<short> si = {-12, 10};
-    LOG_INFO(logger, "si {}", si);
-
-    std::list<int> i = {-123, 1};
-    LOG_INFO(logger, "i {}", i);
-
-    std::list<long> li = {9876, 1232};
-    LOG_INFO(logger, "li {}", li);
-
-    std::list<long long> lli = {321, 231};
-    LOG_INFO(logger, "lli {}", lli);
-
-    std::list<unsigned short> usi = {15, 2};
-    LOG_INFO(logger, "usi {}", usi);
-
-    std::list<unsigned int> ui = {123, 2};
-    LOG_INFO(logger, "ui {}", ui);
-
-    std::list<unsigned long> uli = {3213, 2876};
-    LOG_INFO(logger, "uli {}", uli);
-
-    std::list<unsigned long long> ulli = {321, 1321};
-    LOG_INFO(logger, "ulli {}", ulli);
-
-    std::list<float> f = {111.1f, 323.31f};
-    LOG_INFO(logger, "f {}", f);
-
-    std::list<double> d = {12.1, 3213213.123};
-    LOG_INFO(logger, "d {}", d);
-
-    std::list<int> const& cri = i;
-    LOG_INFO(logger, "cri {}", cri);
-
-    std::list<int>& ci = i;
-    LOG_INFO(logger, "ci {}", ci);
-
-    std::list<std::string> sa = {"test", "string"};
-    LOG_INFO(logger, "sa {}", sa);
-
-    std::list<std::string_view> sva = {"test", "string_view"};
-    LOG_INFO(logger, "sva {}", sva);
-
-    std::list<char const*> scva = {"c style", "string test", "test", "log"};
-    LOG_INFO(logger, "scva {}", scva);
-
-    LOG_INFO(logger, "scva {} sa {} ulli {} scva {} sa {}", scva, sa, ulli, scva, sa);
-
-    std::list<int> empt;
-    LOG_INFO(logger, "empt {}", empt);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c ['a', 'c']"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       si [-12, 10]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       i [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       li [9876, 1232]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       lli [321, 231]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       usi [15, 2]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ui [123, 2]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uli [3213, 2876]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ulli [321, 1321]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       f [111.1, 323.31]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       d [12.1, 3213213.123]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cri [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ci [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sa [\"test\", \"string\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sva [\"test\", \"string_view\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva [\"c style\", \"string test\", \"test\", \"log\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva [\"c style\", \"string test\", \"test\", \"log\"] sa [\"test\", \"string\"] ulli [321, 1321] scva [\"c style\", \"string test\", \"test\", \"log\"] sa [\"test\", \"string\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empt []"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdMapLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdMapLoggingTest.cpp
deleted file mode 100644
index 081b1ca..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdMapLoggingTest.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/std/Map.h"
-
-#include <cstdio>
-#include <cstring>
-#include <map>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-struct CStringComparator
-{
-  bool operator()(char const* a, char const* b) const { return std::strcmp(a, b) < 0; }
-};
-
-/***/
-TEST_CASE("std_map_logging")
-{
-  static constexpr char const* filename = "std_map_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::map<int, double> idm = {{111, 3213.21}, {222, 321.19}, {333, 5555.99}};
-    LOG_INFO(logger, "idm {}", idm);
-
-    std::map<int, std::string> loopv;
-    for (int iter = 0; iter < 25; ++iter)
-    {
-      loopv.emplace(iter, std::to_string(iter));
-    }
-    LOG_INFO(logger, "loopv {}", loopv);
-
-    std::map<std::string, std::string> loopsv;
-    for (int iter = 0; iter < 25; ++iter)
-    {
-      loopsv.emplace(std::to_string(iter), std::to_string(iter * 2));
-    }
-    LOG_INFO(logger, "loopsv {}", loopv);
-
-    std::map<char const*, char const*, CStringComparator> ccm = {
-      {"4", "400"}, {"3", "300"}, {"1", "100"}, {"2", "200"}};
-    LOG_INFO(logger, "ccm {}", ccm);
-
-    std::map<char const*, int, CStringComparator> cim = {{"4", 4}, {"3", 3}, {"1", 1}, {"2", 2}};
-    LOG_INFO(logger, "cim {}", cim);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       idm {111: 3213.21, 222: 321.19, 333: 5555.99}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopv {0: \"0\", 1: \"1\", 2: \"2\", 3: \"3\", 4: \"4\", 5: \"5\", 6: \"6\", 7: \"7\", 8: \"8\", 9: \"9\", 10: \"10\", 11: \"11\", 12: \"12\", 13: \"13\", 14: \"14\", 15: \"15\", 16: \"16\", 17: \"17\", 18: \"18\", 19: \"19\", 20: \"20\", 21: \"21\", 22: \"22\", 23: \"23\", 24: \"24\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopsv {0: \"0\", 1: \"1\", 2: \"2\", 3: \"3\", 4: \"4\", 5: \"5\", 6: \"6\", 7: \"7\", 8: \"8\", 9: \"9\", 10: \"10\", 11: \"11\", 12: \"12\", 13: \"13\", 14: \"14\", 15: \"15\", 16: \"16\", 17: \"17\", 18: \"18\", 19: \"19\", 20: \"20\", 21: \"21\", 22: \"22\", 23: \"23\", 24: \"24\""}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_INFO      " + logger_name +
-                "       ccm {\"1\": \"100\", \"2\": \"200\", \"3\": \"300\", \"4\": \"400\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cim {\"1\": 1, \"2\": 2, \"3\": 3, \"4\": 4}"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdMultiMapLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdMultiMapLoggingTest.cpp
deleted file mode 100644
index d2a0713..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdMultiMapLoggingTest.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/std/Map.h"
-
-#include <cstdio>
-#include <cstring>
-#include <map>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-struct CStringComparator
-{
-  bool operator()(char const* a, char const* b) const { return std::strcmp(a, b) < 0; }
-};
-
-/***/
-TEST_CASE("std_multimap_logging")
-{
-  static constexpr char const* filename = "std_multimap_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::multimap<int, double> idm = {{111, 3213.21}, {222, 321.19}, {333, 5555.99}};
-    LOG_INFO(logger, "idm {}", idm);
-
-    std::multimap<int, std::string> loopv;
-    for (int iter = 0; iter < 25; ++iter)
-    {
-      loopv.emplace(iter, std::to_string(iter));
-    }
-    LOG_INFO(logger, "loopv {}", loopv);
-
-    std::multimap<std::string, std::string> loopsv;
-    for (int iter = 0; iter < 25; ++iter)
-    {
-      loopsv.emplace(std::to_string(iter), std::to_string(iter * 2));
-    }
-    LOG_INFO(logger, "loopsv {}", loopv);
-
-    std::multimap<char const*, char const*, CStringComparator> ccm = {
-      {"4", "400"}, {"3", "300"}, {"1", "100"}, {"2", "200"}};
-    LOG_INFO(logger, "ccm {}", ccm);
-
-    std::multimap<char const*, int, CStringComparator> cim = {{"4", 4}, {"3", 3}, {"1", 1}, {"2", 2}};
-    LOG_INFO(logger, "cim {}", cim);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       idm {111: 3213.21, 222: 321.19, 333: 5555.99}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopv {0: \"0\", 1: \"1\", 2: \"2\", 3: \"3\", 4: \"4\", 5: \"5\", 6: \"6\", 7: \"7\", 8: \"8\", 9: \"9\", 10: \"10\", 11: \"11\", 12: \"12\", 13: \"13\", 14: \"14\", 15: \"15\", 16: \"16\", 17: \"17\", 18: \"18\", 19: \"19\", 20: \"20\", 21: \"21\", 22: \"22\", 23: \"23\", 24: \"24\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopsv {0: \"0\", 1: \"1\", 2: \"2\", 3: \"3\", 4: \"4\", 5: \"5\", 6: \"6\", 7: \"7\", 8: \"8\", 9: \"9\", 10: \"10\", 11: \"11\", 12: \"12\", 13: \"13\", 14: \"14\", 15: \"15\", 16: \"16\", 17: \"17\", 18: \"18\", 19: \"19\", 20: \"20\", 21: \"21\", 22: \"22\", 23: \"23\", 24: \"24\""}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_INFO      " + logger_name +
-                "       ccm {\"1\": \"100\", \"2\": \"200\", \"3\": \"300\", \"4\": \"400\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cim {\"1\": 1, \"2\": 2, \"3\": 3, \"4\": 4}"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdMultiSetLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdMultiSetLoggingTest.cpp
deleted file mode 100644
index 04b53b5..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdMultiSetLoggingTest.cpp
+++ /dev/null
@@ -1,218 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/std/Set.h"
-
-#include <cstdio>
-#include <cstring>
-#include <set>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-struct CStringComparator
-{
-  bool operator()(char const* a, char const* b) const { return std::strcmp(a, b) < 0; }
-};
-
-/***/
-TEST_CASE("std_multiset_logging")
-{
-  static constexpr char const* filename = "std_multiset_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::multiset<char> c = {'a', 'c'};
-    LOG_INFO(logger, "c {}", c);
-
-    std::multiset<short> si = {-12, 10};
-    LOG_INFO(logger, "si {}", si);
-
-    std::multiset<int> i = {-123, 1};
-    LOG_INFO(logger, "i {}", i);
-
-    std::multiset<long> li = {9876, 1232};
-    LOG_INFO(logger, "li {}", li);
-
-    std::multiset<long long> lli = {321, 231};
-    LOG_INFO(logger, "lli {}", lli);
-
-    std::multiset<unsigned short> usi = {15, 2};
-    LOG_INFO(logger, "usi {}", usi);
-
-    std::multiset<unsigned int> ui = {123, 2};
-    LOG_INFO(logger, "ui {}", ui);
-
-    std::multiset<unsigned long> uli = {3213, 2876};
-    LOG_INFO(logger, "uli {}", uli);
-
-    std::multiset<unsigned long long> ulli = {321, 1321};
-    LOG_INFO(logger, "ulli {}", ulli);
-
-    std::multiset<float> f = {111.1f, 323.31f};
-    LOG_INFO(logger, "f {}", f);
-
-    std::multiset<double> d = {12.1, 3213213.123};
-    LOG_INFO(logger, "d {}", d);
-
-    std::multiset<int> const& cri = i;
-    LOG_INFO(logger, "cri {}", cri);
-
-    std::multiset<int>& ci = i;
-    LOG_INFO(logger, "ci {}", ci);
-
-    std::multiset<std::string> sa = {"test", "string"};
-    LOG_INFO(logger, "sa {}", sa);
-
-    std::multiset<std::string_view> sva = {"test", "string_view"};
-    LOG_INFO(logger, "sva {}", sva);
-
-    std::multiset<char const*, CStringComparator> scva = {"c_style", "aa", "string_test", "test",
-                                                          "log"};
-    LOG_INFO(logger, "scva {}", scva);
-
-    std::multiset<std::multiset<int>> aai = {{{321, 123}, {444, 333}, {111, 222}}};
-    LOG_INFO(logger, "aai {}", aai);
-
-    {
-      std::multiset<std::multiset<char const*, CStringComparator>> aacs = {
-        {{"one", "two"}, {"three", "four"}, {"five", "six"}}};
-      LOG_INFO(logger, "aacs {}", aacs);
-    }
-
-    {
-      std::multiset<std::multiset<std::multiset<char const*, CStringComparator>>> aaacs = {
-        {{{{"one", "two"}, {"three", "four"}}},
-         {{{"five", "six"}, {"seven", "eight"}}},
-         {{{"nine", "ten"}, {"eleven", "twelve"}}}}};
-      LOG_INFO(logger, "aaacs {}", aaacs);
-    }
-
-    LOG_INFO(logger, "scva {} sa {} ulli {} scva {} sa {} aai {}", scva, sa, ulli, scva, sa, aai);
-
-    std::multiset<int> loopv;
-    for (int iter = 0; iter < 100; ++iter)
-    {
-      loopv.insert(iter);
-    }
-
-    LOG_INFO(logger, "loopv {}", loopv);
-
-    std::multiset<std::string> loopsv;
-    for (int iter = 0; iter < 100; ++iter)
-    {
-      loopsv.insert(std::to_string(iter));
-    }
-
-    LOG_INFO(logger, "loopsv {}", loopsv);
-
-    std::multiset<int> empt;
-    LOG_INFO(logger, "empt {}", empt);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c {'a', 'c'}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       si {-12, 10}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       i {-123, 1}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       li {1232, 9876}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       lli {231, 321}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       usi {2, 15}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ui {2, 123}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uli {2876, 3213}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ulli {321, 1321}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       f {111.1, 323.31}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       d {12.1, 3213213.123}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cri {-123, 1}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ci {-123, 1}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sa {\"string\", \"test\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sva {\"string_view\", \"test\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_INFO      " + logger_name +
-                "       scva {\"aa\", \"c_style\", \"log\", \"string_test\", \"test\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aai {{111, 222}, {123, 321}, {333, 444}}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aacs {{"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aaacs {{{"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva {\"aa\", \"c_style\", \"log\", \"string_test\", \"test\"} sa {\"string\", \"test\"} ulli {321, 1321} scva {\"aa\", \"c_style\", \"log\", \"string_test\", \"test\"} sa {\"string\", \"test\"} aai {{111, 222}, {123, 321}, {333, 444}}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopv {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 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, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopsv {\"0\", \"1\", \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\", \"2\", \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\", \"3\", \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\", \"4\", \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\", \"5\", \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\", \"6\", \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\", \"7\", \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\", \"8\", \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\", \"9\", \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empt {}"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdOptionalLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdOptionalLoggingTest.cpp
deleted file mode 100644
index 0627eca..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdOptionalLoggingTest.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include "quill/std/Optional.h"
-
-#include <array>
-#include <cstdio>
-#include <optional>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("std_optional_logging")
-{
-  static constexpr char const* filename = "std_optional_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::optional<int> ei{std::nullopt};
-    LOG_INFO(logger, "ei [{}]", ei);
-
-    std::optional<double> ed{std::nullopt};
-    LOG_INFO(logger, "ed [{}]", ed);
-
-    std::optional<char const*> ccp{"testing"};
-    LOG_INFO(logger, "ccp [{}]", ccp);
-
-    std::optional<std::string> sp{"sp_testing"};
-    LOG_INFO(logger, "sp [{}]", sp);
-
-    std::optional<std::string> esp{std::nullopt};
-    LOG_INFO(logger, "esp [{}]", esp);
-
-    std::optional<std::string_view> svp{"svp_testing"};
-    LOG_INFO(logger, "svp [{}]", svp);
-
-    std::optional<int> i{123321};
-    LOG_INFO(logger, "i [{}]", i);
-
-    std::optional<double> d{333.221};
-    LOG_INFO(logger, "d [{}]", d);
-
-    LOG_INFO(logger, "zzzz [{}] [{}] [{}] [{}] [{}]", d, "test", *svp, *sp, ccp);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ei [none]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ed [none]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ccp [optional(\"testing\")]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sp [optional(\"sp_testing\")]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       esp [none]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       svp [optional(\"svp_testing\")]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       i [optional(123321)]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       d [optional(333.221)]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       zzzz [optional(333.221)] [test] [svp_testing] [sp_testing] [optional(\"testing\")]"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdPairLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdPairLoggingTest.cpp
deleted file mode 100644
index f7201df..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdPairLoggingTest.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include "quill/std/Pair.h"
-
-#include <array>
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("std_pair_logging")
-{
-  static constexpr char const* filename = "std_pair_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::pair<bool, int> b = {true, 312};
-    LOG_INFO(logger, "v {}", b);
-
-    std::pair<std::string, std::string> sa = {"test", "string"};
-    LOG_INFO(logger, "sa {}", sa);
-
-    std::pair<std::string_view, std::string> sva = {"test", "string_view"};
-    LOG_INFO(logger, "sva {}", sva);
-
-    std::pair<char const*, std::string> scva = {"c style", "string test"};
-    LOG_INFO(logger, "scva {}", scva);
-
-    std::pair<std::pair<std::string, std::string_view>, std::pair<const char*, uint32_t>> cp = {
-      {"pair", "testing"}, {"first", 2}};
-    LOG_INFO(logger, "cp {}", cp);
-
-    std::pair<int, double> empt;
-    LOG_INFO(logger, "empt {}", empt);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       v (true, 312)"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sa (\"test\", \"string\")"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sva (\"test\", \"string_view\")"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva (\"c style\", \"string test\")"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cp ((\"pair\", \"testing\"), (\"first\", 2))"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empt (0, 0)"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdSetLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdSetLoggingTest.cpp
deleted file mode 100644
index b7214f7..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdSetLoggingTest.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/std/Set.h"
-
-#include <cstdio>
-#include <cstring>
-#include <set>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-struct CStringComparator
-{
-  bool operator()(char const* a, char const* b) const { return std::strcmp(a, b) < 0; }
-};
-
-/***/
-TEST_CASE("std_set_logging")
-{
-  static constexpr char const* filename = "std_set_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::set<char> c = {'a', 'c'};
-    LOG_INFO(logger, "c {}", c);
-
-    std::set<short> si = {-12, 10};
-    LOG_INFO(logger, "si {}", si);
-
-    std::set<int> i = {-123, 1};
-    LOG_INFO(logger, "i {}", i);
-
-    std::set<long> li = {9876, 1232};
-    LOG_INFO(logger, "li {}", li);
-
-    std::set<long long> lli = {321, 231};
-    LOG_INFO(logger, "lli {}", lli);
-
-    std::set<unsigned short> usi = {15, 2};
-    LOG_INFO(logger, "usi {}", usi);
-
-    std::set<unsigned int> ui = {123, 2};
-    LOG_INFO(logger, "ui {}", ui);
-
-    std::set<unsigned long> uli = {3213, 2876};
-    LOG_INFO(logger, "uli {}", uli);
-
-    std::set<unsigned long long> ulli = {321, 1321};
-    LOG_INFO(logger, "ulli {}", ulli);
-
-    std::set<float> f = {111.1f, 323.31f};
-    LOG_INFO(logger, "f {}", f);
-
-    std::set<double> d = {12.1, 3213213.123};
-    LOG_INFO(logger, "d {}", d);
-
-    std::set<int> const& cri = i;
-    LOG_INFO(logger, "cri {}", cri);
-
-    std::set<int>& ci = i;
-    LOG_INFO(logger, "ci {}", ci);
-
-    std::set<std::string> sa = {"test", "string"};
-    LOG_INFO(logger, "sa {}", sa);
-
-    std::set<std::string_view> sva = {"test", "string_view"};
-    LOG_INFO(logger, "sva {}", sva);
-
-    std::set<char const*, CStringComparator> scva = {"c_style", "aa", "string_test", "test", "log"};
-    LOG_INFO(logger, "scva {}", scva);
-
-    std::set<std::set<int>> aai = {{{321, 123}, {444, 333}, {111, 222}}};
-    LOG_INFO(logger, "aai {}", aai);
-
-    {
-      std::set<std::set<char const*, CStringComparator>> aacs = {
-        {{"one", "two"}, {"three", "four"}, {"five", "six"}}};
-      LOG_INFO(logger, "aacs {}", aacs);
-    }
-
-    {
-      std::set<std::set<std::set<char const*, CStringComparator>>> aaacs = {
-        {{{{"one", "two"}, {"three", "four"}}},
-         {{{"five", "six"}, {"seven", "eight"}}},
-         {{{"nine", "ten"}, {"eleven", "twelve"}}}}};
-      LOG_INFO(logger, "aaacs {}", aaacs);
-    }
-
-    LOG_INFO(logger, "scva {} sa {} ulli {} scva {} sa {} aai {}", scva, sa, ulli, scva, sa, aai);
-
-    std::set<int> loopv;
-    for (int iter = 0; iter < 100; ++iter)
-    {
-      loopv.insert(iter);
-    }
-
-    LOG_INFO(logger, "loopv {}", loopv);
-
-    std::set<std::string> loopsv;
-    for (int iter = 0; iter < 100; ++iter)
-    {
-      loopsv.insert(std::to_string(iter));
-    }
-
-    LOG_INFO(logger, "loopsv {}", loopsv);
-
-    std::set<int> empt;
-    LOG_INFO(logger, "empt {}", empt);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c {'a', 'c'}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       si {-12, 10}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       i {-123, 1}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       li {1232, 9876}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       lli {231, 321}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       usi {2, 15}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ui {2, 123}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uli {2876, 3213}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ulli {321, 1321}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       f {111.1, 323.31}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       d {12.1, 3213213.123}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cri {-123, 1}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ci {-123, 1}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sa {\"string\", \"test\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sva {\"string_view\", \"test\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_INFO      " + logger_name +
-                "       scva {\"aa\", \"c_style\", \"log\", \"string_test\", \"test\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aai {{111, 222}, {123, 321}, {333, 444}}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aacs {{"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aaacs {{{"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva {\"aa\", \"c_style\", \"log\", \"string_test\", \"test\"} sa {\"string\", \"test\"} ulli {321, 1321} scva {\"aa\", \"c_style\", \"log\", \"string_test\", \"test\"} sa {\"string\", \"test\"} aai {{111, 222}, {123, 321}, {333, 444}}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopv {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 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, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopsv {\"0\", \"1\", \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\", \"2\", \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\", \"3\", \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\", \"4\", \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\", \"5\", \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\", \"6\", \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\", \"7\", \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\", \"8\", \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\", \"9\", \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empt {}"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdTupleLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdTupleLoggingTest.cpp
deleted file mode 100644
index f2e92c9..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdTupleLoggingTest.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include "quill/std/Tuple.h"
-
-#include <array>
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <tuple>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("std_tuple_logging")
-{
-  static constexpr char const* filename = "std_tuple_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::tuple<std::string> st{"123456789"};
-    LOG_INFO(logger, "st {}", st);
-
-    std::tuple<std::string, int> et;
-    LOG_INFO(logger, "et {}", et);
-
-    std::tuple<std::string, std::string_view, int, double, char const*, std::string, int> ct{
-      "string", "string_view", 213, 33.12, "c_style", "another_string", 123};
-    LOG_INFO(logger, "ct {}", ct);
-
-    LOG_INFO(logger, "ct {} et {} st {}", ct, et, st);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       st (\"123456789\")"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       et (\"\", 0)"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ct (\"string\", \"string_view\", 213, 33.12, \"c_style\", \"another_string\", 123)"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ct (\"string\", \"string_view\", 213, 33.12, \"c_style\", \"another_string\", 123) et (\"\", 0) st (\"123456789\")"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdUnorderedMapLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdUnorderedMapLoggingTest.cpp
deleted file mode 100644
index 7822afe..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdUnorderedMapLoggingTest.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/std/UnorderedMap.h"
-
-#include <cstdio>
-#include <cstring>
-#include <string>
-#include <string_view>
-#include <unordered_map>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("std_unordered_map_logging")
-{
-  static constexpr char const* filename = "std_unordered_map_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::unordered_map<int, double> idm = {{111, 3213.21}};
-    LOG_INFO(logger, "idm {}", idm);
-
-    std::unordered_map<int, std::string> loopv;
-    for (int iter = 0; iter < 25; ++iter)
-    {
-      loopv.emplace(iter, std::to_string(iter));
-    }
-    LOG_INFO(logger, "loopv {}", loopv);
-
-    std::unordered_map<std::string, std::string> loopsv;
-    for (int iter = 0; iter < 25; ++iter)
-    {
-      loopsv.emplace(std::to_string(iter), std::to_string(iter * 2));
-    }
-    LOG_INFO(logger, "loopsv {}", loopv);
-
-    std::unordered_map<char const*, char const*> ccm = {{"4", "400"}};
-    LOG_INFO(logger, "ccm {}", ccm);
-
-    std::unordered_map<char const*, int> cim = {{"4", 4}};
-    LOG_INFO(logger, "cim {}", cim);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       idm {111: 3213.21}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopv {"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopsv {"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ccm {\"4\": \"400\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cim {\"4\": 4}"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdUnorderedMultiMapLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdUnorderedMultiMapLoggingTest.cpp
deleted file mode 100644
index 1ea45d9..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdUnorderedMultiMapLoggingTest.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/std/UnorderedMap.h"
-
-#include <cstdio>
-#include <cstring>
-#include <string>
-#include <string_view>
-#include <unordered_map>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("std_unordered_multimap_logging")
-{
-  static constexpr char const* filename = "std_unordered_multimap_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::unordered_multimap<int, double> idm = {{111, 3213.21}};
-    LOG_INFO(logger, "idm {}", idm);
-
-    std::unordered_multimap<int, std::string> loopv;
-    for (int iter = 0; iter < 25; ++iter)
-    {
-      loopv.emplace(iter, std::to_string(iter));
-    }
-    LOG_INFO(logger, "loopv {}", loopv);
-
-    std::unordered_multimap<std::string, std::string> loopsv;
-    for (int iter = 0; iter < 25; ++iter)
-    {
-      loopsv.emplace(std::to_string(iter), std::to_string(iter * 2));
-    }
-    LOG_INFO(logger, "loopsv {}", loopv);
-
-    std::unordered_multimap<char const*, char const*> ccm = {{"4", "400"}};
-    LOG_INFO(logger, "ccm {}", ccm);
-
-    std::unordered_multimap<char const*, int> cim = {{"4", 4}};
-    LOG_INFO(logger, "cim {}", cim);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       idm {111: 3213.21}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopv {"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopsv {"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ccm {\"4\": \"400\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cim {\"4\": 4}"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdUnorderedMultiSetLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdUnorderedMultiSetLoggingTest.cpp
deleted file mode 100644
index a293a74..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdUnorderedMultiSetLoggingTest.cpp
+++ /dev/null
@@ -1,184 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/std/UnorderedSet.h"
-
-#include <cstdio>
-#include <cstring>
-#include <string>
-#include <string_view>
-#include <unordered_set>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("std_unordered_multi_set_logging")
-{
-  static constexpr char const* filename = "std_unordered_multi_set_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::unordered_multiset<char> c = {'a'};
-    LOG_INFO(logger, "c {}", c);
-
-    std::unordered_multiset<short> si = {-12};
-    LOG_INFO(logger, "si {}", si);
-
-    std::unordered_multiset<int> i = {-123};
-    LOG_INFO(logger, "i {}", i);
-
-    std::unordered_multiset<long> li = {9876};
-    LOG_INFO(logger, "li {}", li);
-
-    std::unordered_multiset<long long> lli = {321};
-    LOG_INFO(logger, "lli {}", lli);
-
-    std::unordered_multiset<unsigned short> usi = {15};
-    LOG_INFO(logger, "usi {}", usi);
-
-    std::unordered_multiset<unsigned int> ui = {123};
-    LOG_INFO(logger, "ui {}", ui);
-
-    std::unordered_multiset<unsigned long> uli = {3213};
-    LOG_INFO(logger, "uli {}", uli);
-
-    std::unordered_multiset<unsigned long long> ulli = {321};
-    LOG_INFO(logger, "ulli {}", ulli);
-
-    std::unordered_multiset<float> f = {111.1f};
-    LOG_INFO(logger, "f {}", f);
-
-    std::unordered_multiset<double> d = {12.1};
-    LOG_INFO(logger, "d {}", d);
-
-    std::unordered_multiset<int> const& cri = i;
-    LOG_INFO(logger, "cri {}", cri);
-
-    std::unordered_multiset<int>& ci = i;
-    LOG_INFO(logger, "ci {}", ci);
-
-    std::unordered_multiset<std::string> sa = {"test"};
-    LOG_INFO(logger, "sa {}", sa);
-
-    std::unordered_multiset<std::string_view> sva = {"string_view"};
-    LOG_INFO(logger, "sva {}", sva);
-
-    std::unordered_multiset<char const*> scva = {"c_style"};
-    LOG_INFO(logger, "scva {}", scva);
-
-    LOG_INFO(logger, "scva {} sa {} ulli {} scva {} sa {}", scva, sa, ulli, scva, sa);
-
-    std::unordered_multiset<int> loopv;
-    for (int iter = 0; iter < 100; ++iter)
-    {
-      loopv.insert(iter);
-    }
-
-    LOG_INFO(logger, "loopv {}", loopv);
-
-    std::unordered_multiset<std::string> loopsv;
-    for (int iter = 0; iter < 100; ++iter)
-    {
-      loopsv.insert(std::to_string(iter));
-    }
-
-    LOG_INFO(logger, "loopsv {}", loopsv);
-
-    std::unordered_multiset<int> empt;
-    LOG_INFO(logger, "empt {}", empt);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c {'a'}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       si {-12}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       i {-123}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       li {9876}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       lli {321}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       usi {15}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ui {123}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uli {3213}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ulli {321}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       f {111.1}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       d {12.1}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cri {-123}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ci {-123}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sa {\"test\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sva {\"string_view\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva {\"c_style\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva {\"c_style\"} sa {\"test\"} ulli {321} scva {\"c_style\"} sa {\"test\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopv {"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopsv {"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empt {}"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdUnorderedSetLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdUnorderedSetLoggingTest.cpp
deleted file mode 100644
index 0fec236..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdUnorderedSetLoggingTest.cpp
+++ /dev/null
@@ -1,184 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/std/UnorderedSet.h"
-
-#include <cstdio>
-#include <cstring>
-#include <string>
-#include <string_view>
-#include <unordered_set>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("std_unordered_set_logging")
-{
-  static constexpr char const* filename = "std_unordered_set_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::unordered_set<char> c = {'a'};
-    LOG_INFO(logger, "c {}", c);
-
-    std::unordered_set<short> si = {-12};
-    LOG_INFO(logger, "si {}", si);
-
-    std::unordered_set<int> i = {-123};
-    LOG_INFO(logger, "i {}", i);
-
-    std::unordered_set<long> li = {9876};
-    LOG_INFO(logger, "li {}", li);
-
-    std::unordered_set<long long> lli = {321};
-    LOG_INFO(logger, "lli {}", lli);
-
-    std::unordered_set<unsigned short> usi = {15};
-    LOG_INFO(logger, "usi {}", usi);
-
-    std::unordered_set<unsigned int> ui = {123};
-    LOG_INFO(logger, "ui {}", ui);
-
-    std::unordered_set<unsigned long> uli = {3213};
-    LOG_INFO(logger, "uli {}", uli);
-
-    std::unordered_set<unsigned long long> ulli = {321};
-    LOG_INFO(logger, "ulli {}", ulli);
-
-    std::unordered_set<float> f = {111.1f};
-    LOG_INFO(logger, "f {}", f);
-
-    std::unordered_set<double> d = {12.1};
-    LOG_INFO(logger, "d {}", d);
-
-    std::unordered_set<int> const& cri = i;
-    LOG_INFO(logger, "cri {}", cri);
-
-    std::unordered_set<int>& ci = i;
-    LOG_INFO(logger, "ci {}", ci);
-
-    std::unordered_set<std::string> sa = {"test"};
-    LOG_INFO(logger, "sa {}", sa);
-
-    std::unordered_set<std::string_view> sva = {"string_view"};
-    LOG_INFO(logger, "sva {}", sva);
-
-    std::unordered_set<char const*> scva = {"c_style"};
-    LOG_INFO(logger, "scva {}", scva);
-
-    LOG_INFO(logger, "scva {} sa {} ulli {} scva {} sa {}", scva, sa, ulli, scva, sa);
-
-    std::unordered_set<int> loopv;
-    for (int iter = 0; iter < 100; ++iter)
-    {
-      loopv.insert(iter);
-    }
-
-    LOG_INFO(logger, "loopv {}", loopv);
-
-    std::unordered_set<std::string> loopsv;
-    for (int iter = 0; iter < 100; ++iter)
-    {
-      loopsv.insert(std::to_string(iter));
-    }
-
-    LOG_INFO(logger, "loopsv {}", loopsv);
-
-    std::unordered_set<int> empt;
-    LOG_INFO(logger, "empt {}", empt);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c {'a'}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       si {-12}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       i {-123}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       li {9876}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       lli {321}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       usi {15}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ui {123}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uli {3213}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ulli {321}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       f {111.1}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       d {12.1}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cri {-123}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ci {-123}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sa {\"test\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sva {\"string_view\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva {\"c_style\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva {\"c_style\"} sa {\"test\"} ulli {321} scva {\"c_style\"} sa {\"test\"}"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopv {"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopsv {"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empt {}"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StdVectorLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StdVectorLoggingTest.cpp
deleted file mode 100644
index 7b17287..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StdVectorLoggingTest.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-#include "quill/std/Vector.h"
-
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("std_vector_logging")
-{
-  static constexpr char const* filename = "std_vector_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::vector<char> c = {'a', 'c'};
-    LOG_INFO(logger, "c {}", c);
-
-    std::vector<short> si = {-12, 10};
-    LOG_INFO(logger, "si {}", si);
-
-    std::vector<int> i = {-123, 1};
-    LOG_INFO(logger, "i {}", i);
-
-    std::vector<long> li = {9876, 1232};
-    LOG_INFO(logger, "li {}", li);
-
-    std::vector<long long> lli = {321, 231};
-    LOG_INFO(logger, "lli {}", lli);
-
-    std::vector<unsigned short> usi = {15, 2};
-    LOG_INFO(logger, "usi {}", usi);
-
-    std::vector<unsigned int> ui = {123, 2};
-    LOG_INFO(logger, "ui {}", ui);
-
-    std::vector<unsigned long> uli = {3213, 2876};
-    LOG_INFO(logger, "uli {}", uli);
-
-    std::vector<unsigned long long> ulli = {321, 1321};
-    LOG_INFO(logger, "ulli {}", ulli);
-
-    std::vector<float> f = {111.1f, 323.31f};
-    LOG_INFO(logger, "f {}", f);
-
-    std::vector<double> d = {12.1, 3213213.123};
-    LOG_INFO(logger, "d {}", d);
-
-    std::vector<int> const& cri = i;
-    LOG_INFO(logger, "cri {}", cri);
-
-    std::vector<int>& ci = i;
-    LOG_INFO(logger, "ci {}", ci);
-
-    std::vector<std::string> sa = {"test", "string"};
-    LOG_INFO(logger, "sa {}", sa);
-
-    std::vector<std::string_view> sva = {"test", "string_view"};
-    LOG_INFO(logger, "sva {}", sva);
-
-    std::vector<char const*> scva = {"c style", "string test", "test", "log"};
-    LOG_INFO(logger, "scva {}", scva);
-
-    std::vector<std::vector<int>> aai = {{{321, 123}, {444, 333}, {111, 222}}};
-    LOG_INFO(logger, "aai {}", aai);
-
-    std::vector<std::vector<char const*>> aacs = {
-      {{"one", "two"}, {"three", "four"}, {"five", "six"}}};
-    LOG_INFO(logger, "aacs {}", aacs);
-
-    std::vector<std::vector<std::vector<char const*>>> aaacs = {
-      {{{{"one", "two"}, {"three", "four"}}},
-       {{{"five", "six"}, {"seven", "eight"}}},
-       {{{"nine", "ten"}, {"eleven", "twelve"}}}}};
-    LOG_INFO(logger, "aaacs {}", aaacs);
-
-    {
-      std::vector<std::vector<std::vector<std::string>>> aaabcs;
-
-      // First outer vector
-      std::vector<std::vector<std::string>> first_outer = {{"std_one", "two"}, {"three", "four"}};
-
-      // Second outer vector
-      std::vector<std::vector<std::string>> second_outer = {{"five", "six"}, {"seven", "eight"}};
-
-      // Third outer vector
-      std::vector<std::vector<std::string>> third_outer = {{"std_nine", "ten"},
-                                                           {"eleven", "twelve"}};
-
-      aaabcs.push_back(first_outer);
-      aaabcs.push_back(second_outer);
-      aaabcs.push_back(third_outer);
-
-      LOG_INFO(logger, "aaabcs {}", aaabcs);
-    }
-
-    {
-      std::vector<std::vector<std::vector<std::string>>> aaaccs;
-
-      // First outer vector
-      std::vector<std::vector<std::string>> first_outer = {{"std_one", "two"},
-                                                           {"three_std", "four"}};
-
-      // Second outer vector
-      std::vector<std::vector<std::string>> second_outer = {{"five", "six"}, {"seven_std", "eight"}};
-
-      // Third outer vector
-      std::vector<std::vector<std::string>> third_outer = {{"std_nine", "ten"},
-                                                           {"eleven", "twelve"}};
-
-      aaaccs.push_back(first_outer);
-      aaaccs.push_back(second_outer);
-      aaaccs.push_back(third_outer);
-
-      LOG_INFO(logger, "aaaccs {}", aaaccs);
-    }
-
-    LOG_INFO(logger, "scva {} sa {} ulli {} scva {} sa {} aaacs {} aai {}", scva, sa, ulli, scva, sa, aaacs, aai);
-
-    std::vector<int> loopv;
-    loopv.reserve(100);
-    for (int iter = 0; iter < 100; ++iter)
-    {
-      loopv.push_back(iter);
-    }
-
-    LOG_INFO(logger, "loopv {}", loopv);
-
-    std::vector<std::string> loopsv;
-    loopsv.reserve(100);
-    for (int iter = 0; iter < 100; ++iter)
-    {
-      loopsv.push_back(std::to_string(iter));
-    }
-
-    LOG_INFO(logger, "loopsv {}", loopsv);
-
-    std::vector<int> empt;
-    LOG_INFO(logger, "empt {}", empt);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c ['a', 'c']"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       si [-12, 10]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       i [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       li [9876, 1232]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       lli [321, 231]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       usi [15, 2]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ui [123, 2]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uli [3213, 2876]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ulli [321, 1321]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       f [111.1, 323.31]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       d [12.1, 3213213.123]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       cri [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ci [-123, 1]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sa [\"test\", \"string\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sva [\"test\", \"string_view\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva [\"c style\", \"string test\", \"test\", \"log\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aai [[321, 123], [444, 333], [111, 222]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_INFO      " + logger_name +
-                "       aacs [[\"one\", \"two\"], [\"three\", \"four\"], [\"five\", \"six\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aaabcs [[[\"std_one\", \"two\"], [\"three\", \"four\"]], [[\"five\", \"six\"], [\"seven\", \"eight\"]], [[\"std_nine\", \"ten\"], [\"eleven\", \"twelve\"]]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aaaccs [[[\"std_one\", \"two\"], [\"three_std\", \"four\"]], [[\"five\", \"six\"], [\"seven_std\", \"eight\"]], [[\"std_nine\", \"ten\"], [\"eleven\", \"twelve\"]]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       aaacs [[[\"one\", \"two\"], [\"three\", \"four\"]], [[\"five\", \"six\"], [\"seven\", \"eight\"]], [[\"nine\", \"ten\"], [\"eleven\", \"twelve\"]]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scva [\"c style\", \"string test\", \"test\", \"log\"] sa [\"test\", \"string\"] ulli [321, 1321] scva [\"c style\", \"string test\", \"test\", \"log\"] sa [\"test\", \"string\"] aaacs [[[\"one\", \"two\"], [\"three\", \"four\"]], [[\"five\", \"six\"], [\"seven\", \"eight\"]], [[\"nine\", \"ten\"], [\"eleven\", \"twelve\"]]] aai [[321, 123], [444, 333], [111, 222]]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopv [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 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, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       loopsv [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"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\", \"36\", \"37\", \"38\", \"39\", \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\", \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\", \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\", \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\", \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\", \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empt []"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StringLargeLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StringLargeLoggingTest.cpp
deleted file mode 100644
index 5f93c03..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StringLargeLoggingTest.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("string_large_logging")
-{
-  static constexpr char const* filename = "string_large_logging.log";
-  static std::string const logger_name = "logger";
-  static constexpr size_t number_of_messages = 100;
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  for (size_t i = 0; i < number_of_messages; ++i)
-  {
-    std::string v{
-      "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor "
-      "incididunt ut labore et dolore magna aliqua. Dui accumsan sit amet nulla facilisi "
-      "morbi tempus. Diam ut venenatis tellus in metus vulputate eu scelerisque felis. Lorem "
-      "mollis aliquam ut porttitor leo a. Posuere urna nec tincidunt praesent semper feugiat "
-      "nibh sed. Auctor urna nunc id cursus metus aliquam eleifend mi. Et ultrices neque ornare "
-      "aenean euismod elementum nisi quis. Phasellus vestibulum lorem sed risus ultricies "
-      "tristique nulla. Porta nibh venenatis cras sed felis eget velit aliquet sagittis. "
-      "Eget arcu dictum varius duis at consectetur lorem. Diam quam nulla porttitor massa id "
-      "neque aliquam vestibulum morbi. Sed euismod nisi porta lorem mollis aliquam. Arcu "
-      "felis bibendum ut tristique. Lorem ipsum dolor sit amet consectetur adipiscing elit "
-      "pellentesque habitant. Mauris augue neque gravida in. Dictum fusce ut placerat orci "
-      "nulla pellentesque dignissim "};
-
-    v += std::to_string(i);
-
-    LOG_INFO(logger, "Logging int: {}, int: {}, string: {}, string: {}", i, i * 10, v, v);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), number_of_messages);
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StringLoggingDynamicLogLevelTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StringLoggingDynamicLogLevelTest.cpp
deleted file mode 100644
index b4fa637..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StringLoggingDynamicLogLevelTest.cpp
+++ /dev/null
@@ -1,154 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("string_logging_dynamic_log_level")
-{
-  static constexpr char const* filename = "string_logging_dynamic_log_level.log";
-  static std::string const logger_name = "logger";
-  static constexpr size_t number_of_messages = 10000;
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-  logger->set_log_level(LogLevel::TraceL3);
-
-  {
-    std::string s = "adipiscing";
-    std::string const empty_s{};
-
-    std::string_view begin_s{"begin_s"};
-    std::string_view const end_s{"end_s"};
-    std::string_view empty_sv{};
-
-    char const* c_style_string_empty = "";
-    const char* c_style_string = "Lorem ipsum";
-
-    char c_style_char_array_empty[] = "";
-    char const c_style_char_array[] = "dolor";
-
-    char c_style_string_array_non_terminated[3];
-    c_style_string_array_non_terminated[0] = 'A';
-    c_style_string_array_non_terminated[1] = 'B';
-    c_style_string_array_non_terminated[2] = 'C';
-
-    LOG_DYNAMIC(logger, LogLevel::TraceL3, "s [{}]", s);
-    LOG_DYNAMIC(logger, LogLevel::TraceL2, "empty_s [{}]", empty_s);
-    LOG_DYNAMIC(logger, LogLevel::TraceL1, "begin_s [{}]", begin_s);
-    LOG_DYNAMIC(logger, LogLevel::Debug, "end_s [{}]", end_s);
-    LOG_DYNAMIC(logger, LogLevel::Info, "empty_sv [{}]", empty_sv);
-    LOG_DYNAMIC(logger, LogLevel::Warning, "c_style_string_empty [{}]", c_style_string_empty);
-    LOG_DYNAMIC(logger, LogLevel::Error, "c_style_string [{}]", c_style_string);
-    LOG_DYNAMIC(logger, LogLevel::Critical, "c_style_char_array_empty [{}]", c_style_char_array_empty);
-    LOG_DYNAMIC(logger, LogLevel::Info, "c_style_char_array [{}]", c_style_char_array);
-    LOG_DYNAMIC(logger, LogLevel::Info, "c_style_string_array_non_terminated [{}]",
-                c_style_string_array_non_terminated);
-
-    LOG_DYNAMIC(
-      logger, LogLevel::Info,
-      "Lorem ipsum dolor sit amet, consectetur [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] "
-      "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}]",
-      s, "elit", 1, 3.14, empty_s, begin_s, end_s, empty_sv, c_style_string_empty, c_style_string,
-      c_style_char_array_empty, c_style_char_array, c_style_string_array_non_terminated, s, "elit",
-      1, 3.14, empty_s, begin_s, end_s, empty_sv, c_style_string_empty, c_style_string,
-      c_style_char_array_empty, c_style_char_array, c_style_string_array_non_terminated);
-
-    LOG_DYNAMIC(logger, LogLevel::Error,
-                "Nulla tempus, libero at dignissim viverra, lectus libero finibus ante [{}] [{}] "
-                "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] "
-                "[{}] [{}] [{}] [{}]",
-                2, true, begin_s, empty_sv, empty_s, c_style_string_array_non_terminated, c_style_string_empty,
-                c_style_string, end_s, c_style_char_array_empty, c_style_char_array, 2, true,
-                begin_s, empty_sv, empty_s, c_style_string_array_non_terminated, c_style_string_empty,
-                c_style_string, end_s, c_style_char_array_empty, c_style_char_array);
-  }
-
-  // Log a big string
-  for (size_t i = 0; i < number_of_messages; ++i)
-  {
-    std::string v{"Lorem ipsum dolor sit amet, consectetur "};
-    v += std::to_string(i);
-
-    LOG_DYNAMIC(logger, LogLevel::Info, "Logging int: {}, int: {}, string: {}, char: {}", i, i * 10,
-                v, v.c_str());
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), number_of_messages + 12);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_TRACE_L3  " + logger_name + "       s [adipiscing]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_TRACE_L2  " + logger_name + "       empty_s []"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_TRACE_L1  " + logger_name + "       begin_s [begin_s]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_DEBUG     " + logger_name + "       end_s [end_s]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empty_sv []"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_WARNING   " + logger_name + "       c_style_string_empty []"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_ERROR     " + logger_name + "       c_style_string [Lorem ipsum]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_CRITICAL  " + logger_name + "       c_style_char_array_empty []"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c_style_char_array [dolor]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c_style_string_array_non_terminated [ABC]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       Lorem ipsum dolor sit amet, consectetur [adipiscing] [elit] [1] [3.14] [] [begin_s] [end_s] [] [] [Lorem ipsum] [] [dolor] [ABC] [adipiscing] [elit] [1] [3.14] [] [begin_s] [end_s] [] [] [Lorem ipsum] [] [dolor] [ABC]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_ERROR     " + logger_name + "       Nulla tempus, libero at dignissim viverra, lectus libero finibus ante [2] [true] [begin_s] [] [] [ABC] [] [Lorem ipsum] [end_s] [] [dolor] [2] [true] [begin_s] [] [] [ABC] [] [Lorem ipsum] [end_s] [] [dolor]"}));
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       Logging int: 0, int: 0, string: Lorem ipsum dolor sit amet, consectetur 0, char: Lorem ipsum dolor sit amet, consectetur 0"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       Logging int: 1999, int: 19990, string: Lorem ipsum dolor sit amet, consectetur 1999, char: Lorem ipsum dolor sit amet, consectetur 1999"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StringLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StringLoggingTest.cpp
deleted file mode 100644
index 02bfdd1..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StringLoggingTest.cpp
+++ /dev/null
@@ -1,161 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("string_logging")
-{
-  static constexpr char const* filename = "string_logging.log";
-  static std::string const logger_name = "logger";
-  static constexpr size_t number_of_messages = 10000;
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::string s = "adipiscing";
-    std::string const& scr = s;
-    std::string& sr = s;
-    std::string const empty_s{};
-
-    std::string_view begin_s{"begin_s"};
-    std::string_view const end_s{"end_s"};
-    std::string_view empty_sv{};
-
-    char const* c_style_string_empty = "";
-    const char* c_style_string = "Lorem ipsum";
-
-    char c_style_char_array_empty[] = "";
-    char const c_style_char_array[] = "dolor";
-
-    char c_style_string_array_non_terminated[3];
-    c_style_string_array_non_terminated[0] = 'A';
-    c_style_string_array_non_terminated[1] = 'B';
-    c_style_string_array_non_terminated[2] = 'C';
-
-    LOG_INFO(logger, "s [{}]", s);
-    LOG_INFO(logger, "scr [{}]", scr);
-    LOG_INFO(logger, "sr [{}]", sr);
-    LOG_INFO(logger, "empty_s [{}]", empty_s);
-    LOG_INFO(logger, "begin_s [{}]", begin_s);
-    LOG_INFO(logger, "end_s [{}]", end_s);
-    LOG_INFO(logger, "empty_sv [{}]", empty_sv);
-    LOG_INFO(logger, "c_style_string_empty [{}]", c_style_string_empty);
-    LOG_INFO(logger, "c_style_string [{}]", c_style_string);
-    LOG_INFO(logger, "c_style_char_array_empty [{}]", c_style_char_array_empty);
-    LOG_INFO(logger, "c_style_char_array [{}]", c_style_char_array);
-    LOG_INFO(logger, "c_style_string_array_non_terminated [{}]", c_style_string_array_non_terminated);
-
-    LOG_INFO(logger,
-             "Lorem ipsum dolor sit amet, consectetur [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] "
-             "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}]",
-             s, "elit", 1, 3.14, empty_s, begin_s, end_s, empty_sv, c_style_string_empty, c_style_string,
-             c_style_char_array_empty, c_style_char_array, c_style_string_array_non_terminated, s,
-             "elit", 1, 3.14, empty_s, begin_s, end_s, empty_sv, c_style_string_empty, c_style_string,
-             c_style_char_array_empty, c_style_char_array, c_style_string_array_non_terminated);
-
-    LOG_ERROR(logger,
-              "Nulla tempus, libero at dignissim viverra, lectus libero finibus ante [{}] [{}] "
-              "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] "
-              "[{}] [{}] [{}] [{}]",
-              2, true, begin_s, empty_sv, empty_s, c_style_string_array_non_terminated, c_style_string_empty,
-              c_style_string, end_s, c_style_char_array_empty, c_style_char_array, 2, true, begin_s,
-              empty_sv, empty_s, c_style_string_array_non_terminated, c_style_string_empty,
-              c_style_string, end_s, c_style_char_array_empty, c_style_char_array);
-  }
-
-  // Log a big string
-  for (size_t i = 0; i < number_of_messages; ++i)
-  {
-    std::string v{"Lorem ipsum dolor sit amet, consectetur "};
-    v += std::to_string(i);
-
-    LOG_INFO(logger, "Logging int: {}, int: {}, string: {}, char: {}", i, i * 10, v, v.c_str());
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), number_of_messages + 14);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       s [adipiscing]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scr [adipiscing]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sr [adipiscing]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empty_s []"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       begin_s [begin_s]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       end_s [end_s]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empty_sv []"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c_style_string_empty []"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c_style_string [Lorem ipsum]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c_style_char_array_empty []"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c_style_char_array [dolor]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c_style_string_array_non_terminated [ABC]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       Lorem ipsum dolor sit amet, consectetur [adipiscing] [elit] [1] [3.14] [] [begin_s] [end_s] [] [] [Lorem ipsum] [] [dolor] [ABC] [adipiscing] [elit] [1] [3.14] [] [begin_s] [end_s] [] [] [Lorem ipsum] [] [dolor] [ABC]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_ERROR     " + logger_name + "       Nulla tempus, libero at dignissim viverra, lectus libero finibus ante [2] [true] [begin_s] [] [] [ABC] [] [Lorem ipsum] [end_s] [] [dolor] [2] [true] [begin_s] [] [] [ABC] [] [Lorem ipsum] [end_s] [] [dolor]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       Logging int: 0, int: 0, string: Lorem ipsum dolor sit amet, consectetur 0, char: Lorem ipsum dolor sit amet, consectetur 0"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       Logging int: 1999, int: 19990, string: Lorem ipsum dolor sit amet, consectetur 1999, char: Lorem ipsum dolor sit amet, consectetur 1999"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StringRandomLargeLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StringRandomLargeLoggingTest.cpp
deleted file mode 100644
index 28433be..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StringRandomLargeLoggingTest.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("string_random_large_logging")
-{
-  static constexpr char const* filename = "string_random_large_logging.log";
-  static std::string const logger_name = "logger";
-  static constexpr size_t number_of_strings = 500;
-  static constexpr int min_string_len = 10000;
-  static constexpr int max_string_len = 20000;
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  std::vector<std::string> random_strings_vec =
-    quill::testing::gen_random_strings(number_of_strings, min_string_len, max_string_len);
-
-  // First push in sequence
-  int32_t i = 0;
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", elem);
-    LOG_INFO(logger, "{}", elem.c_str());
-    LOG_INFO(logger, "{}", std::string_view{elem});
-    LOG_INFO(logger, "{} {}", i, static_cast<double>(i));
-    ++i;
-    logger->flush_log();
-  }
-
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", elem);
-    LOG_INFO(logger, "{} {}", i, static_cast<double>(i));
-    ++i;
-    logger->flush_log();
-  }
-
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", elem.c_str());
-    LOG_INFO(logger, "{} {}", i, static_cast<double>(i));
-    ++i;
-    logger->flush_log();
-  }
-
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", std::string_view{elem});
-    LOG_INFO(logger, "{} {}", i, static_cast<double>(i));
-    ++i;
-    logger->flush_log();
-  }
-
-  // Then also try to push all
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", elem);
-    LOG_INFO(logger, "{}", elem.c_str());
-    LOG_INFO(logger, "{}", std::string_view{elem});
-    LOG_INFO(logger, "{} {}", i, static_cast<double>(i));
-    ++i;
-  }
-
-  // clear the vector for the strings to go out of scope for additional testing
-  size_t const total_log_messages = random_strings_vec.size() * 14;
-  random_strings_vec.clear();
-
-  // Let all log get flushed to the file
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check we logged everything
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), total_log_messages);
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StringRandomLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StringRandomLoggingTest.cpp
deleted file mode 100644
index 64ab65e..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StringRandomLoggingTest.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("string_random_logging")
-{
-  static constexpr char const* filename = "string_random_logging.log";
-  static std::string const logger_name = "logger";
-  static constexpr size_t number_of_strings = 2000;
-  static constexpr int min_string_len = 1;
-  static constexpr int max_string_len = 1500;
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  std::vector<std::string> random_strings_vec =
-    quill::testing::gen_random_strings(number_of_strings, min_string_len, max_string_len);
-
-  // First push in sequence
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", elem);
-    LOG_INFO(logger, "{}", elem.c_str());
-    LOG_INFO(logger, "{}", std::string_view{elem});
-    logger->flush_log();
-  }
-
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", elem);
-    logger->flush_log();
-  }
-
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", elem.c_str());
-    logger->flush_log();
-  }
-
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", std::string_view{elem});
-    logger->flush_log();
-  }
-
-  // Then also try to push all
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", elem);
-    LOG_INFO(logger, "{}", elem.c_str());
-    LOG_INFO(logger, "{}", std::string_view{elem});
-  }
-
-  // clear the vector for the strings to go out of scope for additional testing
-  size_t const total_log_messages = random_strings_vec.size() * 9;
-  random_strings_vec.clear();
-
-  // Let all log get flushed to the file
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check we logged everything
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), total_log_messages);
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/StringRandomSmallLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/StringRandomSmallLoggingTest.cpp
deleted file mode 100644
index 5ddb11a..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/StringRandomSmallLoggingTest.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("string_random_small_logging")
-{
-  static constexpr char const* filename = "string_random_small_logging.log";
-  static std::string const logger_name = "logger";
-  static constexpr size_t number_of_strings = 500;
-  static constexpr int min_string_len = 1;
-  static constexpr int max_string_len = 50;
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  std::vector<std::string> random_strings_vec =
-    quill::testing::gen_random_strings(number_of_strings, min_string_len, max_string_len);
-
-  // First push in sequence
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", elem);
-    LOG_INFO(logger, "{}", elem.c_str());
-    LOG_INFO(logger, "{}", std::string_view{elem});
-    logger->flush_log();
-  }
-
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", elem);
-    logger->flush_log();
-  }
-
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", elem.c_str());
-    logger->flush_log();
-  }
-
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", std::string_view{elem});
-    logger->flush_log();
-  }
-
-  // Then also try to push all
-  for (auto const& elem : random_strings_vec)
-  {
-    LOG_INFO(logger, "{}", elem);
-    LOG_INFO(logger, "{}", elem.c_str());
-    LOG_INFO(logger, "{}", std::string_view{elem});
-  }
-
-  // clear the vector for the strings to go out of scope for additional testing
-  size_t const total_log_messages = random_strings_vec.size() * 9;
-  random_strings_vec.clear();
-
-  // Let all log get flushed to the file
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check we logged everything
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), total_log_messages);
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/TagsLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/TagsLoggingTest.cpp
deleted file mode 100644
index bcc6245..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/TagsLoggingTest.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Utility.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-class TestTags : public quill::Tags
-{
-public:
-  explicit constexpr TestTags(char const* tag_a) : _tag_a(tag_a) {}
-
-  void format(std::string& out) const override { out.append(fmtquill::format("{}", _tag_a)); }
-
-private:
-  char const* _tag_a;
-};
-
-static constexpr TestTags tags_a{"TAG_A"};
-static constexpr TestTags tags_b{"TAG_B"};
-
-static constexpr quill::utility::CombinedTags<TestTags, TestTags> tags_ab{tags_a, tags_b, " -- "};
-
-/***/
-TEST_CASE("tags_logging")
-{
-  static constexpr char const* filename = "tags_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(
-    logger_name, std::move(file_sink),
-    "%(time) [%(thread_id)] %(short_source_location:<28) LOG_%(log_level:<9) "
-    "%(logger:<12) [%(tags)] %(message)\"");
-
-  logger->set_log_level(quill::LogLevel::TraceL3);
-
-  LOG_TRACE_L3_WITH_TAGS(logger, tags_ab, "Lorem ipsum dolor sit amet, consectetur {} {} {}", "elit", 1, 3.14);
-  LOG_TRACE_L2_WITH_TAGS(logger, tags_ab, "Lorem ipsum dolor sit amet, consectetur {} {} {}", "elit", 1, 3.14);
-  LOG_TRACE_L1_WITH_TAGS(logger, tags_ab, "Lorem ipsum dolor sit amet, consectetur {} {} {}", "elit", 1, 3.14);
-  LOG_DEBUG_WITH_TAGS(logger, tags_ab, "Lorem ipsum dolor sit amet, consectetur {} {} {}", "elit", 1, 3.14);
-  LOG_INFO_WITH_TAGS(logger, tags_ab, "Lorem ipsum dolor sit amet, consectetur {} {} {}", "elit", 1, 3.14);
-  LOG_WARNING_WITH_TAGS(logger, tags_ab, "Lorem ipsum dolor sit amet, consectetur {} {} {}", "elit", 1, 3.14);
-  LOG_ERROR_WITH_TAGS(logger, tags_ab, "Lorem ipsum dolor sit amet, consectetur {} {} {}", "elit", 1, 3.14);
-  LOG_CRITICAL_WITH_TAGS(logger, tags_ab, "Lorem ipsum dolor sit amet, consectetur {} {} {}", "elit", 1, 3.14);
-
-  LOG_ERROR_WITH_TAGS(
-    logger, tags_ab, "Nulla tempus, libero at dignissim viverra, lectus libero finibus ante {} {}", 2, true);
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), 9);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_TRACE_L3  " + logger_name +
-                "       [TAG_A -- TAG_B] Lorem ipsum dolor sit amet, consectetur elit 1 3.14"}));
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_TRACE_L2  " + logger_name +
-                "       [TAG_A -- TAG_B] Lorem ipsum dolor sit amet, consectetur elit 1 3.14"}));
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_TRACE_L1  " + logger_name +
-                "       [TAG_A -- TAG_B] Lorem ipsum dolor sit amet, consectetur elit 1 3.14"}));
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_DEBUG     " + logger_name +
-                "       [TAG_A -- TAG_B] Lorem ipsum dolor sit amet, consectetur elit 1 3.14"}));
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_INFO      " + logger_name +
-                "       [TAG_A -- TAG_B] Lorem ipsum dolor sit amet, consectetur elit 1 3.14"}));
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_WARNING   " + logger_name +
-                "       [TAG_A -- TAG_B] Lorem ipsum dolor sit amet, consectetur elit 1 3.14"}));
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_ERROR     " + logger_name +
-                "       [TAG_A -- TAG_B] Lorem ipsum dolor sit amet, consectetur elit 1 3.14"}));
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_CRITICAL  " + logger_name +
-                "       [TAG_A -- TAG_B] Lorem ipsum dolor sit amet, consectetur elit 1 3.14"}));
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_ERROR     " + logger_name + "       [TAG_A -- TAG_B] Nulla tempus, libero at dignissim viverra, lectus libero finibus ante 2 true"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/UserClockSourceTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/UserClockSourceTest.cpp
deleted file mode 100644
index 9af5464..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/UserClockSourceTest.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace quill;
-
-/**
- * Custom timestamp class
- */
-class UserClockSourceTest : public UserClockSource
-{
-public:
-  UserClockSourceTest() = default;
-
-  /**
-   * Required by TimestampClock
-   * @return current time now, in nanoseconds since epoch
-   */
-  uint64_t now() const override { return _ts.load(); }
-
-  /**
-   * set custom timestamp
-   * @param time_since_epoch timestamp
-   */
-  void set_timestamp(std::chrono::seconds time_since_epoch)
-  {
-    // always convert to nanos
-    _ts.store(static_cast<uint64_t>(std::chrono::nanoseconds{time_since_epoch}.count()));
-  }
-
-private:
-  /**
-   * time since epoch - must always be in nanoseconds
-   * This class needs to be thread-safe, unless only a single thread in the application calling LOG macros
-   * **/
-  std::atomic<uint64_t> _ts;
-};
-
-/***/
-TEST_CASE("user_clock_source")
-{
-  static constexpr size_t number_of_messages = 10;
-  static constexpr char const* filename = "user_clock_source.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  UserClockSourceTest uct;
-  uct.set_timestamp(std::chrono::seconds{1655007309});
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink),
-                                                  "%(time) %(log_level) %(logger:<16) %(message)", // format
-                                                  "%Y-%m-%d %H:%M:%S.%Qms", // timestamp format
-                                                  quill::Timezone::GmtTime, ClockSourceType::User, &uct);
-
-  for (size_t i = 0; i < number_of_messages; ++i)
-  {
-    // log an array so the log message is pushed to the queue
-    LOG_INFO(logger, "Lorem ipsum dolor sit amet, consectetur adipiscing elit {}", i);
-  }
-
-  uct.set_timestamp(std::chrono::seconds{1656007309});
-
-  for (size_t i = 0; i < number_of_messages; ++i)
-  {
-    LOG_ERROR(logger, "Nulla tempus, libero at dignissim viverra, lectus libero finibus ante {}", i);
-  }
-
-  // Let all log get flushed to the file
-  uct.set_timestamp(std::chrono::seconds{1658007309});
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), number_of_messages * 2);
-
-  for (size_t i = 0; i < number_of_messages; ++i)
-  {
-    std::string expected_string = "2022-06-12 04:15:09.000 INFO " + logger_name +
-      "           Lorem ipsum dolor sit amet, consectetur adipiscing elit " + std::to_string(i);
-    REQUIRE(quill::testing::file_contains(file_contents, expected_string));
-  }
-
-  for (size_t i = 0; i < number_of_messages; ++i)
-  {
-    std::string expected_string = "2022-06-23 18:01:49.000 ERROR " + logger_name +
-      "           Nulla tempus, libero at dignissim viverra, lectus libero finibus ante " +
-      std::to_string(i);
-    REQUIRE(quill::testing::file_contains(file_contents, expected_string));
-  }
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/UserDefinedTypeLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/UserDefinedTypeLoggingTest.cpp
deleted file mode 100644
index 2a64375..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/UserDefinedTypeLoggingTest.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/Utility.h"
-#include "quill/sinks/FileSink.h"
-
-#include "quill/core/Codec.h"
-#include "quill/core/DynamicFormatArgStore.h"
-#include "quill/std/Array.h"
-#include "quill/std/Vector.h"
-
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/**
- * CustomType defined type
- */
-struct CustomType
-{
-  std::string name;
-  std::string surname;
-  uint32_t age;
-  std::array<std::string, 3> favorite_colors;
-};
-
-/***/
-template <>
-struct fmtquill::formatter<CustomType>
-{
-  template <typename FormatContext>
-  constexpr auto parse(FormatContext& ctx)
-  {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(::CustomType const& custom_type, FormatContext& ctx) const
-  {
-    return fmtquill::format_to(ctx.out(), "Name: {}, Surname: {}, Age: {}, Favorite Colors: {}",
-                               custom_type.name, custom_type.surname, custom_type.age,
-                               custom_type.favorite_colors);
-  }
-};
-
-/***/
-template <>
-struct quill::detail::ArgSizeCalculator<CustomType>
-{
-  static size_t calculate(std::vector<size_t>& conditional_arg_size_cache, ::CustomType const& custom_type) noexcept
-  {
-    // pass as arguments the class members you want to serialize
-    return calculate_total_size(conditional_arg_size_cache, custom_type.name, custom_type.surname,
-                                custom_type.age, custom_type.favorite_colors);
-  }
-};
-
-/***/
-template <>
-struct quill::detail::Encoder<CustomType>
-{
-  static void encode(std::byte*& buffer, std::vector<size_t> const& conditional_arg_size_cache,
-                     uint32_t& conditional_arg_size_cache_index, ::CustomType const& custom_type) noexcept
-  {
-    // You must encode the same members and in the same order as in the ArgSizeCalculator::calculate
-    encode_members(buffer, conditional_arg_size_cache, conditional_arg_size_cache_index,
-                   custom_type.name, custom_type.surname, custom_type.age, custom_type.favorite_colors);
-  }
-};
-
-/***/
-template <>
-struct quill::detail::Decoder<CustomType>
-{
-  static ::CustomType decode(std::byte*& buffer, DynamicFormatArgStore* args_store)
-  {
-    // You must decode the same members and in the same order as in the Encoder::encode
-    ::CustomType custom_type;
-    decode_and_assign_members(buffer, args_store, custom_type, custom_type.name,
-                              custom_type.surname, custom_type.age, custom_type.favorite_colors);
-    return custom_type;
-  }
-};
-
-/***/
-TEST_CASE("custom_type_defined_type_logging")
-{
-  static constexpr char const* filename = "custom_type_defined_type_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(
-    logger_name, std::move(file_sink),
-    "%(time) [%(thread_id)] %(short_source_location:<28) LOG_%(log_level:<9) "
-    "%(logger:<12) %(message)");
-
-  logger->set_log_level(quill::LogLevel::TraceL3);
-
-  CustomType custom_type;
-  custom_type.name = "Quill";
-  custom_type.surname = "Library";
-  custom_type.age = 4;
-  custom_type.favorite_colors[0] = "red";
-  custom_type.favorite_colors[1] = "green";
-  custom_type.favorite_colors[2] = "blue";
-
-  LOG_INFO(logger, "The answer is {}", custom_type);
-
-  std::vector<CustomType> const custom_types = {{"Alice", "Doe", 25, {"red", "green"}},
-                                                {"Bob", "Smith", 30, {"blue", "yellow"}},
-                                                {"Charlie", "Johnson", 35, {"green", "orange"}},
-                                                {"David", "Brown", 40, {"red", "blue", "yellow"}}};
-
-  LOG_INFO(logger, "The answers are {}", custom_types);
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), 2);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       The answer is Name: Quill, Surname: Library, Age: 4, Favorite Colors: [\"red\", \"green\", \"blue\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       The answers are [Name: Alice, Surname: Doe, Age: 25, Favorite Colors: [\"red\", \"green\", \"\"], Name: Bob, Surname: Smith, Age: 30, Favorite Colors: [\"blue\", \"yellow\", \"\"], Name: Charlie, Surname: Johnson, Age: 35, Favorite Colors: [\"green\", \"orange\", \"\"], Name: David, Surname: Brown, Age: 40, Favorite Colors: [\"red\", \"blue\", \"yellow\"]]"}));
-
-  testing::remove_file(filename);
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/WideStdTypesLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/WideStdTypesLoggingTest.cpp
deleted file mode 100644
index 25dbf08..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/WideStdTypesLoggingTest.cpp
+++ /dev/null
@@ -1,330 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/core/Filesystem.h"
-#include "quill/sinks/FileSink.h"
-
-#include "quill/std/Array.h"
-#include "quill/std/Deque.h"
-#include "quill/std/FilesystemPath.h"
-#include "quill/std/ForwardList.h"
-#include "quill/std/List.h"
-#include "quill/std/Map.h"
-#include "quill/std/Optional.h"
-#include "quill/std/Pair.h"
-#include "quill/std/Set.h"
-#include "quill/std/UnorderedMap.h"
-#include "quill/std/UnorderedSet.h"
-#include "quill/std/Vector.h"
-
-#include <array>
-#include <cstdio>
-#include <deque>
-#include <forward_list>
-#include <list>
-#include <map>
-#include <optional>
-#include <set>
-#include <string>
-#include <string_view>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-using namespace quill;
-
-struct CWideStringComparator
-{
-  bool operator()(wchar_t const* a, wchar_t const* b) const { return std::wcscmp(a, b) < 0; }
-};
-
-/***/
-TEST_CASE("wide_std_types_logging")
-{
-#if defined(_WIN32)
-  static constexpr char const* filename = "wide_std_types_logging.log";
-  static std::string const logger_name = "logger";
-
-  // Start the logging backend thread
-  Backend::start();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    fs::path wp{L"C:\\some\\path"};
-    LOG_INFO(logger, "wp {}", wp);
-
-    fs::path p{"C:\\another\\path"};
-    LOG_INFO(logger, "p {}", p);
-
-    LOG_INFO(logger, "wp {} p {}", wp, p);
-
-    std::array<std::wstring, 2> wsa = {L"test", L"string"};
-    LOG_INFO(logger, "wsa {}", wsa);
-
-    std::array<std::wstring_view, 2> wsva = {L"test", L"string_view"};
-    LOG_INFO(logger, "wsva {}", wsva);
-
-    std::array<wchar_t const*, 4> wscva = {L"c style", L"string test", L"test", L"log"};
-    LOG_INFO(logger, "wscva {}", wscva);
-
-    std::deque<std::wstring> wds = {L"test", L"string"};
-    LOG_INFO(logger, "wds {}", wds);
-
-    std::deque<std::wstring_view> wdsv = {L"test", L"string_view"};
-    LOG_INFO(logger, "wdsv {}", wdsv);
-
-    std::deque<wchar_t const*> wdcs = {L"c style", L"string test", L"test", L"log"};
-    LOG_INFO(logger, "wdcs {}", wdcs);
-
-    std::forward_list<std::wstring> wfs = {L"test", L"string"};
-    LOG_INFO(logger, "wfs {}", wfs);
-
-    std::forward_list<std::wstring_view> wfsv = {L"test", L"string_view"};
-    LOG_INFO(logger, "wfsv {}", wfsv);
-
-    std::forward_list<wchar_t const*> wfcs = {L"c style", L"string test", L"test", L"log"};
-    LOG_INFO(logger, "wfcs {}", wfcs);
-
-    std::list<std::wstring> sl = {L"test", L"string"};
-    LOG_INFO(logger, "sl {}", sl);
-
-    std::list<std::wstring_view> svl = {L"test", L"string_view"};
-    LOG_INFO(logger, "svl {}", svl);
-
-    std::list<wchar_t const*> scl = {L"c style", L"string test", L"test", L"log"};
-    LOG_INFO(logger, "scl {}", scl);
-
-    std::vector<std::wstring> wsv = {L"test", L"string"};
-    LOG_INFO(logger, "wsv {}", wsv);
-
-    std::vector<std::wstring_view> wsvv = {L"test", L"string_view"};
-    LOG_INFO(logger, "wsvv {}", wsvv);
-
-    std::vector<wchar_t const*> wscv = {L"c style", L"string test", L"test", L"log"};
-    LOG_INFO(logger, "wscv {}", wscv);
-
-    std::pair<std::wstring, std::wstring> wpss = {L"test", L"string"};
-    LOG_INFO(logger, "wpss {}", wpss);
-
-    std::pair<std::wstring_view, std::wstring> wpsv = {L"test", L"string_view"};
-    LOG_INFO(logger, "wpsv {}", wpsv);
-
-    std::pair<wchar_t const*, std::wstring> wscs = {L"c style", L"string test"};
-    LOG_INFO(logger, "wscs {}", wscs);
-
-    std::pair<int, std::wstring> wscsi = {1231, L"string test"};
-    LOG_INFO(logger, "wscsi {}", wscsi);
-
-    std::pair<std::wstring, double> wscsd = {L"string test", 443.2};
-    LOG_INFO(logger, "wscsd {}", wscsd);
-
-    std::optional<std::wstring> weo{std::nullopt};
-    LOG_INFO(logger, "eo {}", weo);
-
-    std::optional<std::wstring> wos{L"test"};
-    LOG_INFO(logger, "wos {}", wos);
-
-    std::optional<std::wstring_view> wosv{L"test"};
-    LOG_INFO(logger, "wosv {}", wosv);
-
-    std::optional<wchar_t const*> woc{L"test"};
-    LOG_INFO(logger, "woc {}", woc);
-
-    std::set<std::wstring> sa = {L"test", L"string"};
-    LOG_INFO(logger, "sa {}", sa);
-
-    std::set<std::wstring> sva = {L"test", L"string_view"};
-    LOG_INFO(logger, "sva {}", sva);
-
-    std::set<wchar_t const*, CWideStringComparator> scva = {L"c_style", L"aa", L"string_test",
-                                                            L"test", L"log"};
-    LOG_INFO(logger, "scva {}", scva);
-
-    std::map<std::wstring, std::wstring> ccm = {{L"4", L"400"}, {L"3", L"300"}, {L"1", L"100"}};
-    LOG_INFO(logger, "ccm {}", ccm);
-
-    std::map<std::wstring, int> ccmx = {{L"4", 400}, {L"3", 300}, {L"1", 100}};
-    LOG_INFO(logger, "ccmx {}", ccmx);
-
-    std::map<wchar_t const*, std::wstring, CWideStringComparator> ccmc = {
-      {L"4", L"400"}, {L"3", L"300"}, {L"1", L"100"}};
-    LOG_INFO(logger, "ccmc {}", ccmc);
-
-    std::map<int, std::wstring> ccmi = {{4, L"400"}, {3, L"300"}, {1, L"100"}};
-    LOG_INFO(logger, "ccmi {}", ccmi);
-
-    std::unordered_set<std::wstring> uss = {L"test"};
-    LOG_INFO(logger, "uss {}", uss);
-
-    std::unordered_set<std::wstring_view> usvs = {L"string_view"};
-    LOG_INFO(logger, "usvs {}", usvs);
-
-    std::unordered_set<wchar_t const*> uscs = {L"c_style"};
-    LOG_INFO(logger, "uscs {}", uscs);
-
-    std::unordered_map<std::wstring, std::wstring> uccm = {{L"4", L"400"}};
-    LOG_INFO(logger, "uccm {}", uccm);
-
-    std::unordered_map<std::wstring, int> uccmx = {{L"5", 500}};
-    LOG_INFO(logger, "uccmx {}", uccmx);
-
-    std::unordered_map<wchar_t const*, std::wstring> uccmc = {{L"6", L"600"}};
-    LOG_INFO(logger, "uccmc {}", uccmc);
-
-    std::unordered_map<int, std::wstring> uccmi = {{7, L"700"}};
-    LOG_INFO(logger, "uccmi {}", uccmi);
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wp C:\\some\\path"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       p C:\\another\\path"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wp C:\\some\\path p C:\\another\\path"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wsa [\"test\", \"string\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wsva [\"test\", \"string_view\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wscva [\"c style\", \"string test\", \"test\", \"log\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wds [\"test\", \"string\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wdsv [\"test\", \"string_view\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wdcs [\"c style\", \"string test\", \"test\", \"log\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wfs [\"test\", \"string\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wfsv [\"test\", \"string_view\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wfcs [\"c style\", \"string test\", \"test\", \"log\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sl [\"test\", \"string\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       svl [\"test\", \"string_view\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       scl [\"c style\", \"string test\", \"test\", \"log\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wsv [\"test\", \"string\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wsvv [\"test\", \"string_view\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wscv [\"c style\", \"string test\", \"test\", \"log\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wpss (\"test\", \"string\")"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wpsv (\"test\", \"string_view\")"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wscs (\"c style\", \"string test\")"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wscsi (1231, \"string test\")"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wscsd (\"string test\", 443.2)"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       eo none"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wos optional(\"test\")"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       wosv optional(\"test\")"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       woc optional(\"test\")"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sa [\"string\", \"test\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       sva [\"string_view\", \"test\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents,
-    std::string{"LOG_INFO      " + logger_name +
-                "       scva [\"aa\", \"c_style\", \"log\", \"string_test\", \"test\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ccm [(\"1\", \"100\"), (\"3\", \"300\"), (\"4\", \"400\")]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ccmx [(\"1\", 100), (\"3\", 300), (\"4\", 400)]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ccmc [(\"1\", \"100\"), (\"3\", \"300\"), (\"4\", \"400\")]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ccmi [(1, \"100\"), (3, \"300\"), (4, \"400\")]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uss [\"test\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       usvs [\"string_view\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uscs [\"c_style\"]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uccm [(\"4\", \"400\")]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uccmx [(\"5\", 500)]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uccmc [(\"6\", \"600\")]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       uccmi [(7, \"700\")]"}));
-
-  testing::remove_file(filename);
-#endif
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/integration_tests/WideStringLoggingTest.cpp b/subprojects/quill-4.2.0/quill/test/integration_tests/WideStringLoggingTest.cpp
deleted file mode 100644
index 6480a35..0000000
--- a/subprojects/quill-4.2.0/quill/test/integration_tests/WideStringLoggingTest.cpp
+++ /dev/null
@@ -1,136 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/Backend.h"
-#include "quill/Frontend.h"
-#include "quill/LogMacros.h"
-#include "quill/sinks/FileSink.h"
-
-#include <cstdio>
-#include <string>
-#include <string_view>
-#include <vector>
-
-using namespace quill;
-
-/***/
-TEST_CASE("wide_string_logging")
-{
-#if defined(_WIN32)
-  static constexpr char const* filename = "wide_string_logging.log";
-  static std::string const logger_name = "logger";
-  static constexpr size_t number_of_messages = 10000;
-
-  // Start the logging backend thread
-  Backend::start();
-
-  Frontend::preallocate();
-
-  // Set writing logging to a file
-  auto file_sink = Frontend::create_or_get_sink<FileSink>(
-    filename,
-    []()
-    {
-      FileSinkConfig cfg;
-      cfg.set_open_mode('w');
-      return cfg;
-    }(),
-    FileEventNotifier{});
-
-  Logger* logger = Frontend::create_or_get_logger(logger_name, std::move(file_sink));
-
-  {
-    std::string s = "adipiscing";
-    std::wstring ws = L"adipiscing";
-    std::wstring const empty_s{};
-
-    std::wstring_view begin_s{L"begin_s"};
-    std::wstring_view const end_s{L"end_s"};
-    std::wstring_view empty_sv{};
-
-    wchar_t const* c_style_string_empty = L"";
-    wchar_t const* c_style_string = L"Lorem ipsum";
-
-    LOG_INFO(logger, "s [{}]", s);
-    LOG_INFO(logger, "ws [{}]", ws);
-    LOG_INFO(logger, "empty_s [{}]", empty_s);
-    LOG_INFO(logger, "begin_s [{}]", begin_s);
-    LOG_INFO(logger, "end_s [{}]", end_s);
-    LOG_INFO(logger, "empty_sv [{}]", empty_sv);
-    LOG_INFO(logger, "c_style_string_empty [{}]", c_style_string_empty);
-    LOG_INFO(logger, "c_style_string [{}]", c_style_string);
-
-    LOG_INFO(logger,
-             "Lorem ipsum dolor sit amet, consectetur [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] "
-             "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}]",
-             ws, "elit", 1, 3.14, empty_s, begin_s, end_s, empty_sv, c_style_string_empty,
-             c_style_string, ws, "elit", 1, 3.14, empty_s, begin_s, end_s, empty_sv,
-             c_style_string_empty, c_style_string, s);
-
-    LOG_ERROR(logger,
-              "Nulla tempus, libero at dignissim viverra, lectus libero finibus ante [{}] [{}] "
-              "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}]",
-              2, true, begin_s, empty_sv, empty_s, c_style_string_empty, c_style_string, end_s, 2,
-              true, begin_s, empty_sv, empty_s, c_style_string_empty, c_style_string, end_s, s);
-  }
-
-  // Log a big string
-  for (size_t i = 0; i < number_of_messages; ++i)
-  {
-    std::wstring v{
-      L"Lorem ipsum dolor sit amet, consectetur Lorem ipsum dolor sit amet, consectetur Lorem "
-      L"ipsum dolor sit amet, consectetur "};
-    v += std::to_wstring(i);
-
-    LOG_INFO(logger, "Logging int: {}, int: {}, string: {}, char: {}", i, i * 10, v, v.c_str());
-  }
-
-  logger->flush_log();
-  Frontend::remove_logger(logger);
-
-  // Wait until the backend thread stops for test stability
-  Backend::stop();
-
-  // Read file and check
-  std::vector<std::string> const file_contents = quill::testing::file_contents(filename);
-  REQUIRE_EQ(file_contents.size(), number_of_messages + 10);
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       s [adipiscing]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       ws [adipiscing]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empty_s []"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       begin_s [begin_s]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       end_s [end_s]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       empty_sv []"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c_style_string_empty []"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       c_style_string [Lorem ipsum]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       Lorem ipsum dolor sit amet, consectetur [adipiscing] [elit] [1] [3.14] [] [begin_s] [end_s] [] [] [Lorem ipsum] [adipiscing] [elit] [1] [3.14] [] [begin_s] [end_s] [] [] [Lorem ipsum] [adipiscing]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_ERROR     " + logger_name + "       Nulla tempus, libero at dignissim viverra, lectus libero finibus ante [2] [true] [begin_s] [] [] [] [Lorem ipsum] [end_s] [2] [true] [begin_s] [] [] [] [Lorem ipsum] [end_s] [adipiscing]"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       Logging int: 0, int: 0, string: Lorem ipsum dolor sit amet, consectetur Lorem ipsum dolor sit amet, consectetur Lorem ipsum dolor sit amet, consectetur 0, char: Lorem ipsum dolor sit amet, consectetur Lorem ipsum dolor sit amet, consectetur Lorem ipsum dolor sit amet, consectetur 0"}));
-
-  REQUIRE(quill::testing::file_contains(
-    file_contents, std::string{"LOG_INFO      " + logger_name + "       Logging int: 1999, int: 19990, string: Lorem ipsum dolor sit amet, consectetur Lorem ipsum dolor sit amet, consectetur Lorem ipsum dolor sit amet, consectetur 1999, char: Lorem ipsum dolor sit amet, consectetur Lorem ipsum dolor sit amet, consectetur Lorem ipsum dolor sit amet, consectetur 1999"}));
-
-  testing::remove_file(filename);
-#endif
-}
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/misc/DocTestExtensions.cpp b/subprojects/quill-4.2.0/quill/test/misc/DocTestExtensions.cpp
deleted file mode 100644
index 446008e..0000000
--- a/subprojects/quill-4.2.0/quill/test/misc/DocTestExtensions.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-#include "DocTestExtensions.h"
-
-#include <memory>
-
-#ifndef _WIN32
-  #include <cstdlib>
-  #include <unistd.h>
-#else
-  #if !defined(WIN32_LEAN_AND_MEAN)
-    #define WIN32_LEAN_AND_MEAN
-  #endif
-
-  #if !defined(NOMINMAX)
-    // Mingw already defines this, so no need to redefine
-    #define NOMINMAX
-  #endif
-
-  #include <windows.h>
-
-  #include <codecvt>
-  #include <io.h>
-  #include <locale>
-  #include <sys/stat.h>
-#endif
-
-namespace quill
-{
-namespace testing
-{
-
-  // The ctor redirects the stream to a temporary file.
-CapturedStream::CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd))
-  {
-#if defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__) || defined(_WIN32)
-    char temp_dir_path[MAX_PATH + 1] = {'\0'};  // NOLINT
-    char temp_file_path[MAX_PATH + 1] = {'\0'}; // NOLINT
-
-    ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
-    const UINT success = ::GetTempFileNameA(temp_dir_path, "dtest_redir",
-                                            0, // Generate unique file name.
-                                            temp_file_path);
-    if (success == 0)
-    {
-      FAIL("Unable to create a temporary file in " << temp_dir_path;);
-    }
-
-    const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
-    if (captured_fd == -1)
-    {
-      FAIL("Unable to open_file temporary file " << temp_file_path);
-    }
-    filename_ = temp_file_path;
-#else
-    // There's no guarantee that a test has write access to the current
-    // directory, so we create the temporary file in the /tmp directory
-    // instead.
-    // We use /tmp on most systems, and /sdcard on Android.
-    // That's because Android doesn't have /tmp.
-
-  #if defined(__ANDROID__)
-    char name_template[] = "/data/local/tmp/doctest_captured_stream.XXXXXX";
-  #else
-    char name_template[] = "/tmp/captured_stream.XXXXXX";
-  #endif // __ANDROID__
-
-    const int captured_fd = mkstemp(name_template);
-
-    if (captured_fd == -1)
-    {
-      FAIL("Failed to create tmp file "
-           << name_template << " for test; does the test have access to the /tmp directory?");
-    }
-
-    filename_ = name_template;
-#endif   // _WIN32
-
-    fflush(nullptr);
-    dup2(captured_fd, fd_);
-    close(captured_fd);
-  }
-
-  CapturedStream::~CapturedStream() { remove(filename_.c_str()); }
-
-  std::string CapturedStream::GetCapturedString()
-  {
-    if (uncaptured_fd_ != -1)
-    {
-      // Restores the original stream.
-      fflush(nullptr);
-      dup2(uncaptured_fd_, fd_);
-      close(uncaptured_fd_);
-      uncaptured_fd_ = -1;
-    }
-
-    FILE* const file = _fopen(filename_.c_str(), "r");
-    if (file == nullptr)
-    {
-      // FAIL("Failed to open_file tmp file " << filename_ << " for capturing stream.");
-    }
-
-    std::string content = _read_entire_file(file);
-    _fclose(file);
-    return content;
-  }
-
-  std::string CapturedStream::_read_entire_file(FILE* file)
-  {
-    size_t const file_size = _get_file_size(file);
-    std::unique_ptr<char[]> buffer{new char[file_size]};
-
-    size_t bytes_last_read = 0; // # of bytes read in the last fread()
-    size_t bytes_read = 0;      // # of bytes read so far
-
-    fseek(file, 0, SEEK_SET);
-
-    do
-    {
-      // Keeps reading the file until we cannot read further or the
-      // pre-determined file size is reached.
-      bytes_last_read = fread(buffer.get() + bytes_read, 1, file_size - bytes_read, file);
-      bytes_read += bytes_last_read;
-    } while (bytes_last_read > 0 && bytes_read < file_size);
-
-    std::string content{buffer.get(), bytes_read};
-    return content;
-  }
-
-  size_t CapturedStream::_get_file_size(FILE* file)
-  {
-    fseek(file, 0, SEEK_END);
-    return static_cast<size_t>(ftell(file));
-  }
-
-  FILE* CapturedStream::_fopen(char const* path, char const* mode)
-  {
-#if defined(_WIN32)
-    struct wchar_codecvt : public std::codecvt<wchar_t, char, std::mbstate_t>
-    {
-    };
-    std::wstring_convert<wchar_codecvt> converter;
-    std::wstring wide_path = converter.from_bytes(path);
-    std::wstring wide_mode = converter.from_bytes(mode);
-    return _wfopen(wide_path.c_str(), wide_mode.c_str());
-#else
-    return fopen(path, mode);
-#endif // _WIN32
-  }
-
-  int CapturedStream::_fclose(FILE* fp) { return fclose(fp); }
-
-  // Starts capturing an output stream (stdout/stderr).
-  void CaptureStream(int fd, const char* stream_name, CapturedStream** stream)
-  {
-    if (*stream != nullptr)
-    {
-      FAIL("Only one " << stream_name << " capturer can exist at a time.");
-    }
-    *stream = new CapturedStream(fd);
-  }
-
-  // Stops capturing the output stream and returns the captured string.
-  std::string GetCapturedStream(CapturedStream** captured_stream)
-  {
-    std::string content = (*captured_stream)->GetCapturedString();
-
-    delete *captured_stream;
-    *captured_stream = nullptr;
-
-    return content;
-  }
-
-#if defined(_MSC_VER) || defined(__BORLANDC__)
-  // MSVC and C++Builder do not provide a definition of STDERR_FILENO.
-  const int kStdOutFileno = 1;
-  const int kStdErrFileno = 2;
-#else
-  const int kStdOutFileno = STDOUT_FILENO;
-  const int kStdErrFileno = STDERR_FILENO;
-#endif // _MSC_VER
-
-  void CaptureStdout() { CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout); }
-
-  void CaptureStderr() { CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr); }
-
-  std::string GetCapturedStdout() { return GetCapturedStream(&g_captured_stdout); }
-
-  std::string GetCapturedStderr() { return GetCapturedStream(&g_captured_stderr); }
-
-  } // namespace testing
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/misc/DocTestExtensions.h b/subprojects/quill-4.2.0/quill/test/misc/DocTestExtensions.h
deleted file mode 100644
index 5f154ab..0000000
--- a/subprojects/quill-4.2.0/quill/test/misc/DocTestExtensions.h
+++ /dev/null
@@ -1,97 +0,0 @@
-#pragma once
-
-#include "doctest/doctest.h"
-#include "quill/core/Attributes.h"
-
-
-#include <iostream>
-#include <cstdio>
-#include <cstring>
-#include <string>
-#include <string_view>
-
-#define REQUIRE_STREQ(str1, str2)                                                                  \
-  do                                                                                               \
-  {                                                                                                \
-    if (strcmp(str1, str2) != 0)                                                                   \
-    {                                                                                              \
-      MESSAGE("Expected equality of these values: \n\t str1: "                                     \
-              << std::string_view{str1} << "\n\t str2: " << std::string_view{str2});               \
-      REQUIRE_UNARY(false);                                                                        \
-    };                                                                                             \
-  } while (0)
-
-#define REQUIRE_WSTREQ(str1, str2)                                                                 \
-  do                                                                                               \
-  {                                                                                                \
-    if (wcscmp(str1, str2) != 0)                                                                   \
-    {                                                                                              \
-      MESSAGE("Expected equality of these values: \n\t str1: " << str1 << "\n\t str2: " << str2);  \
-      REQUIRE_UNARY(false);                                                                        \
-    };                                                                                             \
-  } while (0)
-
-#define REQUIRE_STRNEQ(str1, str2)                                                                    \
-  do                                                                                                  \
-  {                                                                                                   \
-    if (strcmp(str1, str2) == 0)                                                                      \
-    {                                                                                                 \
-      MESSAGE("Expected non-equality of these values: \n\t str1: " << str1 << "\n\t str2: " << str2); \
-      REQUIRE_UNARY(false);                                                                           \
-    };                                                                                                \
-  } while (0)
-
-namespace quill
-{
-namespace testing
-{
-/**
- * Object that captures an output stream (stdout/stderr).
- */
-class CapturedStream
-{
-public:
-  // The ctor redirects the stream to a temporary file.
-  explicit CapturedStream(int fd);
-
-  ~CapturedStream();
-
-  std::string GetCapturedString();
-
-private:
-  static std::string _read_entire_file(FILE* file);
-
-  static size_t _get_file_size(FILE* file);
-
-  static FILE* _fopen(char const* path, char const* mode);
-
-  static int _fclose(FILE* fp);
-
-private:
-  int fd_; // A stream to capture.
-  int uncaptured_fd_;
-  std::string filename_; // Name of the temporary file holding the stderr output.
-};
-
-QUILL_MAYBE_UNUSED static CapturedStream* g_captured_stderr = nullptr;
-QUILL_MAYBE_UNUSED static CapturedStream* g_captured_stdout = nullptr;
-
-// Starts capturing an output stream (stdout/stderr).
-void CaptureStream(int fd, const char* stream_name, CapturedStream** stream);
-
-// Stops capturing the output stream and returns the captured string.
-std::string GetCapturedStream(CapturedStream** captured_stream);
-
-// Starts capturing stdout.
-void CaptureStdout();
-
-// Starts capturing stderr.
-void CaptureStderr();
-
-// Stops capturing stdout and returns the captured string.
-std::string GetCapturedStdout();
-
-// Stops capturing stderr and returns the captured string.
-std::string GetCapturedStderr();
-} // namespace testing
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/misc/TestMain.cpp b/subprojects/quill-4.2.0/quill/test/misc/TestMain.cpp
deleted file mode 100644
index 9522fa7..0000000
--- a/subprojects/quill-4.2.0/quill/test/misc/TestMain.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
-#include "doctest/doctest.h"
diff --git a/subprojects/quill-4.2.0/quill/test/misc/TestUtilities.cpp b/subprojects/quill-4.2.0/quill/test/misc/TestUtilities.cpp
deleted file mode 100644
index aec8e24..0000000
--- a/subprojects/quill-4.2.0/quill/test/misc/TestUtilities.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-#include "TestUtilities.h"
-
-#include <algorithm>
-#include <chrono>
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <iterator>
-#include <random>
-#include <sstream>
-#include <string>
-#include <system_error>
-#include <utility>
-#include <vector>
-
-namespace quill
-{
-namespace testing
-{
-// Convert the given file to a vector
-std::vector<std::string> file_contents(fs::path const& filename)
-{
-  std::ifstream out_file(filename.string());
-
-  std::vector<std::string> lines;
-
-  for (std::string current_line; getline(out_file, current_line);)
-  {
-    lines.push_back(current_line);
-  }
-
-  return lines;
-}
-
-// Convert the given file to a vector
-std::vector<std::wstring> wfile_contents(fs::path const& filename)
-{
-  std::wifstream out_file(filename.string());
-
-  std::vector<std::wstring> lines;
-
-  for (std::wstring current_line; getline(out_file, current_line);)
-  {
-    lines.push_back(current_line);
-  }
-
-  return lines;
-}
-
-// Search a vector for the given string
-bool file_contains(std::vector<std::string> const& file_vector, std::string const& search_string)
-{
-  auto const search =
-    std::find_if(file_vector.cbegin(), file_vector.cend(), [&search_string](std::string const& elem)
-                 { return elem.find(search_string) != std::string::npos; });
-
-  bool const success = search != file_vector.cend();
-
-  if (!success)
-  {
-    // We failed to find and we will log for diagnostic reasons
-    std::cout << "Failed to find '" << search_string << "' in:\n";
-    for (auto const& line : file_vector)
-    {
-      std::cout << "'" << line << "'\n";
-    }
-  }
-
-  return success;
-}
-
-void create_file(fs::path const& filename, std::string const& text)
-{
-  if (std::ofstream file(filename); file.is_open())
-  {
-    if (!text.empty())
-    {
-      file << text;
-    }
-    file.close();
-  }
-}
-
-void remove_file(fs::path const& filename)
-{
-  std::error_code ec;
-  fs::remove(filename, ec);
-}
-
-std::vector<std::string> gen_random_strings(size_t n, int min_len, int max_len)
-{
-  // Generate random strings
-  std::random_device rd;
-  std::mt19937 mt(rd());
-  std::uniform_int_distribution<int> dist_chars(32, 126);
-
-  // length of strings
-  std::uniform_int_distribution<int> dist_len(min_len, max_len);
-
-  // Generate a vector of random strings of dist_len
-  std::vector<std::string> random_strings_vec;
-  random_strings_vec.reserve(n);
-
-  std::string result;
-  for (size_t i = 0; i < n; ++i)
-  {
-    std::generate_n(std::back_inserter(result), dist_len(mt),
-                    [&] { return static_cast<char>(dist_chars(mt)); });
-    random_strings_vec.emplace_back(std::move(result));
-  }
-  return random_strings_vec;
-}
-
-uint64_t parse_timestamp(std::string const& timestamp_str)
-{
-  std::tm tm = {};
-  std::istringstream ss(timestamp_str);
-  ss >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S"); // Extract date and time
-
-  // Extract fractional seconds
-  size_t pos = timestamp_str.find('.');
-  std::string fractional_seconds_str = timestamp_str.substr(pos + 1, 9);
-  uint64_t fractional_seconds = std::stoull(fractional_seconds_str);
-
-  auto time_point = std::chrono::system_clock::from_time_t(std::mktime(&tm));
-  auto nanoseconds_since_epoch =
-    std::chrono::duration_cast<std::chrono::nanoseconds>(time_point.time_since_epoch()).count();
-  return static_cast<uint64_t>(nanoseconds_since_epoch) + fractional_seconds;
-}
-
-bool is_timestamp_ordered(std::vector<std::string> const& file_contents)
-{
-  uint64_t previous_timestamp = 0;
-  bool first = true;
-
-  for (auto const& line : file_contents)
-  {
-    uint64_t current_timestamp = parse_timestamp(line);
-
-    if (!first)
-    {
-      if (current_timestamp < previous_timestamp)
-      {
-        return false;
-      }
-    }
-
-    previous_timestamp = current_timestamp;
-    first = false;
-  }
-
-  return true;
-}
-} // namespace testing
-} // namespace quill
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/misc/TestUtilities.h b/subprojects/quill-4.2.0/quill/test/misc/TestUtilities.h
deleted file mode 100644
index 3ecfac9..0000000
--- a/subprojects/quill-4.2.0/quill/test/misc/TestUtilities.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#pragma once
-
-#include "quill/core/Common.h"
-#include "quill/core/Filesystem.h"
-
-#include "DocTestExtensions.h"
-
-#include <cstring>
-#include <string>
-#include <vector>
-
-namespace quill
-{
-namespace testing
-{
-// Convert the given file to a vector
-std::vector<std::string> file_contents(fs::path const& filename);
-std::vector<std::wstring> wfile_contents(fs::path const& filename);
-
-// Search a vector for the given string
-bool file_contains(std::vector<std::string> const& file_vector, std::string const& search_string);
-void create_file(fs::path const& filename, std::string const& text = std::string{});
-void remove_file(fs::path const& filename);
-
-std::vector<std::string> gen_random_strings(size_t n, int min_len, int max_len);
-
-uint64_t parse_timestamp(std::string const& timestamp_str);
-bool is_timestamp_ordered(std::vector<std::string> const& file_contents);
-} // namespace testing
-} // namespace quill
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/BoundedQueueTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/BoundedQueueTest.cpp
deleted file mode 100644
index 8fdc129..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/BoundedQueueTest.cpp
+++ /dev/null
@@ -1,137 +0,0 @@
-#include "doctest/doctest.h"
-#include "misc/DocTestExtensions.h"
-
-#include "quill/core/BoundedSPSCQueue.h"
-
-#include <cstring>
-#include <thread>
-#include <vector>
-
-TEST_SUITE_BEGIN("BoundedQueue");
-
-using namespace quill::detail;
-
-#if !defined(QUILL_X86ARCH)
-// QUILL_X86ARCH requires at least a queue capacity of 1024 and those tests are using a smaller number
-
-TEST_CASE("read_write_buffer")
-{
-  BoundedSPSCQueue buffer{64u};
-
-  for (uint32_t i = 0; i < 128; ++i)
-  {
-    {
-      std::byte* write_buf = buffer.prepare_write(32u);
-      REQUIRE_NE(write_buf, nullptr);
-      buffer.finish_write(32u);
-      buffer.commit_write();
-    }
-
-    {
-      std::byte* write_buf = buffer.prepare_write(32u);
-      REQUIRE_NE(write_buf, nullptr);
-      buffer.finish_write(32u);
-      buffer.commit_write();
-    }
-
-    {
-      std::byte* res = buffer.prepare_read();
-      REQUIRE(res);
-      buffer.finish_read(32u);
-      buffer.commit_read();
-    }
-
-    {
-      std::byte* res = buffer.prepare_read();
-      REQUIRE(res);
-      buffer.finish_read(32u);
-      buffer.commit_read();
-
-      res = buffer.prepare_read();
-      REQUIRE_FALSE(res);
-    }
-  }
-
-  std::byte* res = buffer.prepare_read();
-  REQUIRE_FALSE(res);
-}
-
-TEST_CASE("bounded_queue_integer_overflow")
-{
-  BoundedSPSCQueueImpl<uint8_t> buffer{128, false, 0};
-  size_t constexpr iterations = static_cast<size_t>(std::numeric_limits<uint8_t>::max()) * 8ull;
-
-  for (size_t i = 0; i < iterations; ++i)
-  {
-    std::string to_write{"test"};
-    to_write += std::to_string(i);
-    std::byte* r = buffer.prepare_write(static_cast<uint8_t>(to_write.length()) + 1);
-    std::strncpy(reinterpret_cast<char*>(r), to_write.data(), to_write.length() + 1);
-    buffer.finish_write(static_cast<uint8_t>(to_write.length()) + 1);
-    buffer.commit_write();
-
-    // now read
-    std::byte* w = buffer.prepare_read();
-    REQUIRE(w);
-    char result[256];
-    std::memcpy(&result[0], w, static_cast<uint8_t>(to_write.length()) + 1);
-    REQUIRE_STREQ(result, to_write.data());
-    buffer.finish_read(static_cast<uint8_t>(to_write.length()) + 1);
-    buffer.commit_read();
-  }
-}
-#endif
-
-TEST_CASE("bounded_queue_read_write_multithreaded_plain_ints")
-{
-  BoundedSPSCQueue buffer{131'072};
-
-  std::thread producer_thread(
-    [&buffer]()
-    {
-      for (uint32_t wrap_cnt = 0; wrap_cnt < 20; ++wrap_cnt)
-      {
-        for (uint32_t i = 0; i < 8192; ++i)
-        {
-          std::byte* write_buffer = buffer.prepare_write(sizeof(uint32_t));
-
-          while (!write_buffer)
-          {
-            std::this_thread::sleep_for(std::chrono::microseconds{2});
-            write_buffer = buffer.prepare_write(sizeof(uint32_t));
-          }
-
-          std::memcpy(write_buffer, &i, sizeof(uint32_t));
-          buffer.finish_write(sizeof(uint32_t));
-          buffer.commit_write();
-        }
-      }
-    });
-
-  std::thread consumer_thread(
-    [&buffer]()
-    {
-      for (uint32_t wrap_cnt = 0; wrap_cnt < 20; ++wrap_cnt)
-      {
-        for (uint32_t i = 0; i < 8192; ++i)
-        {
-          std::byte const* read_buffer = buffer.prepare_read();
-          while (!read_buffer)
-          {
-            std::this_thread::sleep_for(std::chrono::microseconds{2});
-            read_buffer = buffer.prepare_read();
-          }
-
-          auto const value = reinterpret_cast<uint32_t const*>(read_buffer);
-          REQUIRE_EQ(*value, i);
-          buffer.finish_read(sizeof(uint32_t));
-          buffer.commit_read();
-        }
-      }
-    });
-
-  producer_thread.join();
-  consumer_thread.join();
-}
-
-TEST_SUITE_END();
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/CMakeLists.txt b/subprojects/quill-4.2.0/quill/test/unit_tests/CMakeLists.txt
deleted file mode 100644
index 3f25720..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/CMakeLists.txt
+++ /dev/null
@@ -1,66 +0,0 @@
-function(quill_add_test TEST_NAME SOURCES)
-    set(HEADER_FILES
-            ${PROJECT_SOURCE_DIR}/quill/test/bundled/doctest/doctest.h
-            ${PROJECT_SOURCE_DIR}/quill/test/misc/TestUtilities.h
-    )
-
-    set(ADD_SOURCE_FILES
-            ${PROJECT_SOURCE_DIR}/quill/test/misc/TestMain.cpp
-            ${PROJECT_SOURCE_DIR}/quill/test/misc/TestUtilities.cpp
-            ${PROJECT_SOURCE_DIR}/quill/test/misc/DocTestExtensions.cpp)
-
-    list(APPEND SOURCES ${ADD_SOURCE_FILES})
-
-    # Create a test executable
-    add_executable(${TEST_NAME} "")
-
-    set_common_compile_options(${TEST_NAME})
-
-    # Add sources
-    target_sources(${TEST_NAME} PRIVATE ${SOURCES} ${HEADER_FILES})
-
-    # include dirs
-    target_include_directories(${TEST_NAME}
-            PUBLIC
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/quill/test/misc>
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/quill/test/bundled>
-            $<INSTALL_INTERFACE:include>
-            PRIVATE
-            ${PROJECT_SOURCE_DIR}/quill/test)
-
-    # Link dependencies
-    target_link_libraries(${TEST_NAME} quill)
-
-    # Do not decay cxx standard if not specified
-    set_property(TARGET ${TEST_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
-
-    # Set output test directory
-    set_target_properties(${TEST_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/build/test)
-
-    # Add this target to the post build unit tests
-    doctest_discover_tests(${TEST_NAME})
-endfunction()
-
-include(${PROJECT_SOURCE_DIR}/cmake/doctest.cmake)
-
-quill_add_test(TEST_BoundedQueueTest BoundedQueueTest.cpp)
-quill_add_test(TEST_DynamicFormatArgStore DynamicFormatArgStoreTest.cpp)
-quill_add_test(TEST_FileUtilities FileUtilitiesTest.cpp)
-quill_add_test(TEST_LoggerManager LoggerManagerTest.cpp)
-quill_add_test(TEST_Logger LoggerTest.cpp)
-quill_add_test(TEST_LogLevel LogLevelTest.cpp)
-quill_add_test(TEST_MacroMetadata MacroMetadataTest.cpp)
-quill_add_test(TEST_MathUtils MathUtilsTest.cpp)
-quill_add_test(TEST_PatternFormatter PatternFormatterTest.cpp)
-quill_add_test(TEST_RotatingFileSink RotatingFileSinkTest.cpp)
-quill_add_test(TEST_SinkManager SinkManagerTest.cpp)
-quill_add_test(TEST_StringFromTime StringFromTimeTest.cpp)
-quill_add_test(TEST_ThreadContextManager ThreadContextManagerTest.cpp)
-quill_add_test(TEST_TimestampFormatter TimestampFormatterTest.cpp)
-quill_add_test(TEST_TransitEventBuffer TransitEventBufferTest.cpp)
-quill_add_test(TEST_UnboundedQueue.cpp UnboundedQueueTest.cpp)
-quill_add_test(TEST_Utility UtilityTest.cpp)
-
-if (NOT QUILL_USE_VALGRIND)
-    quill_add_test(TEST_RdtscClock RdtscClockTest.cpp)
-endif ()
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/DynamicFormatArgStoreTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/DynamicFormatArgStoreTest.cpp
deleted file mode 100644
index f2f51bd..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/DynamicFormatArgStoreTest.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/DocTestExtensions.h"
-#include "quill/core/DynamicFormatArgStore.h"
-
-#include "quill/bundled/fmt/format.h"
-
-TEST_SUITE_BEGIN("DynamicFormatArgStore");
-
-using namespace quill;
-using namespace quill::detail;
-
-/***/
-TEST_CASE("dynamic_format_arg_store")
-{
-  // DynamicFormatArgStore store;
-  DynamicFormatArgStore store;
-
-  store.push_back(42);
-  store.push_back(std::string_view{"abc"});
-  store.push_back(1.5f);
-
-  // c style string allocates
-  store.push_back("efg");
-
-  std::string result = fmtquill::vformat(
-    "{} and {} and {} and {}",
-    fmtquill::basic_format_args<fmtquill::format_context>{store.get_types(), store.data()});
-
-  REQUIRE_EQ(result, std::string{"42 and abc and 1.5 and efg"});
-}
-
-TEST_SUITE_END();
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/FileUtilitiesTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/FileUtilitiesTest.cpp
deleted file mode 100644
index 874fdfa..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/FileUtilitiesTest.cpp
+++ /dev/null
@@ -1,166 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/DocTestExtensions.h"
-#include "quill/core/Common.h"
-#include "quill/sinks/FileSink.h"
-
-TEST_SUITE_BEGIN("FileUtilities");
-
-using namespace quill;
-using namespace quill::detail;
-
-class FileSinkMock : public quill::FileSink
-{
-public:
-  static std::pair<std::string, std::string> extract_stem_and_extension(
-    fs::path const& filename) noexcept
-  {
-    return quill::FileSink::extract_stem_and_extension(filename);
-  }
-
-  static fs::path append_datetime_to_filename(
-    fs::path const& filename, bool with_time = false, Timezone timezone = Timezone::LocalTime,
-    std::chrono::system_clock::time_point timestamp = {}) noexcept
-  {
-    return quill::FileSink::append_datetime_to_filename(filename, with_time, timezone, timestamp);
-  }
-};
-
-/***/
-TEST_CASE("extract_stem_and_extension")
-{
-  {
-    // simple file
-    fs::path fname = "logfile";
-    auto const res = FileSinkMock::extract_stem_and_extension(fname);
-    REQUIRE_STREQ(res.first.data(), fname.string().data());
-    REQUIRE_STREQ(res.second.data(), "");
-  }
-
-  {
-    // simple directory
-    fs::path fname = "etc";
-    fname /= "eng";
-    fname /= "logfile";
-
-    auto const res = FileSinkMock::extract_stem_and_extension(fname);
-    REQUIRE_STREQ(res.first.data(), fname.string().data());
-    REQUIRE_STREQ(res.second.data(), "");
-  }
-
-  {
-    // no file extension
-    fs::path fname = "logfile.";
-    auto const res = FileSinkMock::extract_stem_and_extension(fname);
-    REQUIRE_STREQ(res.first.data(), "logfile");
-    REQUIRE_STREQ(res.second.data(), ".");
-  }
-
-  {
-    // no file extension - directory
-    fs::path fname = "etc";
-    fname /= "eng";
-    fname /= "logfile.";
-
-    fs::path fname_expected = "etc";
-    fname_expected /= "eng";
-    fname_expected /= "logfile";
-
-    auto const res = FileSinkMock::extract_stem_and_extension(fname);
-    REQUIRE_STREQ(res.first.data(), fname_expected.string().data());
-    REQUIRE_STREQ(res.second.data(), ".");
-  }
-
-  {
-    // hidden file
-    fs::path fname = ".logfile.";
-    auto const res = FileSinkMock::extract_stem_and_extension(fname);
-    REQUIRE_STREQ(res.first.data(), ".logfile");
-    REQUIRE_STREQ(res.second.data(), ".");
-  }
-
-#ifndef QUILL_HAS_EXPERIMENTAL_FILESYSTEM
-  {
-    // hidden file - directory
-    fs::path fname = "etc";
-    fname /= "eng";
-    fname /= ".logfile";
-
-    auto const res = FileSinkMock::extract_stem_and_extension(fname);
-
-    // in gcc 7.3.1 with experimental filesystem this line fails with str1: etc/eng != str2: /etc/eng/.logfile
-    REQUIRE_STREQ(res.first.data(), fname.string().data());
-    REQUIRE_STREQ(res.second.data(), "");
-  }
-#endif
-
-  {
-    // valid stem and extension
-    fs::path fname = "logfile.log";
-    fs::path fname_expected = "logfile";
-    fs::path extension_expected = ".log";
-    auto const res = FileSinkMock::extract_stem_and_extension(fname);
-    REQUIRE_STREQ(res.first.data(), fname_expected.string().data());
-    REQUIRE_STREQ(res.second.data(), extension_expected.string().data());
-  }
-
-  {
-    // valid stem and extension - directory
-    fs::path fname = "etc";
-    fname /= "eng";
-    fname /= "logfile.log";
-
-    fs::path fname_expected = "etc";
-    fname_expected /= "eng";
-    fname_expected /= "logfile";
-
-    fs::path extension_expected = ".log";
-    auto const res = FileSinkMock::extract_stem_and_extension(fname);
-    REQUIRE_STREQ(res.first.data(), fname_expected.string().data());
-    REQUIRE_STREQ(res.second.data(), extension_expected.string().data());
-  }
-
-  {
-    // valid stem and extension - directory
-    fs::path fname = "/etc";
-    fname /= "eng";
-    fname /= "logfile.log";
-
-    fs::path fname_expected = "/etc";
-    fname_expected /= "eng";
-    fname_expected /= "logfile";
-
-    fs::path extension_expected = ".log";
-    auto const res = FileSinkMock::extract_stem_and_extension(fname);
-    REQUIRE_STREQ(res.first.data(), fname_expected.string().data());
-    REQUIRE_STREQ(res.second.data(), extension_expected.string().data());
-  }
-}
-
-/***/
-TEST_CASE("append_date_to_filename")
-{
-  std::chrono::system_clock::time_point const ts =
-    std::chrono::system_clock::time_point{std::chrono::seconds{1583376945}};
-  fs::path const expected_fname = "logfile_20200305.log";
-  fs::path const base_fname = "logfile.log";
-
-  REQUIRE_STREQ(
-    FileSinkMock::append_datetime_to_filename(base_fname, false, quill::Timezone::GmtTime, ts).string().data(),
-    expected_fname.string().data());
-}
-
-/***/
-TEST_CASE("append_datetime_to_filename")
-{
-  std::chrono::system_clock::time_point const ts =
-    std::chrono::system_clock::time_point{std::chrono::seconds{1583376945}};
-  fs::path const expected_fname = "logfile_20200305_025545.log";
-  fs::path const base_fname = "logfile.log";
-
-  REQUIRE_STREQ(
-    FileSinkMock::append_datetime_to_filename(base_fname, true, quill::Timezone::GmtTime, ts).string().data(),
-    expected_fname.string().data());
-}
-
-TEST_SUITE_END();
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/LogLevelTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/LogLevelTest.cpp
deleted file mode 100644
index 13254ac..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/LogLevelTest.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/core/LogLevel.h"
-#include "quill/core/QuillError.h"
-
-TEST_SUITE_BEGIN("LogLevel");
-
-using namespace quill;
-using namespace std::literals;
-
-/***/
-TEST_CASE("loglevel_to_string")
-{
-  {
-    LogLevel log_level{LogLevel::Dynamic};
-    REQUIRE_STREQ(loglevel_to_string(log_level).data(), "DYNAMIC");
-  }
-
-  {
-    LogLevel log_level{LogLevel::None};
-    REQUIRE_STREQ(loglevel_to_string(log_level).data(), "NONE");
-  }
-
-  {
-    LogLevel log_level{LogLevel::Backtrace};
-    REQUIRE_STREQ(loglevel_to_string(log_level).data(), "BACKTRACE");
-  }
-
-  {
-    LogLevel log_level{LogLevel::Critical};
-    REQUIRE_STREQ(loglevel_to_string(log_level).data(), "CRITICAL");
-  }
-
-  {
-    LogLevel log_level{LogLevel::Error};
-    REQUIRE_STREQ(loglevel_to_string(log_level).data(), "ERROR");
-  }
-
-  {
-    LogLevel log_level{LogLevel::Warning};
-    REQUIRE_STREQ(loglevel_to_string(log_level).data(), "WARNING");
-  }
-
-  {
-    LogLevel log_level{LogLevel::Info};
-    REQUIRE_STREQ(loglevel_to_string(log_level).data(), "INFO");
-  }
-
-  {
-    LogLevel log_level{LogLevel::Debug};
-    REQUIRE_STREQ(loglevel_to_string(log_level).data(), "DEBUG");
-  }
-
-  {
-    LogLevel log_level{LogLevel::TraceL1};
-    REQUIRE_STREQ(loglevel_to_string(log_level).data(), "TRACE_L1");
-  }
-
-  {
-    LogLevel log_level{LogLevel::TraceL2};
-    REQUIRE_STREQ(loglevel_to_string(log_level).data(), "TRACE_L2");
-  }
-
-  {
-    LogLevel log_level{LogLevel::TraceL3};
-    REQUIRE_STREQ(loglevel_to_string(log_level).data(), "TRACE_L3");
-  }
-
-  {
-#ifndef QUILL_NO_EXCEPTIONS
-    LogLevel log_level;
-    log_level = static_cast<LogLevel>(-1);
-    REQUIRE_THROWS_AS(QUILL_MAYBE_UNUSED auto s = loglevel_to_string(log_level).data(), quill::QuillError);
-    REQUIRE_THROWS_AS(QUILL_MAYBE_UNUSED auto s = loglevel_to_string_id(log_level).data(), quill::QuillError);
-#endif
-  }
-}
-
-/***/
-TEST_CASE("loglevel_from_string")
-{
-  {
-    std::string log_level{"Dynamic"};
-    REQUIRE_EQ(loglevel_from_string(log_level), LogLevel::Dynamic);
-  }
-
-  {
-    std::string log_level{"None"};
-    REQUIRE_EQ(loglevel_from_string(log_level), LogLevel::None);
-  }
-
-  {
-    std::string log_level{"Backtrace"};
-    REQUIRE_EQ(loglevel_from_string(log_level), LogLevel::Backtrace);
-  }
-
-  {
-    std::string log_level{"Critical"};
-    REQUIRE_EQ(loglevel_from_string(log_level), LogLevel::Critical);
-  }
-
-  {
-    std::string log_level{"Error"};
-    REQUIRE_EQ(loglevel_from_string(log_level), LogLevel::Error);
-  }
-
-  {
-    std::string log_level{"Warning"};
-    REQUIRE_EQ(loglevel_from_string(log_level), LogLevel::Warning);
-  }
-
-  {
-    std::string log_level{"Info"};
-    REQUIRE_EQ(loglevel_from_string(log_level), LogLevel::Info);
-  }
-
-  {
-    std::string log_level{"Debug"};
-    REQUIRE_EQ(loglevel_from_string(log_level), LogLevel::Debug);
-  }
-
-  {
-    std::string log_level{"TraceL1"};
-    REQUIRE_EQ(loglevel_from_string(log_level), LogLevel::TraceL1);
-  }
-
-  {
-    std::string log_level{"TraceL2"};
-    REQUIRE_EQ(loglevel_from_string(log_level), LogLevel::TraceL2);
-  }
-
-  {
-    std::string log_level{"TraceL3"};
-    REQUIRE_EQ(loglevel_from_string(log_level), LogLevel::TraceL3);
-  }
-
-  {
-#ifndef QUILL_NO_EXCEPTIONS
-    std::string log_level{"dummy"};
-    REQUIRE_THROWS_AS(QUILL_MAYBE_UNUSED auto res = loglevel_from_string(log_level), quill::QuillError);
-#endif
-  }
-}
-
-TEST_SUITE_END();
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/LoggerManagerTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/LoggerManagerTest.cpp
deleted file mode 100644
index 3f23dbf..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/LoggerManagerTest.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "quill/Logger.h"
-#include "quill/core/LoggerManager.h"
-#include "quill/sinks/ConsoleSink.h"
-
-TEST_SUITE_BEGIN("LoggerManager");
-
-using namespace quill;
-using namespace quill::detail;
-
-/***/
-TEST_CASE("create_get_remove_logger")
-{
-  std::shared_ptr<ConsoleSink> sink = std::make_unique<ConsoleSink>();
-
-  LoggerManager& lm = LoggerManager::instance();
-
-  std::vector<std::shared_ptr<Sink>> sinks;
-  sinks.push_back(sink);
-
-  LoggerBase* logger_1 = lm.create_or_get_logger<Logger>(
-    "logger_1", std::move(sinks),
-    "%(time) [%(thread_id)] %(short_source_location:<28) "
-    "LOG_%(log_level:<9) %(logger:<12) %(message)",
-    "%H:%M:%S.%Qns", quill::Timezone::GmtTime, ClockSourceType::Tsc, nullptr);
-
-  LoggerBase* logger_2 = lm.create_or_get_logger<Logger>(
-    "logger_2", std::initializer_list<std::shared_ptr<Sink>>{sink},
-    "[%(thread_id)] %(short_source_location:<28) "
-    "LOG_%(log_level:<9) %(logger:<12) %(message)",
-    "%H:%M:%S.%Qns", quill::Timezone::GmtTime, ClockSourceType::Tsc, nullptr);
-
-  REQUIRE_EQ(logger_1->get_logger_name(), "logger_1");
-  REQUIRE_EQ(logger_2->get_logger_name(), "logger_2");
-
-  REQUIRE_EQ(lm.get_logger("logger_1")->get_logger_name(), "logger_1");
-  REQUIRE_EQ(lm.get_logger("logger_2")->get_logger_name(), "logger_2");
-  REQUIRE_EQ(lm.get_logger("logger_3"), nullptr);
-
-  REQUIRE_EQ(lm.get_all_loggers().size(), 2);
-  REQUIRE_EQ(lm.get_all_loggers()[0]->get_logger_name(), "logger_1");
-  REQUIRE_EQ(lm.get_all_loggers()[1]->get_logger_name(), "logger_2");
-
-  // try_remove_logger_1_queue_has_pending_messages
-  {
-    lm.remove_logger(logger_1);
-
-    // Logger is only marked invalid at this stage
-    REQUIRE_EQ(lm.get_all_loggers().size(), 1);
-    REQUIRE_EQ(lm.get_all_loggers()[0]->get_logger_name(), "logger_2");
-
-    // count will include also the invalidated loggers
-    REQUIRE_EQ(lm.get_number_of_loggers(), 2);
-
-    // Logger is not removed yet because we have pending records
-    std::vector<std::string> const removed_loggers =
-      lm.cleanup_invalidated_loggers([]() { return false; });
-
-    REQUIRE_EQ(removed_loggers.size(), 0);
-    REQUIRE_EQ(lm.get_number_of_loggers(), 2);
-  }
-
-  // try_remove_logger_1_queue_is_empty
-  {
-    lm.remove_logger(logger_1);
-
-    // Logger is only marked invalid at this stage
-    REQUIRE_EQ(lm.get_all_loggers().size(), 1);
-    REQUIRE_EQ(lm.get_all_loggers()[0]->get_logger_name(), "logger_2");
-
-    // count will include also the invalidated loggers
-    REQUIRE_EQ(lm.get_number_of_loggers(), 2);
-
-    // Logger is removed since we pass true meaning the queue is empty
-    std::vector<std::string> const removed_loggers =
-      lm.cleanup_invalidated_loggers([]() { return true; });
-
-    REQUIRE_EQ(removed_loggers.size(), 1);
-    REQUIRE_EQ(removed_loggers[0], "logger_1");
-
-    REQUIRE_EQ(lm.get_all_loggers().size(), 1);
-    REQUIRE_EQ(lm.get_all_loggers()[0]->get_logger_name(), "logger_2");
-
-    // Number of loggers is also updated after removal
-    REQUIRE_EQ(lm.get_number_of_loggers(), 1);
-  }
-
-  // try_remove_logger_2_queue_has_pending_messages
-  {
-    lm.remove_logger(logger_2);
-
-    // Logger is only marked invalid at this stage
-    REQUIRE_EQ(lm.get_all_loggers().size(), 0);
-
-    // Logger is not removed yet because we have pending records
-    std::vector<std::string> const removed_loggers =
-      lm.cleanup_invalidated_loggers([]() { return false; });
-
-    REQUIRE_EQ(removed_loggers.size(), 0);
-
-    REQUIRE_EQ(lm.get_all_loggers().size(), 0);
-    REQUIRE_EQ(lm.get_number_of_loggers(), 1);
-  }
-
-  // try_remove_logger_2_queue_is_empty
-  {
-    lm.remove_logger(logger_2);
-
-    // Logger is only marked invalid at this stage
-    REQUIRE_EQ(lm.get_all_loggers().size(), 0);
-
-    // Logger is removed since we pass true meaning the queue is empty
-    std::vector<std::string> const removed_loggers =
-      lm.cleanup_invalidated_loggers([]() { return true; });
-
-    REQUIRE_EQ(removed_loggers.size(), 1);
-    REQUIRE_EQ(removed_loggers[0], "logger_2");
-
-    REQUIRE_EQ(lm.get_all_loggers().size(), 0);
-    REQUIRE_EQ(lm.get_number_of_loggers(), 0);
-  }
-}
-
-TEST_SUITE_END();
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/LoggerTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/LoggerTest.cpp
deleted file mode 100644
index 9ddfe7d..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/LoggerTest.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "quill/Logger.h"
-#include "quill/core/LoggerManager.h"
-
-#include "quill/sinks/ConsoleSink.h"
-
-TEST_SUITE_BEGIN("Logger");
-
-using namespace quill;
-using namespace quill::detail;
-
-/***/
-TEST_CASE("check_logger")
-{
-  std::shared_ptr<ConsoleSink> sink = std::make_unique<ConsoleSink>();
-
-  LoggerManager& lm = LoggerManager::instance();
-
-  std::vector<std::shared_ptr<Sink>> sinks;
-  sinks.push_back(std::move(sink));
-
-  Logger* logger_1 = static_cast<Logger*>(lm.create_or_get_logger<Logger>(
-    "logger_1", std::move(sinks),
-    "%(time) [%(thread_id)] %(short_source_location:<28) "
-    "LOG_%(log_level:<9) %(logger:<12) %(message)",
-    "%H:%M:%S.%Qns", quill::Timezone::GmtTime, ClockSourceType::Tsc, nullptr));
-
-  // Check default log level
-  REQUIRE_EQ(logger_1->get_log_level(), LogLevel::Info);
-  REQUIRE_EQ(logger_1->get_logger_name(), "logger_1");
-
-#ifndef QUILL_NO_EXCEPTIONS
-  // throw if backtrace log level is used
-  REQUIRE_THROWS_AS(logger_1->set_log_level(LogLevel::Backtrace), quill::QuillError);
-#endif
-}
-
-/***/
-TEST_CASE("logger_should_log")
-{
-  std::shared_ptr<ConsoleSink> sink = std::make_unique<ConsoleSink>();
-
-  LoggerManager& lm = LoggerManager::instance();
-
-  std::vector<std::shared_ptr<Sink>> sinks;
-  sinks.push_back(std::move(sink));
-
-  Logger* logger_1 = static_cast<Logger*>(lm.create_or_get_logger<Logger>(
-    "logger_1", std::move(sinks),
-    "%(time) [%(thread_id)] %(short_source_location:<28) "
-    "LOG_%(log_level:<9) %(logger:<12) %(message)",
-    "%H:%M:%S.%Qns", quill::Timezone::GmtTime, ClockSourceType::Tsc, nullptr));
-
-  REQUIRE_UNARY_FALSE(logger_1->should_log_message<LogLevel::Debug>());
-  REQUIRE(logger_1->should_log_message<LogLevel::Info>());
-  REQUIRE(logger_1->should_log_message<LogLevel::Error>());
-
-  // change log level
-  logger_1->set_log_level(LogLevel::TraceL3);
-  REQUIRE(logger_1->should_log_message<LogLevel::TraceL3>());
-  REQUIRE(logger_1->should_log_message<LogLevel::Critical>());
-
-  // change log level
-  logger_1->set_log_level(LogLevel::None);
-  REQUIRE_UNARY_FALSE(logger_1->should_log_message<LogLevel::TraceL3>());
-  REQUIRE_UNARY_FALSE(logger_1->should_log_message<LogLevel::Critical>());
-}
-
-TEST_SUITE_END();
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/MacroMetadataTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/MacroMetadataTest.cpp
deleted file mode 100644
index 061238f..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/MacroMetadataTest.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/core/Common.h"
-#include "quill/core/MacroMetadata.h"
-
-TEST_SUITE_BEGIN("MacroMetadata");
-
-using namespace quill::detail;
-using namespace quill;
-
-TEST_CASE("construct")
-{
-  {
-    constexpr MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                                           __FUNCTION__,
-                                           "Test fmt {}",
-                                           nullptr,
-                                           quill::LogLevel::Debug,
-                                           MacroMetadata::Event::Log};
-
-    REQUIRE_STREQ(macro_metadata.message_format(), "Test fmt {}");
-    REQUIRE_EQ(macro_metadata.log_level(), quill::LogLevel::Debug);
-    REQUIRE_STREQ(macro_metadata.line(), "15");
-    REQUIRE_EQ(macro_metadata.has_named_args(), false);
-  }
-
-  {
-    constexpr MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                                           __FUNCTION__,
-                                           "Test another fmt {name}",
-                                           nullptr,
-                                           quill::LogLevel::Info,
-                                           MacroMetadata::Event::Flush};
-
-    REQUIRE_STREQ(macro_metadata.message_format(), "Test another fmt {name}");
-    REQUIRE_EQ(macro_metadata.log_level(), quill::LogLevel::Info);
-    REQUIRE_STREQ(macro_metadata.line(), "29");
-    REQUIRE_EQ(macro_metadata.file_name(), std::string_view{"MacroMetadataTest.cpp"});
-    REQUIRE_STREQ(macro_metadata.short_source_location(), "MacroMetadataTest.cpp:29");
-    REQUIRE_STREQ(macro_metadata.caller_function(), "DOCTEST_ANON_FUNC_3");
-    REQUIRE_EQ(macro_metadata.event(), MacroMetadata::Event::Flush);
-    REQUIRE_EQ(macro_metadata.has_named_args(), true);
-    REQUIRE_NE(std::string_view{macro_metadata.source_location()}.find("MacroMetadataTest.cpp"),
-               std::string_view::npos);
-    REQUIRE_NE(std::string_view{macro_metadata.full_path()}.find("MacroMetadataTest.cpp"),
-               std::string_view::npos);
-  }
-
-  {
-    constexpr MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                                           __FUNCTION__,
-                                           "Test another fmt {name} and {surname} and {{age}}",
-                                           nullptr,
-                                           quill::LogLevel::Info,
-                                           MacroMetadata::Event::Flush};
-
-    REQUIRE_STREQ(macro_metadata.message_format(),
-                  "Test another fmt {name} and {surname} and {{age}}");
-    REQUIRE_EQ(macro_metadata.log_level(), quill::LogLevel::Info);
-    REQUIRE_STREQ(macro_metadata.line(), "51");
-    REQUIRE_EQ(macro_metadata.file_name(), std::string_view{"MacroMetadataTest.cpp"});
-    REQUIRE_STREQ(macro_metadata.short_source_location(), "MacroMetadataTest.cpp:51");
-    REQUIRE_STREQ(macro_metadata.caller_function(), "DOCTEST_ANON_FUNC_3");
-    REQUIRE_EQ(macro_metadata.event(), MacroMetadata::Event::Flush);
-    REQUIRE_EQ(macro_metadata.has_named_args(), true);
-  }
-
-  {
-    constexpr MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                                           __FUNCTION__,
-                                           "Test another fmt {0} and {1} and {2}",
-                                           nullptr,
-                                           quill::LogLevel::Info,
-                                           MacroMetadata::Event::Flush};
-
-    REQUIRE_STREQ(macro_metadata.message_format(), "Test another fmt {0} and {1} and {2}");
-    REQUIRE_EQ(macro_metadata.log_level(), quill::LogLevel::Info);
-    REQUIRE_STREQ(macro_metadata.line(), "70");
-    REQUIRE_EQ(macro_metadata.file_name(), std::string_view{"MacroMetadataTest.cpp"});
-    REQUIRE_STREQ(macro_metadata.short_source_location(), "MacroMetadataTest.cpp:70");
-    REQUIRE_STREQ(macro_metadata.caller_function(), "DOCTEST_ANON_FUNC_3");
-    REQUIRE_EQ(macro_metadata.event(), MacroMetadata::Event::Flush);
-    REQUIRE_EQ(macro_metadata.has_named_args(), false);
-  }
-}
-
-TEST_SUITE_END();
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/MathUtilsTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/MathUtilsTest.cpp
deleted file mode 100644
index d0f4846..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/MathUtilsTest.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/core/MathUtils.h"
-
-TEST_SUITE_BEGIN("MathUtils");
-
-using namespace quill::detail;
-using namespace quill;
-
-TEST_CASE("is_power_of_two")
-{
-  // Test with power of two numbers
-  CHECK(is_power_of_two(1) == true);
-  CHECK(is_power_of_two(2) == true);
-  CHECK(is_power_of_two(4) == true);
-  CHECK(is_power_of_two(8) == true);
-  CHECK(is_power_of_two(16) == true);
-  CHECK(is_power_of_two(1024) == true);
-
-  // Test with non-power of two numbers
-  CHECK(is_power_of_two(0) == false);
-  CHECK(is_power_of_two(3) == false);
-  CHECK(is_power_of_two(5) == false);
-  CHECK(is_power_of_two(6) == false);
-  CHECK(is_power_of_two(7) == false);
-  CHECK(is_power_of_two(9) == false);
-
-  // Test edge cases
-  CHECK(is_power_of_two(std::numeric_limits<std::size_t>::max()) == false);
-}
-
-TEST_CASE("next_power_of_two_unsigned")
-{
-  // Test with numbers that are already powers of two
-  CHECK(next_power_of_two(1u) == 1u);
-  CHECK(next_power_of_two(2u) == 2u);
-  CHECK(next_power_of_two(4u) == 4u);
-  CHECK(next_power_of_two(8u) == 8u);
-  CHECK(next_power_of_two(16u) == 16u);
-  CHECK(next_power_of_two(1024u) == 1024u);
-
-  // Test with numbers that are not powers of two
-  CHECK(next_power_of_two(0u) == 1u);
-  CHECK(next_power_of_two(3u) == 4u);
-  CHECK(next_power_of_two(5u) == 8u);
-  CHECK(next_power_of_two(6u) == 8u);
-  CHECK(next_power_of_two(7u) == 8u);
-  CHECK(next_power_of_two(9u) == 16u);
-
-  // Test edge cases
-  constexpr std::size_t max_power_of_2 = (std::numeric_limits<std::size_t>::max() >> 1) + 1;
-  CHECK(next_power_of_two(std::numeric_limits<std::size_t>::max() - 1) == max_power_of_2); // Handling near overflow case
-  CHECK(next_power_of_two(std::numeric_limits<std::size_t>::max() / 2 + 1) == max_power_of_2); // Largest possible input
-}
-
-TEST_CASE("next_power_of_two_signed")
-{
-  // Test with positive numbers that are already powers of two
-  CHECK(next_power_of_two(1) == 1);
-  CHECK(next_power_of_two(2) == 2);
-  CHECK(next_power_of_two(4) == 4);
-  CHECK(next_power_of_two(8) == 8);
-  CHECK(next_power_of_two(16) == 16);
-  CHECK(next_power_of_two(1024) == 1024);
-
-  // Test with positive numbers that are not powers of two
-  CHECK(next_power_of_two(0) == 1);
-  CHECK(next_power_of_two(3) == 4);
-  CHECK(next_power_of_two(5) == 8);
-  CHECK(next_power_of_two(6) == 8);
-  CHECK(next_power_of_two(7) == 8);
-  CHECK(next_power_of_two(9) == 16);
-
-  // Test edge cases
-  constexpr int max_power_of_2_signed = (std::numeric_limits<int>::max() >> 1) + 1;
-  CHECK(next_power_of_two(std::numeric_limits<int>::max() - 1) == max_power_of_2_signed); // Handling near overflow case for int
-  CHECK(next_power_of_two(std::numeric_limits<int>::max() / 2 + 1) == max_power_of_2_signed); // Middle large input for int
-}
-
-TEST_SUITE_END();
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/PatternFormatterTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/PatternFormatterTest.cpp
deleted file mode 100644
index 307d982..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/PatternFormatterTest.cpp
+++ /dev/null
@@ -1,419 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "quill/backend/PatternFormatter.h"
-#include "quill/core/Common.h"
-#include "quill/core/MacroMetadata.h"
-#include <chrono>
-#include <string_view>
-#include <vector>
-
-TEST_SUITE_BEGIN("PatternFormatter");
-
-using namespace quill::detail;
-using namespace quill;
-
-char const* thread_name = "test_thread";
-std::string_view process_id = "123";
-
-TEST_CASE("default_pattern_formatter")
-{
-  PatternFormatter default_pattern_formatter;
-
-  uint64_t const ts{1579815761000023021};
-  char const* thread_id = "31341";
-  std::string const logger_name = "test_logger";
-  MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                               __func__,
-                               "This the {} formatter {}",
-                               nullptr,
-                               LogLevel::Info,
-                               MacroMetadata::Event::Log};
-
-  // Format to a buffer
-  fmtquill::memory_buffer log_msg;
-  fmtquill::format_to(std::back_inserter(log_msg),
-                      fmtquill::runtime(macro_metadata.message_format()), "pattern", 1234);
-
-  std::vector<std::pair<std::string, std::string>> named_args;
-
-  auto const& formatted_buffer = default_pattern_formatter.format(
-    ts, thread_id, thread_name, process_id, logger_name, loglevel_to_string(macro_metadata.log_level()),
-    macro_metadata, &named_args, std::string_view{log_msg.data(), log_msg.size()});
-
-  // Convert the buffer to a string
-  std::string const formatted_string = fmtquill::to_string(formatted_buffer);
-
-  // Default pattern formatter is using local time to convert the timestamp to timezone, in this test we ignore the timestamp
-  std::string const expected_string =
-    "[31341] PatternFormatterTest.cpp:25  LOG_INFO      test_logger  This the pattern formatter "
-    "1234\n";
-  auto const found_expected = formatted_string.find(expected_string);
-  REQUIRE_NE(found_expected, std::string::npos);
-}
-
-TEST_CASE("custom_pattern_message_only")
-{
-  // Message only
-  PatternFormatter custom_pattern_formatter{"%(log_level_id) %(message)", "%H:%M:%S.%Qns", Timezone::GmtTime};
-
-  uint64_t const ts{1579815761000023000};
-  char const* thread_id = "31341";
-  std::string const logger_name = "test_logger";
-  MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                               __func__,
-                               "This the {1} formatter {0}",
-                               nullptr,
-                               LogLevel::Debug,
-                               MacroMetadata::Event::Log};
-
-  // Format to a buffer
-  fmtquill::memory_buffer log_msg;
-  fmtquill::format_to(std::back_inserter(log_msg),
-                      fmtquill::runtime(macro_metadata.message_format()), "pattern", 12.34);
-
-  std::vector<std::pair<std::string, std::string>> named_args;
-
-  auto const& formatted_buffer = custom_pattern_formatter.format(
-    ts, thread_id, thread_name, process_id, logger_name, loglevel_to_string(macro_metadata.log_level()),
-    macro_metadata, &named_args, std::string_view{log_msg.data(), log_msg.size()});
-
-  // Convert the buffer to a string
-  std::string const formatted_string = fmtquill::to_string(formatted_buffer);
-  std::string const expected_string = "D This the 12.34 formatter pattern\n";
-
-  REQUIRE_EQ(formatted_string, expected_string);
-}
-
-TEST_CASE("custom_pattern_timestamp_precision_nanoseconds")
-{
-  // Custom pattern with part 1 and part 3
-  PatternFormatter custom_pattern_formatter{
-    "%(time) [%(thread_id)] %(file_name):%(line_number) LOG_%(log_level) %(logger) "
-    "%(message) [%(caller_function)]",
-    "%m-%d-%Y %H:%M:%S.%Qns", Timezone::GmtTime};
-
-  uint64_t const ts{1579815761000023000};
-  char const* thread_id = "31341";
-  std::string const logger_name = "test_logger";
-  MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                               __func__,
-                               "This the {1} formatter {0}",
-                               nullptr,
-                               LogLevel::Debug,
-                               MacroMetadata::Event::Log};
-
-  // Format to a buffer
-  fmtquill::memory_buffer log_msg;
-  fmtquill::format_to(std::back_inserter(log_msg),
-                      fmtquill::runtime(macro_metadata.message_format()), "pattern", 1234);
-
-  std::vector<std::pair<std::string, std::string>> named_args;
-
-  auto const& formatted_buffer = custom_pattern_formatter.format(
-    ts, thread_id, thread_name, process_id, logger_name, loglevel_to_string(macro_metadata.log_level()),
-    macro_metadata, &named_args, std::string_view{log_msg.data(), log_msg.size()});
-
-  // Convert the buffer to a string
-  std::string const formatted_string = fmtquill::to_string(formatted_buffer);
-
-  std::string const expected_string =
-    "01-23-2020 21:42:41.000023000 [31341] PatternFormatterTest.cpp:98 LOG_DEBUG test_logger "
-    "This the 1234 formatter pattern [DOCTEST_ANON_FUNC_7]\n";
-
-  REQUIRE_EQ(formatted_string, expected_string);
-}
-
-TEST_CASE("custom_pattern_timestamp_precision_microseconds")
-{
-  PatternFormatter custom_pattern_formatter{
-    "%(time) [%(thread_id)] %(file_name):%(line_number) LOG_%(log_level) %(logger) "
-    "%(message) [%(caller_function)]",
-    "%m-%d-%Y %H:%M:%S.%Qus", Timezone::GmtTime};
-
-  uint64_t const ts{1579815761020123000};
-  char const* thread_id = "31341";
-  std::string const logger_name = "test_logger";
-  MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                               __func__,
-                               "This the {1} formatter {0}",
-                               nullptr,
-                               LogLevel::Debug,
-                               MacroMetadata::Event::Log};
-
-  // Format to a buffer
-  fmtquill::memory_buffer log_msg;
-  fmtquill::format_to(std::back_inserter(log_msg),
-                      fmtquill::runtime(macro_metadata.message_format()), "pattern", 1234);
-
-  std::vector<std::pair<std::string, std::string>> named_args;
-
-  auto const& formatted_buffer = custom_pattern_formatter.format(
-    ts, thread_id, thread_name, process_id, logger_name, loglevel_to_string(macro_metadata.log_level()),
-    macro_metadata, &named_args, std::string_view{log_msg.data(), log_msg.size()});
-
-  // Convert the buffer to a string
-  std::string const formatted_string = fmtquill::to_string(formatted_buffer);
-
-  std::string const expected_string =
-    "01-23-2020 21:42:41.020123 [31341] PatternFormatterTest.cpp:136 LOG_DEBUG test_logger "
-    "This the 1234 formatter pattern [DOCTEST_ANON_FUNC_9]\n";
-
-  REQUIRE_EQ(formatted_string, expected_string);
-}
-
-TEST_CASE("custom_pattern_timestamp_precision_milliseconds")
-{
-  PatternFormatter custom_pattern_formatter{
-    "%(time) [%(thread_id)] %(file_name):%(line_number) LOG_%(log_level) %(logger) "
-    "%(message) [%(caller_function)]",
-    "%m-%d-%Y %H:%M:%S.%Qms", Timezone::GmtTime};
-
-  uint64_t const ts{1579815761099000000};
-  char const* thread_id = "31341";
-  std::string const logger_name = "test_logger";
-  MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                               __func__,
-                               "This the {1} formatter {0}",
-                               nullptr,
-                               LogLevel::Debug,
-                               MacroMetadata::Event::Log};
-
-  // Format to a buffer
-  fmtquill::memory_buffer log_msg;
-  fmtquill::format_to(std::back_inserter(log_msg),
-                      fmtquill::runtime(macro_metadata.message_format()), "pattern", 1234);
-
-  std::vector<std::pair<std::string, std::string>> named_args;
-
-  auto const& formatted_buffer = custom_pattern_formatter.format(
-    ts, thread_id, thread_name, process_id, logger_name, loglevel_to_string(macro_metadata.log_level()),
-    macro_metadata, &named_args, std::string_view{log_msg.data(), log_msg.size()});
-
-  // Convert the buffer to a string
-  std::string const formatted_string = fmtquill::to_string(formatted_buffer);
-
-  std::string const expected_string =
-    "01-23-2020 21:42:41.099 [31341] PatternFormatterTest.cpp:174 LOG_DEBUG test_logger This "
-    "the 1234 formatter pattern [DOCTEST_ANON_FUNC_11]\n";
-
-  REQUIRE_EQ(formatted_string, expected_string);
-}
-
-TEST_CASE("custom_pattern_timestamp_precision_none")
-{
-  PatternFormatter custom_pattern_formatter{
-    "%(time) [%(thread_id)] %(file_name):%(line_number) LOG_%(log_level) %(logger) "
-    "%(message) [%(caller_function)]",
-    "%m-%d-%Y %H:%M:%S", Timezone::GmtTime};
-
-  uint64_t const ts{1579815761099220000};
-  char const* thread_id = "31341";
-  std::string const logger_name = "test_logger";
-  MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                               __func__,
-                               "This the {1} formatter {0}",
-                               nullptr,
-                               LogLevel::Debug,
-                               MacroMetadata::Event::Log};
-
-  // Format to a buffer
-  fmtquill::memory_buffer log_msg;
-  fmtquill::format_to(std::back_inserter(log_msg),
-                      fmtquill::runtime(macro_metadata.message_format()), "pattern", 1234);
-
-  std::vector<std::pair<std::string, std::string>> named_args;
-
-  auto const& formatted_buffer = custom_pattern_formatter.format(
-    ts, thread_id, thread_name, process_id, logger_name, loglevel_to_string(macro_metadata.log_level()),
-    macro_metadata, &named_args, std::string_view{log_msg.data(), log_msg.size()});
-
-  // Convert the buffer to a string
-  std::string const formatted_string = fmtquill::to_string(formatted_buffer);
-
-  std::string const expected_string =
-    "01-23-2020 21:42:41 [31341] PatternFormatterTest.cpp:212 LOG_DEBUG test_logger This the "
-    "1234 formatter pattern [DOCTEST_ANON_FUNC_13]\n";
-
-  REQUIRE_EQ(formatted_string, expected_string);
-}
-
-TEST_CASE("custom_pattern_timestamp_strftime_reallocation_on_format_string_2")
-{
-  // set a timestamp_format that will cause timestamp _formatted_date to re-allocate.
-  PatternFormatter custom_pattern_formatter{
-    "%(time) [%(thread_id)] %(file_name):%(line_number) LOG_%(log_level) %(logger) "
-    "%(message) [%(caller_function)]",
-    "%FT%T.%Qus%FT%T", Timezone::GmtTime};
-
-  uint64_t const ts{1579815761099220000};
-  char const* thread_id = "31341";
-  std::string const logger_name = "test_logger";
-  MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                               __func__,
-                               "This the {1} formatter {0}",
-                               nullptr,
-                               LogLevel::Debug,
-                               MacroMetadata::Event::Log};
-
-  for (size_t i = 0; i < 5; ++i)
-  {
-    // Format to a buffer
-    fmtquill::memory_buffer log_msg;
-    fmtquill::format_to(std::back_inserter(log_msg),
-                        fmtquill::runtime(macro_metadata.message_format()), "pattern", 1234);
-
-    std::vector<std::pair<std::string, std::string>> named_args;
-
-    auto const& formatted_buffer = custom_pattern_formatter.format(
-      ts, thread_id, thread_name, process_id, logger_name, loglevel_to_string(macro_metadata.log_level()),
-      macro_metadata, &named_args, std::string_view{log_msg.data(), log_msg.size()});
-
-    // Convert the buffer to a string
-    std::string const formatted_string = fmtquill::to_string(formatted_buffer);
-
-    std::string const expected_string =
-      "2020-01-23T21:42:41.0992202020-01-23T21:42:41 [31341] PatternFormatterTest.cpp:251 "
-      "LOG_DEBUG test_logger This the 1234 formatter pattern [DOCTEST_ANON_FUNC_15]\n";
-
-    REQUIRE_EQ(formatted_string, expected_string);
-  }
-}
-
-TEST_CASE("custom_pattern_timestamp_strftime_reallocation_when_adding_fractional_seconds")
-{
-  // set a timestamp_format that will cause timestamp _formatted_date to re-allocate.
-  PatternFormatter custom_pattern_formatter{
-    "%(time) [%(thread_id)] %(file_name):%(line_number) LOG_%(log_level) %(logger) "
-    "%(message) [%(caller_function)]",
-    "%FT%T.%T.%Qus%FT%T", Timezone::GmtTime};
-
-  uint64_t const ts{1579815761099220000};
-  char const* thread_id = "31341";
-  std::string const logger_name = "test_logger";
-  MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                               __func__,
-                               "This the {1} formatter {0}",
-                               nullptr,
-                               LogLevel::Debug,
-                               MacroMetadata::Event::Log};
-
-  for (size_t i = 0; i < 5; ++i)
-  {
-    // Format to a buffer
-    fmtquill::memory_buffer log_msg;
-    fmtquill::format_to(std::back_inserter(log_msg),
-                        fmtquill::runtime(macro_metadata.message_format()), "pattern", 1234);
-
-    std::vector<std::pair<std::string, std::string>> named_args;
-
-    auto const& formatted_buffer = custom_pattern_formatter.format(
-      ts, thread_id, thread_name, process_id, logger_name, loglevel_to_string(macro_metadata.log_level()),
-      macro_metadata, &named_args, std::string_view{log_msg.data(), log_msg.size()});
-
-    // Convert the buffer to a string
-    std::string const formatted_string = fmtquill::to_string(formatted_buffer);
-
-    std::string const expected_string =
-      "2020-01-23T21:42:41.21:42:41.0992202020-01-23T21:42:41 [31341] PatternFormatterTest.cpp:293 "
-      "LOG_DEBUG test_logger This the 1234 formatter pattern [DOCTEST_ANON_FUNC_17]\n";
-
-    REQUIRE_EQ(formatted_string, expected_string);
-  }
-}
-
-#ifndef QUILL_NO_EXCEPTIONS
-TEST_CASE("invalid_pattern")
-{
-  // missing %)
-  REQUIRE_THROWS_AS(
-    PatternFormatter("%(time [%(thread_id)] %(file_name):%(line_number) %(log_level) %(logger) "
-                     "%(message) [%(caller_function)]",
-                     "%H:%M:%S.%Qns", Timezone::GmtTime),
-    quill::QuillError);
-
-  // invalid attribute %(invalid)
-  REQUIRE_THROWS_AS(
-    PatternFormatter("%(invalid) [%(thread_id)] %(file_name):%(line_number) %(log_level) %(logger) "
-                     "%(message) [%(caller_function)]",
-                     "%H:%M:%S.%Qns", Timezone::GmtTime),
-    quill::QuillError);
-}
-#endif
-
-TEST_CASE("custom_pattern")
-{
-  // Custom pattern with part 1 and part 2
-  PatternFormatter custom_pattern_formatter{
-    "%(time) [%(thread_id)] %(file_name):%(line_number) LOG_%(log_level) %(logger) %(message)",
-    "%m-%d-%Y %H:%M:%S.%Qns", Timezone::GmtTime};
-
-  uint64_t const ts{1579815761000023000};
-  char const* thread_id = "31341";
-  std::string const logger_name = "test_logger";
-  MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                               __func__,
-                               "This the {1} formatter {0}",
-                               nullptr,
-                               LogLevel::Debug,
-                               MacroMetadata::Event::Log};
-
-  // Format to a buffer
-  fmtquill::memory_buffer log_msg;
-  fmtquill::format_to(std::back_inserter(log_msg),
-                      fmtquill::runtime(macro_metadata.message_format()), "pattern", 1234);
-
-  std::vector<std::pair<std::string, std::string>> named_args;
-
-  auto const& formatted_buffer = custom_pattern_formatter.format(
-    ts, thread_id, thread_name, process_id, logger_name, loglevel_to_string(macro_metadata.log_level()),
-    macro_metadata, &named_args, std::string_view{log_msg.data(), log_msg.size()});
-
-  // Convert the buffer to a string
-  std::string const formatted_string = fmtquill::to_string(formatted_buffer);
-
-  std::string const expected_string =
-    "01-23-2020 21:42:41.000023000 [31341] PatternFormatterTest.cpp:353 LOG_DEBUG test_logger "
-    "This the 1234 formatter pattern\n";
-
-  REQUIRE_EQ(formatted_string, expected_string);
-}
-
-TEST_CASE("custom_pattern_part_3_no_format_specifiers")
-{
-  // Custom pattern with a part 3 that has no format specifiers:
-  //   Part 1 - "|{}|{}|"
-  //   Part 3 - "|EOM|"
-  PatternFormatter custom_pattern_formatter{"|LOG_%(log_level)|%(logger)|%(message)|EOM|",
-                                            "%H:%M:%S", Timezone::GmtTime};
-
-  uint64_t const ts{1579815761000023000};
-  char const* thread_id = "31341";
-  std::string const logger_name = "test_logger";
-  MacroMetadata macro_metadata{__FILE__ ":" QUILL_STRINGIFY(__LINE__),
-                               __func__,
-                               "This the {1} formatter {0}",
-                               nullptr,
-                               LogLevel::Debug,
-                               MacroMetadata::Event::Log};
-
-  // Format to a buffer
-  fmtquill::memory_buffer log_msg;
-  fmtquill::format_to(std::back_inserter(log_msg),
-                      fmtquill::runtime(macro_metadata.message_format()), "pattern", 1234);
-
-  std::vector<std::pair<std::string, std::string>> named_args;
-
-  auto const& formatted_buffer = custom_pattern_formatter.format(
-    ts, thread_id, thread_name, process_id, logger_name, loglevel_to_string(macro_metadata.log_level()),
-    macro_metadata, &named_args, std::string_view{log_msg.data(), log_msg.size()});
-
-  // Convert the buffer to a string
-  std::string const formatted_string = fmtquill::to_string(formatted_buffer);
-
-  std::string const expected_string =
-    "|LOG_DEBUG|test_logger|This the 1234 formatter pattern|EOM|\n";
-
-  REQUIRE_EQ(formatted_string, expected_string);
-}
-
-TEST_SUITE_END();
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/RdtscClockTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/RdtscClockTest.cpp
deleted file mode 100644
index a07f0f8..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/RdtscClockTest.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "quill/backend/RdtscClock.h"
-#include "quill/core/Rdtsc.h"
-#include <chrono>
-#include <thread>
-
-TEST_SUITE_BEGIN("RdtscClock");
-
-void check_wall_time_now(quill::detail::RdtscClock const& tsc_clock, size_t& failures)
-{
-  std::chrono::milliseconds constexpr offset{10};
-
-  auto const wall_time_chrono = std::chrono::system_clock::now().time_since_epoch();
-  auto const wall_time_tsc = std::chrono::nanoseconds{tsc_clock.time_since_epoch(quill::detail::rdtsc())};
-
-  auto const lower_bound = wall_time_chrono - offset;
-  auto const upper_bound = wall_time_chrono + offset;
-
-  if (!((wall_time_tsc > lower_bound) && (wall_time_tsc < upper_bound)))
-  {
-    ++failures;
-
-    if (failures > 1)
-    {
-      // wall_time_tsc is not between wall_time_chrono - 1 and wall_time_chrono + 1
-      FAIL("wall_time_tsc: " << wall_time_tsc.count() << " lower_bound: " << lower_bound.count()
-                             << " upper_bound: " << upper_bound.count() << "\n");
-    }
-  }
-}
-
-TEST_CASE("wall_time")
-{
-  quill::detail::RdtscClock const tsc_clock{std::chrono::milliseconds{1200}};
-
-  constexpr size_t num_reps{10};
-  size_t failures{0};
-
-  for (size_t i = 1; i <= num_reps; ++i)
-  {
-    check_wall_time_now(tsc_clock, failures);
-    std::this_thread::sleep_for(std::chrono::milliseconds{i * 100});
-  }
-
-  REQUIRE_LE(failures, 1);
-}
-
-TEST_SUITE_END();
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/RotatingFileSinkTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/RotatingFileSinkTest.cpp
deleted file mode 100644
index 397475f..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/RotatingFileSinkTest.cpp
+++ /dev/null
@@ -1,1967 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/TestUtilities.h"
-#include "quill/core/Common.h"
-#include "quill/sinks/RotatingFileSink.h"
-
-TEST_SUITE_BEGIN("RotatingFileSink");
-
-using namespace quill;
-using namespace quill::detail;
-
-/***/
-TEST_CASE("rotating_file_sink_index_no_backup_limit")
-{
-  fs::path const filename = "rotating_file_sink_index_no_backup_limit.log";
-  fs::path const filename_1 = "rotating_file_sink_index_no_backup_limit.1.log";
-  fs::path const filename_2 = "rotating_file_sink_index_no_backup_limit.2.log";
-  fs::path const filename_3 = "rotating_file_sink_index_no_backup_limit.3.log";
-
-  {
-    auto rfh = RotatingFileSink{filename,
-                                []()
-                                {
-                                  RotatingFileSinkConfig cfg;
-                                  cfg.set_rotation_max_file_size(1024);
-                                  cfg.set_open_mode('w');
-                                  return cfg;
-                                }(),
-                                FileEventNotifier{}};
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, 0, std::string_view{}, std::string_view{}, std::string_view{},
-                            LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-
-  // Read file and check
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [3]"), true);
-
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [0]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_index_with_backup_limit_overwrite_rolled_files")
-{
-  // we expect to have only 2 backup files and to overwrite the rolled files
-  fs::path const filename = "rotating_file_sink_index_with_backup_limit_overwrite_rolled_files.log";
-  fs::path const filename_1 =
-    "rotating_file_sink_index_with_backup_limit_overwrite_rolled_files.1.log";
-  fs::path const filename_2 =
-    "rotating_file_sink_index_with_backup_limit_overwrite_rolled_files.2.log";
-
-  {
-    auto rfh = RotatingFileSink{filename,
-                                []()
-                                {
-                                  RotatingFileSinkConfig cfg;
-                                  cfg.set_rotation_max_file_size(1024);
-                                  cfg.set_max_backup_files(2);
-                                  cfg.set_overwrite_rolled_files(true);
-                                  cfg.set_open_mode('w');
-                                  return cfg;
-                                }(),
-                                FileEventNotifier{}};
-
-    // write some records to the file
-    for (size_t i = 0; i < 12; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, 0, std::string_view{}, std::string_view{}, std::string_view{},
-                            LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-
-  // Read file and check
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [11]"), true);
-
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [10]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [9]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_index_with_backup_limit_dont_overwrite_rolled_files")
-{
-  // we expect to have only 2 backup files and then the rotation will stop and all the
-  // remaining messages will be written to the last file
-  fs::path const filename =
-    "rotating_file_sink_index_with_backup_limit_dont_overwrite_rolled_files.log";
-  fs::path const filename_1 =
-    "rotating_file_sink_index_with_backup_limit_dont_overwrite_rolled_files.1.log";
-  fs::path const filename_2 =
-    "rotating_file_sink_index_with_backup_limit_dont_overwrite_rolled_files.2.log";
-
-  {
-    auto rfh = RotatingFileSink{filename,
-                                []()
-                                {
-                                  RotatingFileSinkConfig cfg;
-                                  cfg.set_rotation_max_file_size(1024);
-                                  cfg.set_max_backup_files(2);
-                                  cfg.set_overwrite_rolled_files(false);
-                                  cfg.set_open_mode('w');
-                                  return cfg;
-                                }(),
-                                FileEventNotifier{}};
-
-    // write some records to the file
-    for (size_t i = 0; i < 12; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, 0, std::string_view{}, std::string_view{}, std::string_view{},
-                            LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-
-  // Read file and check
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [2]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [3]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [4]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [5]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [6]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [7]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [8]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [9]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [10]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [11]"), true);
-
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [0]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_index_open_mode_write_clean_up_old_files")
-{
-  // On write mode, with RotateFileNamingScheme::Index, the log file names can collide
-  // we need to clean up the old files
-  fs::path const filename = "rotating_file_sink_index_open_mode_write_clean_up_old_files.log";
-  fs::path const filename_1 = "rotating_file_sink_index_open_mode_write_clean_up_old_files.1.log";
-  fs::path const filename_2 = "rotating_file_sink_index_open_mode_write_clean_up_old_files.2.log";
-  fs::path const filename_3 = "rotating_file_sink_index_open_mode_write_clean_up_old_files.3.log";
-  fs::path const filename_4 =
-    "rotating_file_sink_index_open_mode_write_clean_up_old_files_another.2.log";
-
-  // create all files simulating the previous run
-  testing::create_file(filename);
-  testing::create_file(filename_1);
-  testing::create_file(filename_2);
-  testing::create_file(filename_4);
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_4));
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_max_file_size(1024);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::Index);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{}};
-
-    REQUIRE_EQ(static_cast<size_t>(fs::file_size(filename)), 0);
-    REQUIRE(!fs::exists(filename_1));
-    REQUIRE(!fs::exists(filename_2));
-    REQUIRE(fs::exists(filename_4));
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, 0, std::string_view{}, std::string_view{}, std::string_view{},
-                            LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-
-  // Read file and check
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [3]"), true);
-
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [0]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-  testing::remove_file(filename_4);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_index_open_mode_write_dont_clean_up_old_files")
-{
-  // On write mode, with RotateFileNamingScheme::Index, the log file names can collide with old
-  // files, but we do not want to clean them up
-  // Eventually the files later will get overwritten by the new files
-
-  fs::path const filename = "rotating_file_sink_index_open_mode_write_dont_clean_up_old_files.log";
-  fs::path const filename_1 =
-    "rotating_file_sink_index_open_mode_write_dont_clean_up_old_files.1.log";
-  fs::path const filename_2 =
-    "rotating_file_sink_index_open_mode_write_dont_clean_up_old_files.2.log";
-  fs::path const filename_3 =
-    "rotating_file_sink_index_open_mode_write_dont_clean_up_old_files.3.log";
-  fs::path const filename_4 =
-    "rotating_file_sink_index_open_mode_write_dont_clean_up_old_files_another.2.log";
-
-  // create all files simulating the previous run
-  testing::create_file(filename);
-  testing::create_file(filename_1);
-  testing::create_file(filename_2);
-  testing::create_file(filename_4);
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_4));
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_max_file_size(1024);
-        cfg.set_remove_old_files(false);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::Index);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{}};
-
-    REQUIRE_EQ(static_cast<size_t>(fs::file_size(filename)), 0);
-    REQUIRE(fs::exists(filename_1));
-    REQUIRE(fs::exists(filename_2));
-    REQUIRE(fs::exists(filename_4));
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, 0, std::string_view{}, std::string_view{}, std::string_view{},
-                            LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-
-  // Read file and check
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [3]"), true);
-
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [0]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_index_open_mode_append")
-{
-  // In append mode, with RotateFileNamingScheme::Index, the log file names can collide
-  // we want to start appending to the last log file and then also rotate it with the correct index
-  // continuing the count from the last run
-  // On write mode, with RotateFileNamingScheme::Index, the log file names can collide
-  // we need to clean up the old files
-  fs::path const filename = "rotating_file_sink_index_open_mode_append.log";
-  fs::path const filename_1 = "rotating_file_sink_index_open_mode_append.1.log";
-  fs::path const filename_2 = "rotating_file_sink_index_open_mode_append.2.log";
-  fs::path const filename_3 = "rotating_file_sink_index_open_mode_append.3.log";
-  fs::path const filename_4 = "rotating_file_sink_index_open_mode_append.4.log";
-  fs::path const filename_5 = "rotating_file_sink_index_open_mode_append.5.log";
-  fs::path const filename_6 = "rotating_file_sink_index_open_mode_append.6.log";
-
-  // create all files simulating the previous run
-  testing::create_file(filename, "Existing [2]");
-  testing::create_file(filename_1, "Existing [1]");
-  testing::create_file(filename_2, "Existing [0]");
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_max_file_size(1024);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::Index);
-        cfg.set_open_mode('a');
-        return cfg;
-      }(),
-      FileEventNotifier{}};
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, 0, std::string_view{}, std::string_view{}, std::string_view{},
-                            LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-  REQUIRE(fs::exists(filename_4));
-  REQUIRE(fs::exists(filename_5));
-  REQUIRE(fs::exists(filename_6));
-
-  // Read file and check
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [3]"), true);
-
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [0]"), true);
-
-  std::vector<std::string> const file_contents_4 = testing::file_contents(filename_4);
-  REQUIRE_EQ(testing::file_contains(file_contents_4, "Existing [2]"), true);
-
-  std::vector<std::string> const file_contents_5 = testing::file_contents(filename_5);
-  REQUIRE_EQ(testing::file_contains(file_contents_5, "Existing [1]"), true);
-
-  std::vector<std::string> const file_contents_6 = testing::file_contents(filename_6);
-  REQUIRE_EQ(testing::file_contains(file_contents_6, "Existing [0]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-  testing::remove_file(filename_4);
-  testing::remove_file(filename_5);
-  testing::remove_file(filename_6);
-}
-
-/** Tests for scheme date **/
-
-/***/
-TEST_CASE("rotating_file_sink_date_no_backup_limit")
-{
-  // e.g .2023-06-12. is the date the rotation occurred
-  uint64_t const timestamp_20230612 = 1686528000000000000;
-  uint64_t const timestamp_20230613 = 1686614400000000000;
-  uint64_t const timestamp_20230614 = 1686700800000000000;
-
-  fs::path const filename_1 = "rotating_file_sink_date_no_backup_limit.20230612.3.log";
-  fs::path const filename_2 = "rotating_file_sink_date_no_backup_limit.20230612.2.log";
-  fs::path const filename_3 = "rotating_file_sink_date_no_backup_limit.20230612.1.log";
-  fs::path const filename_4 = "rotating_file_sink_date_no_backup_limit.20230612.log";
-  fs::path const filename_5 = "rotating_file_sink_date_no_backup_limit.20230613.log";
-  fs::path const filename_6 = "rotating_file_sink_date_no_backup_limit.20230614.1.log";
-  fs::path const filename_7 = "rotating_file_sink_date_no_backup_limit.20230614.log";
-  fs::path const filename = "rotating_file_sink_date_no_backup_limit.log";
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_max_file_size(1024);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::Date);
-        cfg.set_timezone(Timezone::GmtTime);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{},
-      std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(timestamp_20230612 / 1000000000))};
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230612, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    {
-      std::string s{"Record [" + std::to_string(4) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230613, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    // change the date and rotate again
-    for (size_t i = 5; i < 8; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230614, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-  REQUIRE(fs::exists(filename_4));
-  REQUIRE(fs::exists(filename_5));
-  REQUIRE(fs::exists(filename_6));
-  REQUIRE(fs::exists(filename_7));
-
-  // Read file and check
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [0]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents_4 = testing::file_contents(filename_4);
-  REQUIRE_EQ(testing::file_contains(file_contents_4, "Record [3]"), true);
-
-  std::vector<std::string> const file_contents_5 = testing::file_contents(filename_5);
-  REQUIRE_EQ(testing::file_contains(file_contents_5, "Record [4]"), true);
-
-  std::vector<std::string> const file_contents_6 = testing::file_contents(filename_6);
-  REQUIRE_EQ(testing::file_contains(file_contents_6, "Record [5]"), true);
-
-  std::vector<std::string> const file_contents_7 = testing::file_contents(filename_7);
-  REQUIRE_EQ(testing::file_contains(file_contents_7, "Record [6]"), true);
-
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [7]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-  testing::remove_file(filename_4);
-  testing::remove_file(filename_5);
-  testing::remove_file(filename_6);
-  testing::remove_file(filename_7);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_date_with_backup_limit_overwrite_rolled_files")
-{
-  // e.g .2023-06-12. is the date the rotation occurred
-  uint64_t const timestamp_20230612 = 1686528000000000000;
-  uint64_t const timestamp_20230613 = 1686614400000000000;
-  uint64_t const timestamp_20230614 = 1686700800000000000;
-
-  fs::path const filename_2 =
-    "rotating_file_sink_date_with_backup_limit_overwrite_rolled_files.20230614.1.log";
-  fs::path const filename_1 =
-    "rotating_file_sink_date_with_backup_limit_overwrite_rolled_files.20230614.log";
-  fs::path const filename = "rotating_file_sink_date_with_backup_limit_overwrite_rolled_files.log";
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_max_file_size(1024);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::Date);
-        cfg.set_timezone(Timezone::GmtTime);
-        cfg.set_max_backup_files(2);
-        cfg.set_overwrite_rolled_files(true);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{},
-      std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(timestamp_20230612 / 1000000000))};
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230612, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    {
-      // change the date and rotate again
-      std::string s{"Record [" + std::to_string(4) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230613, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    // change the date and rotate again
-    for (size_t i = 5; i < 8; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230614, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-
-  // Read file and check
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [5]"), true);
-
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [6]"), true);
-
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [7]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_date_with_backup_limit_dont_overwrite_rolled_files")
-{
-  // e.g .2023-06-12. is the date the rotation occurred
-  uint64_t const timestamp_20230612 = 1686528000000000000;
-  uint64_t const timestamp_20230613 = 1686614400000000000;
-  uint64_t const timestamp_20230614 = 1686700800000000000;
-
-  fs::path const filename_1 =
-    "rotating_file_sink_date_with_backup_limit_dont_overwrite_rolled_files.20230612.3.log";
-  fs::path const filename_2 =
-    "rotating_file_sink_date_with_backup_limit_dont_overwrite_rolled_files.20230612.2.log";
-  fs::path const filename_3 =
-    "rotating_file_sink_date_with_backup_limit_dont_overwrite_rolled_files.20230612.1.log";
-  fs::path const filename_4 =
-    "rotating_file_sink_date_with_backup_limit_dont_overwrite_rolled_files.20230612.log";
-  fs::path const filename =
-    "rotating_file_sink_date_with_backup_limit_dont_overwrite_rolled_files.log";
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_max_file_size(1024);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::Date);
-        cfg.set_timezone(Timezone::GmtTime);
-        cfg.set_max_backup_files(4);
-        cfg.set_overwrite_rolled_files(false);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{},
-      std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(timestamp_20230612 / 1000000000))};
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230612, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    {
-      // change the date and rotate again
-      std::string s{"Record [" + std::to_string(4) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230613, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    // change the date and rotate again
-    for (size_t i = 5; i < 8; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230614, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-  REQUIRE(fs::exists(filename_4));
-
-  // Read file and check
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [0]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents_4 = testing::file_contents(filename_4);
-  REQUIRE_EQ(testing::file_contains(file_contents_4, "Record [3]"), true);
-
-  std::vector<std::string> const file_contents_5 = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents_5, "Record [4]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents_5, "Record [5]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents_5, "Record [6]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents_5, "Record [7]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-  testing::remove_file(filename_4);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_date_open_mode_write_clean_up_old_files")
-{
-  // On write mode, with RotateFileNamingScheme::Index, the log file names can collide
-
-  // e.g .2023-06-12. is the date the rotation occurred
-  uint64_t const timestamp_20230612 = 1686528000000000000;
-
-  fs::path const filename_1 =
-    "rotating_file_sink_date_open_mode_write_clean_up_old_files.20230612.2.log";
-  fs::path const filename_2 =
-    "rotating_file_sink_date_open_mode_write_clean_up_old_files.20230612.1.log";
-  fs::path const filename_3 =
-    "rotating_file_sink_date_open_mode_write_clean_up_old_files.20230612.log";
-  fs::path const filename = "rotating_file_sink_date_open_mode_write_clean_up_old_files.log";
-
-  //  create files simulating the previous run
-  testing::create_file(filename_1, "Existing [2]");
-  testing::create_file(filename_2, "Existing [1]");
-  testing::create_file(filename_3, "Existing [0]");
-  testing::create_file(filename, "Existing [0]");
-
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-  REQUIRE(fs::exists(filename));
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_max_file_size(1024);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::Date);
-        cfg.set_timezone(Timezone::GmtTime);
-        cfg.set_remove_old_files(true);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{},
-      std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(timestamp_20230612 / 1000000000))};
-
-    REQUIRE_EQ(static_cast<size_t>(fs::file_size(filename)), 0);
-    REQUIRE(!fs::exists(filename_1));
-    REQUIRE(!fs::exists(filename_2));
-    REQUIRE(!fs::exists(filename_3));
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230612, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-
-  // Read file and check
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [3]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_4 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_4, "Record [0]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_date_open_mode_write_dont_clean_up_old_files")
-{
-  // On write mode, the log file names can collide with old
-  // files, but we do not want to clean them up
-  // Eventually the files later will get overwritten by the new files
-
-  // e.g .2023-06-12. is the date the rotation occurred
-  uint64_t const timestamp_20230612 = 1686528000000000000;
-
-  fs::path const filename_1 =
-    "rotating_file_sink_date_open_mode_write_dont_clean_up_old_files.20230612.2.log";
-  fs::path const filename_2 =
-    "rotating_file_sink_date_open_mode_write_dont_clean_up_old_files.20230612.1.log";
-  fs::path const filename_3 =
-    "rotating_file_sink_date_open_mode_write_dont_clean_up_old_files.20230612.log";
-  fs::path const filename = "rotating_file_sink_date_open_mode_write_dont_clean_up_old_files.log";
-
-  //  create files simulating the previous run
-  testing::create_file(filename_1, "Existing [2]");
-  testing::create_file(filename_2, "Existing [1]");
-  testing::create_file(filename_3, "Existing [0]");
-  testing::create_file(filename, "Existing [0]");
-
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-  REQUIRE(fs::exists(filename));
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_max_file_size(1024);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::Date);
-        cfg.set_timezone(Timezone::GmtTime);
-        cfg.set_remove_old_files(false);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{},
-      std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(timestamp_20230612 / 1000000000))};
-
-    REQUIRE_EQ(static_cast<size_t>(fs::file_size(filename)), 0);
-    REQUIRE(fs::exists(filename_1));
-    REQUIRE(fs::exists(filename_2));
-    REQUIRE(fs::exists(filename_3));
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230612, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-
-  // Read file and check
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [3]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_4 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_4, "Record [0]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_data_open_mode_append")
-{
-  // In append mode, with RotateFileNamingScheme::Index, the log file names can collide
-  // we want to start appending to the last log file and then also rotate it with the correct index
-  // continuing the count from the last run
-  // e.g .2023-06-12. is the date the rotation occurred
-  uint64_t const timestamp_20230612 = 1686528000000000000;
-
-  fs::path const filename_7 = "rotating_file_sink_data_open_mode_append.20230612.6.log";
-  fs::path const filename_6 = "rotating_file_sink_data_open_mode_append.20230612.5.log";
-  fs::path const filename_5 = "rotating_file_sink_data_open_mode_append.20230612.4.log";
-  fs::path const filename_4 = "rotating_file_sink_data_open_mode_append.20230612.3.log";
-  fs::path const filename_3 = "rotating_file_sink_data_open_mode_append.20230612.2.log"; // 0
-  fs::path const filename_2 = "rotating_file_sink_data_open_mode_append.20230612.1.log"; // 1
-  fs::path const filename_1 = "rotating_file_sink_data_open_mode_append.20230612.log";   // 2
-  fs::path const filename = "rotating_file_sink_data_open_mode_append.log";              // 3
-
-  //  create files simulating the previous run
-  testing::create_file(filename_1, "Existing [2]");
-  testing::create_file(filename_2, "Existing [1]");
-  testing::create_file(filename_3, "Existing [0]");
-  testing::create_file(filename, "Existing [3]");
-
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-  REQUIRE(fs::exists(filename));
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_max_file_size(1024);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::Date);
-        cfg.set_timezone(Timezone::GmtTime);
-        cfg.set_open_mode('a');
-        return cfg;
-      }(),
-      FileEventNotifier{},
-      std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(timestamp_20230612 / 1000000000))};
-
-    REQUIRE(fs::exists(filename));
-    REQUIRE(fs::exists(filename_1));
-    REQUIRE(fs::exists(filename_2));
-    REQUIRE(fs::exists(filename_3));
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230612, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-  REQUIRE(fs::exists(filename_4));
-  REQUIRE(fs::exists(filename_5));
-  REQUIRE(fs::exists(filename_6));
-  REQUIRE(fs::exists(filename_7));
-
-  // Read file and check
-  std::vector<std::string> const file_contents_7 = testing::file_contents(filename_7);
-  REQUIRE_EQ(testing::file_contains(file_contents_7, "Existing [0]"), true);
-
-  std::vector<std::string> const file_contents_6 = testing::file_contents(filename_6);
-  REQUIRE_EQ(testing::file_contains(file_contents_6, "Existing [1]"), true);
-
-  std::vector<std::string> const file_contents_5 = testing::file_contents(filename_5);
-  REQUIRE_EQ(testing::file_contains(file_contents_5, "Existing [2]"), true);
-
-  std::vector<std::string> const file_contents_4 = testing::file_contents(filename_4);
-  REQUIRE_EQ(testing::file_contains(file_contents_4, "Existing [3]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [0]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [3]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-  testing::remove_file(filename_4);
-  testing::remove_file(filename_5);
-  testing::remove_file(filename_6);
-  testing::remove_file(filename_7);
-}
-
-/** Tests for scheme DateAndTime **/
-
-/***/
-TEST_CASE("rotating_file_sink_dateandtime_no_backup_limit")
-{
-  // e.g .2023-06-12. is the date the rotation occurred
-  uint64_t const timestamp_20230612 = 1686538000000000000;
-  uint64_t const timestamp_20230613 = 1686634400000000000;
-  uint64_t const timestamp_20230613_2 = 1686639400000000000;
-  uint64_t const timestamp_20230614 = 1686700800000000000;
-
-  fs::path const filename_1 =
-    "rotating_file_sink_dateandtime_no_backup_limit.20230612_024640.3.log";
-  fs::path const filename_2 =
-    "rotating_file_sink_dateandtime_no_backup_limit.20230612_024640.2.log";
-  fs::path const filename_3 =
-    "rotating_file_sink_dateandtime_no_backup_limit.20230612_024640.1.log";
-  fs::path const filename_4 = "rotating_file_sink_dateandtime_no_backup_limit.20230612_024640.log";
-  fs::path const filename_5 = "rotating_file_sink_dateandtime_no_backup_limit.20230613_053320.log";
-  fs::path const filename_6 = "rotating_file_sink_dateandtime_no_backup_limit.20230613_065640.log";
-  fs::path const filename_7 =
-    "rotating_file_sink_dateandtime_no_backup_limit.20230614_000000.1.log";
-  fs::path const filename_8 = "rotating_file_sink_dateandtime_no_backup_limit.20230614_000000.log";
-  fs::path const filename = "rotating_file_sink_dateandtime_no_backup_limit.log";
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_max_file_size(1024);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::DateAndTime);
-        cfg.set_timezone(Timezone::GmtTime);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{},
-      std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(timestamp_20230612 / 1000000000))};
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230612, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    {
-      // change the date and rotate again
-
-      std::string s{"Record [" + std::to_string(4) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230613, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    {
-      // change the date and rotate again
-      std::string s{"Record [" + std::to_string(5) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230613_2, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    // change the date and rotate again
-    for (size_t i = 6; i < 9; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230614, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-  REQUIRE(fs::exists(filename_4));
-  REQUIRE(fs::exists(filename_5));
-  REQUIRE(fs::exists(filename_6));
-  REQUIRE(fs::exists(filename_7));
-  REQUIRE(fs::exists(filename_8));
-
-  // Read file and check
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [0]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents_4 = testing::file_contents(filename_4);
-  REQUIRE_EQ(testing::file_contains(file_contents_4, "Record [3]"), true);
-
-  std::vector<std::string> const file_contents_5 = testing::file_contents(filename_5);
-  REQUIRE_EQ(testing::file_contains(file_contents_5, "Record [4]"), true);
-
-  std::vector<std::string> const file_contents_6 = testing::file_contents(filename_6);
-  REQUIRE_EQ(testing::file_contains(file_contents_6, "Record [5]"), true);
-
-  std::vector<std::string> const file_contents_7 = testing::file_contents(filename_7);
-  REQUIRE_EQ(testing::file_contains(file_contents_7, "Record [6]"), true);
-
-  std::vector<std::string> const file_contents_8 = testing::file_contents(filename_8);
-  REQUIRE_EQ(testing::file_contains(file_contents_8, "Record [7]"), true);
-
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [8]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-  testing::remove_file(filename_4);
-  testing::remove_file(filename_5);
-  testing::remove_file(filename_6);
-  testing::remove_file(filename_7);
-  testing::remove_file(filename_8);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_dateandtime_with_backup_limit_overwrite_rolled_files")
-{
-  // e.g .2023-06-12. is the date the rotation occurred
-  uint64_t const timestamp_20230612 = 1686578000000000000;
-  uint64_t const timestamp_20230613 = 1686624400000000000;
-  uint64_t const timestamp_20230614 = 1686720800000000000;
-
-  fs::path const filename_2 =
-    "rotating_file_sink_dateandtime_with_backup_limit_overwrite_rolled_files.20230614_053320.1.log";
-  fs::path const filename_1 =
-    "rotating_file_sink_dateandtime_with_backup_limit_overwrite_rolled_files.20230614_053320.log";
-  fs::path const filename =
-    "rotating_file_sink_dateandtime_with_backup_limit_overwrite_rolled_files.log";
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_max_file_size(1024);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::DateAndTime);
-        cfg.set_timezone(Timezone::GmtTime);
-        cfg.set_max_backup_files(2);
-        cfg.set_overwrite_rolled_files(true);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{},
-      std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(timestamp_20230612 / 1000000000))};
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, 0, std::string_view{}, std::string_view{}, std::string_view{},
-                            LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    {
-      // change the date and rotate again
-      std::string s{"Record [" + std::to_string(4) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230613, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    // change the date and rotate again
-    for (size_t i = 5; i < 8; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230614, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-
-  // Read file and check
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [5]"), true);
-
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [6]"), true);
-
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [7]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_dateandtime_with_backup_limit_dont_overwrite_rolled_files")
-{
-  // e.g .2023-06-12. is the date the rotation occurred
-  uint64_t const timestamp_20230612 = 1686548000000000000;
-  uint64_t const timestamp_20230613 = 1686619400000000000;
-  uint64_t const timestamp_20230614 = 1686710800000000000;
-
-  fs::path const filename_1 =
-    "rotating_file_sink_dateandtime_with_backup_limit_dont_overwrite_rolled_files.20230612_053320."
-    "3."
-    "log";
-  fs::path const filename_2 =
-    "rotating_file_sink_dateandtime_with_backup_limit_dont_overwrite_rolled_files.20230612_053320."
-    "2."
-    "log";
-  fs::path const filename_3 =
-    "rotating_file_sink_dateandtime_with_backup_limit_dont_overwrite_rolled_files.20230612_053320."
-    "1."
-    "log";
-  fs::path const filename_4 =
-    "rotating_file_sink_dateandtime_with_backup_limit_dont_overwrite_rolled_files.20230612_053320."
-    "log";
-  fs::path const filename =
-    "rotating_file_sink_dateandtime_with_backup_limit_dont_overwrite_rolled_files.log";
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_max_file_size(1024);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::DateAndTime);
-        cfg.set_timezone(Timezone::GmtTime);
-        cfg.set_max_backup_files(4);
-        cfg.set_overwrite_rolled_files(false);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{},
-      std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(timestamp_20230612 / 1000000000))};
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230612, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    {
-      // change the date and rotate again
-      std::string s{"Record [" + std::to_string(4) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230613, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    // change the date and rotate again
-    for (size_t i = 5; i < 8; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp_20230614, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-  REQUIRE(fs::exists(filename_4));
-
-  // Read file and check
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [0]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents_4 = testing::file_contents(filename_4);
-  REQUIRE_EQ(testing::file_contains(file_contents_4, "Record [3]"), true);
-
-  std::vector<std::string> const file_contents_5 = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents_5, "Record [4]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents_5, "Record [5]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents_5, "Record [6]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents_5, "Record [7]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-  testing::remove_file(filename_4);
-}
-
-/***/
-TEST_CASE("time_rotation_minutes_rotating_file_sink_index")
-{
-  uint64_t const timestamp_20230612 = 1686528000000000000;
-
-  fs::path const filename_1 = "time_rotation_minutes_rotating_file_sink_index.20230612.3.log";
-  fs::path const filename_2 = "time_rotation_minutes_rotating_file_sink_index.20230612.2.log";
-  fs::path const filename_3 = "time_rotation_minutes_rotating_file_sink_index.20230612.1.log";
-  fs::path const filename_4 = "time_rotation_minutes_rotating_file_sink_index.20230612.log";
-  fs::path const filename = "time_rotation_minutes_rotating_file_sink_index.log";
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_frequency_and_interval('m', 1);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::Date);
-        cfg.set_timezone(Timezone::GmtTime);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{},
-      std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(timestamp_20230612 / 1000000000))};
-
-    uint64_t timestamp = timestamp_20230612;
-
-    for (size_t i = 0; i < 5; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-
-      timestamp += std::chrono::nanoseconds(std::chrono::minutes(1)).count();
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-  REQUIRE(fs::exists(filename_4));
-
-  // Read file and check
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [0]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents_4 = testing::file_contents(filename_4);
-  REQUIRE_EQ(testing::file_contains(file_contents_4, "Record [3]"), true);
-
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [4]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-  testing::remove_file(filename_4);
-}
-
-/***/
-TEST_CASE("time_rotation_hours_rotating_file_sink_index")
-{
-  uint64_t const timestamp_20230612 = 1686528000000000000;
-
-  fs::path const filename_1 = "time_rotation_hours_rotating_file_sink_index.20230612.1.log";
-  fs::path const filename_2 = "time_rotation_hours_rotating_file_sink_index.20230612.log";
-  fs::path const filename = "time_rotation_hours_rotating_file_sink_index.log";
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_frequency_and_interval('h', 2);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::Date);
-        cfg.set_timezone(Timezone::GmtTime);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{},
-      std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(timestamp_20230612 / 1000000000))};
-
-    uint64_t timestamp = timestamp_20230612;
-
-    for (size_t i = 0; i < 5; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, timestamp, std::string_view{}, std::string_view{},
-                            std::string_view{}, LogLevel::Info, nullptr, formatted_log_message);
-
-      timestamp += std::chrono::nanoseconds(std::chrono::hours(1)).count();
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-
-  // Read file and check
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [0]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [1]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [3]"), true);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [4]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-}
-
-/***/
-TEST_CASE("time_rotation_daily_at_time_rotating_file_sink_index")
-{
-  uint64_t const timestamp_20230612 = 1686529000000000000;
-
-  fs::path const filename_1 = "time_rotation_daily_at_time_rotating_file_sink_index.20230612.log";
-  fs::path const filename_2 = "time_rotation_daily_at_time_rotating_file_sink_index.20230613.log";
-  fs::path const filename_3 = "time_rotation_daily_at_time_rotating_file_sink_index.20230614.log";
-  fs::path const filename_4 = "time_rotation_daily_at_time_rotating_file_sink_index.20230615.log";
-  fs::path const filename = "time_rotation_daily_at_time_rotating_file_sink_index.log";
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_time_daily("08:00");
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::Date);
-        cfg.set_timezone(Timezone::GmtTime);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{},
-      std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(timestamp_20230612 / 1000000000))};
-
-    uint64_t ts = timestamp_20230612;
-
-    for (size_t i = 0; i < 5; ++i)
-    {
-      struct tm timeinfo;
-      char buffer[80];
-
-      // Get the timeinfo struct using std::gmtime#
-      time_t timestamp = ts / 1000000000;
-      gmtime_rs(&timestamp, &timeinfo);
-
-      // Use std::strftime to format the date
-      std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &timeinfo);
-
-      std::string s{"Record [" + std::string(buffer) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, ts, std::string_view{}, std::string_view{}, std::string_view{},
-                            LogLevel::Info, nullptr, formatted_log_message);
-
-      ts += std::chrono::nanoseconds(std::chrono::hours(24)).count();
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-  REQUIRE(fs::exists(filename_4));
-
-  // Read file and check
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [2023-06-12 00:16:40]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [2023-06-13 00:16:40]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [2023-06-14 00:16:40]"), true);
-
-  std::vector<std::string> const file_contents_4 = testing::file_contents(filename_4);
-  REQUIRE_EQ(testing::file_contains(file_contents_4, "Record [2023-06-15 00:16:40]"), true);
-
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [2023-06-16 00:16:40]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-  testing::remove_file(filename_4);
-}
-
-/***/
-TEST_CASE("max_size_and_time_rotation_daily_at_time_rotating_file_sink_index")
-{
-  uint64_t const timestamp_20230612 = 1686529000000000000;
-
-  fs::path const filename_1 =
-    "max_size_and_time_rotation_daily_at_time_rotating_file_sink_index.20230612.2.log";
-  fs::path const filename_2 =
-    "max_size_and_time_rotation_daily_at_time_rotating_file_sink_index.20230612.1.log";
-  fs::path const filename_3 =
-    "max_size_and_time_rotation_daily_at_time_rotating_file_sink_index.20230612.log";
-  fs::path const filename_4 =
-    "max_size_and_time_rotation_daily_at_time_rotating_file_sink_index.20230613.log";
-  fs::path const filename = "max_size_and_time_rotation_daily_at_time_rotating_file_sink_index.log";
-
-  {
-    auto rfh = RotatingFileSink{
-      filename,
-      []()
-      {
-        RotatingFileSinkConfig cfg;
-        cfg.set_rotation_time_daily("08:00");
-        cfg.set_rotation_max_file_size(1024);
-        cfg.set_rotation_naming_scheme(RotatingFileSinkConfig::RotationNamingScheme::Date);
-        cfg.set_timezone(Timezone::GmtTime);
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{},
-      std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(timestamp_20230612 / 1000000000))};
-
-    uint64_t ts = timestamp_20230612;
-
-    {
-      struct tm timeinfo;
-      char buffer[80];
-
-      // Get the timeinfo struct using std::gmtime
-      time_t timestamp = ts / 1000000000;
-      gmtime_rs(&timestamp, &timeinfo);
-
-      // Use std::strftime to format the date
-      std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &timeinfo);
-
-      std::string s{"Record [0 " + std::string(buffer) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      rfh.write_log_message(nullptr, ts, std::string_view{}, std::string_view{}, std::string_view{},
-                            LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    {
-      struct tm timeinfo;
-      char buffer[80];
-
-      // Get the timeinfo struct using std::gmtime#
-      time_t timestamp = ts / 1000000000;
-      gmtime_rs(&timestamp, &timeinfo);
-
-      // Use std::strftime to format the date
-      std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &timeinfo);
-
-      std::string s{"Record [1 " + std::string(buffer) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, ts, std::string_view{}, std::string_view{}, std::string_view{},
-                            LogLevel::Info, nullptr, formatted_log_message);
-    }
-
-    for (size_t i = 2; i < 4; ++i)
-    {
-      struct tm timeinfo;
-      char buffer[80];
-
-      // Get the timeinfo struct using std::gmtime#
-      time_t timestamp = ts / 1000000000;
-      gmtime_rs(&timestamp, &timeinfo);
-
-      // Use std::strftime to format the date
-      std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &timeinfo);
-
-      std::string s{"Record [" + std::to_string(i) + " " + std::string(buffer) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      rfh.write_log_message(nullptr, ts, std::string_view{}, std::string_view{}, std::string_view{},
-                            LogLevel::Info, nullptr, formatted_log_message);
-
-      ts += std::chrono::nanoseconds(std::chrono::hours(24)).count();
-    }
-
-    {
-      struct tm timeinfo;
-      char buffer[80];
-
-      // Get the timeinfo struct using std::gmtime#
-      time_t timestamp = ts / 1000000000;
-      gmtime_rs(&timestamp, &timeinfo);
-
-      // Use std::strftime to format the date
-      std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &timeinfo);
-
-      std::string s{"Record [4 " + std::string(buffer) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, ts, std::string_view{}, std::string_view{}, std::string_view{},
-                            LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-  REQUIRE(fs::exists(filename_4));
-
-  // Read file and check
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [0 2023-06-12 00:16:40]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [1 2023-06-12 00:16:40]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [2 2023-06-12 00:16:40]"), true);
-
-  std::vector<std::string> const file_contents_4 = testing::file_contents(filename_4);
-  REQUIRE_EQ(testing::file_contains(file_contents_4, "Record [3 2023-06-13 00:16:40]"), true);
-
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [4 2023-06-14 00:16:40]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_index_dont_remove_unrelated_files")
-{
-  fs::path const filename = "rotating_file_sink_index_dont_remove_unrelated_files.log";
-  fs::path const filename_1 = "rotating_file_sink_index_dont_remove_unrelated_files.1.log";
-  fs::path const filename_2 = "rotating_file_sink_index_dont_remove_unrelated_files.2.log";
-  fs::path const filename_3 = "rotating_file_sink_index_dont_remove_unrelated_files.3.log";
-  fs::path const filename_yaml = "rotating_file_sink_index_dont_remove_unrelated_files.yaml";
-  fs::path const filename_other = "config_rotating_file_sink_index_dont_remove_unrelated_files";
-
-  // create all files simulating the previous run
-  testing::create_file(filename, "Existing [2]");
-  testing::create_file(filename_1, "Existing [1]");
-  testing::create_file(filename_2, "Existing [0]");
-  testing::create_file(filename_3, "Existing [-1]");
-  testing::create_file(filename_yaml, "YAML config");
-  testing::create_file(filename_other, "YAML config");
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-  REQUIRE(fs::exists(filename_yaml));
-  REQUIRE(fs::exists(filename_other));
-
-  {
-    auto rfh = RotatingFileSink{filename,
-                                []()
-                                {
-                                  RotatingFileSinkConfig cfg;
-                                  cfg.set_remove_old_files(true);
-                                  cfg.set_rotation_max_file_size(1024);
-                                  cfg.set_open_mode('w');
-                                  return cfg;
-                                }(),
-                                FileEventNotifier{}};
-
-    REQUIRE(!fs::exists(filename_1));
-    REQUIRE(!fs::exists(filename_2));
-    REQUIRE(!fs::exists(filename_3));
-    REQUIRE(fs::exists(filename_yaml));
-    REQUIRE(fs::exists(filename_other));
-
-    // write some records to the file
-    for (size_t i = 0; i < 4; ++i)
-    {
-      std::string s{"Record [" + std::to_string(i) + "]"};
-      std::string formatted_log_message;
-      formatted_log_message.append(s.data(), s.data() + s.size());
-
-      // Add a big string to rotate the file
-      std::string f;
-      f.resize(1024);
-      formatted_log_message.append(f.data(), f.data() + f.size());
-
-      rfh.write_log_message(nullptr, 0, std::string_view{}, std::string_view{}, std::string_view{},
-                            LogLevel::Info, nullptr, formatted_log_message);
-    }
-  }
-
-  REQUIRE(fs::exists(filename));
-  REQUIRE(fs::exists(filename_1));
-  REQUIRE(fs::exists(filename_2));
-  REQUIRE(fs::exists(filename_3));
-
-  // Read file and check
-  std::vector<std::string> const file_contents = testing::file_contents(filename);
-  REQUIRE_EQ(testing::file_contains(file_contents, "Record [3]"), true);
-
-  std::vector<std::string> const file_contents_1 = testing::file_contents(filename_1);
-  REQUIRE_EQ(testing::file_contains(file_contents_1, "Record [2]"), true);
-
-  std::vector<std::string> const file_contents_2 = testing::file_contents(filename_2);
-  REQUIRE_EQ(testing::file_contains(file_contents_2, "Record [1]"), true);
-
-  std::vector<std::string> const file_contents_3 = testing::file_contents(filename_3);
-  REQUIRE_EQ(testing::file_contains(file_contents_3, "Record [0]"), true);
-
-  testing::remove_file(filename);
-  testing::remove_file(filename_1);
-  testing::remove_file(filename_2);
-  testing::remove_file(filename_3);
-  testing::remove_file(filename_yaml);
-  testing::remove_file(filename_other);
-}
-
-/***/
-TEST_CASE("rotating_file_sink_invalid_params")
-{
-  fs::path const filename = "rotating_file_sink_invalid_params.log";
-  REQUIRE_THROWS(RotatingFileSink{filename, []()
-                                  {
-                                    RotatingFileSinkConfig cfg;
-                                    cfg.set_rotation_max_file_size(128);
-                                    cfg.set_open_mode('w');
-                                    return cfg;
-                                  }()});
-
-  REQUIRE_FALSE(fs::exists(filename));
-
-  REQUIRE_THROWS(RotatingFileSink{filename, []()
-                                  {
-                                    RotatingFileSinkConfig cfg;
-                                    cfg.set_rotation_frequency_and_interval('Z', 123);
-                                    cfg.set_open_mode('w');
-                                    return cfg;
-                                  }()});
-
-  REQUIRE_FALSE(fs::exists(filename));
-
-  REQUIRE_THROWS(RotatingFileSink{filename, []()
-                                  {
-                                    RotatingFileSinkConfig cfg;
-                                    cfg.set_rotation_frequency_and_interval('M', 0);
-                                    cfg.set_open_mode('w');
-                                    return cfg;
-                                  }()});
-
-  REQUIRE_FALSE(fs::exists(filename));
-}
-
-TEST_SUITE_END();
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/SinkManagerTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/SinkManagerTest.cpp
deleted file mode 100644
index 3768be2..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/SinkManagerTest.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "quill/core/SinkManager.h"
-#include "quill/sinks/FileSink.h"
-#include <cstdio>
-
-TEST_SUITE_BEGIN("SinkManager");
-
-using namespace quill;
-using namespace quill::detail;
-
-/***/
-TEST_CASE("subscribe_get_active_different_sinks")
-{
-  std::string file_1 = "file1.log";
-  std::string file_2 = "file2.log";
-
-  {
-    // Create a file sink
-    std::shared_ptr<Sink> file_sink_1_a = SinkManager::instance().create_or_get_sink<quill::FileSink>(
-      file_1,
-      []()
-      {
-        quill::FileSinkConfig cfg;
-        cfg.set_open_mode('w');
-        return cfg;
-      }(),
-      FileEventNotifier{});
-
-    // Request the same sink
-    std::shared_ptr<Sink> file_sink_1_b = SinkManager::instance().create_or_get_sink<quill::FileSink>(
-      file_1,
-      []()
-      {
-        quill::FileSinkConfig cfg;
-        cfg.set_open_mode('a');
-        return cfg;
-      }(),
-      FileEventNotifier{});
-
-    std::shared_ptr<Sink> file_sink_1_c = SinkManager::instance().get_sink(file_1);
-
-    // Request a new sink of the same file
-    std::shared_ptr<Sink> file_sink_3 = SinkManager::instance().create_or_get_sink<quill::FileSink>(
-      file_2,
-      []()
-      {
-        quill::FileSinkConfig cfg;
-        cfg.set_open_mode('a');
-        return cfg;
-      }(),
-      FileEventNotifier{});
-
-    // Compare the pointers
-    REQUIRE_EQ(file_sink_1_a.get(), file_sink_1_b.get());
-    REQUIRE_EQ(file_sink_1_a.get(), file_sink_1_c.get());
-    REQUIRE_NE(file_sink_1_a.get(), file_sink_3.get());
-    REQUIRE_EQ(SinkManager::instance().cleanup_unused_sinks(), 0);
-  }
-
-  // Pointers are out of score and we except them cleaned up
-  REQUIRE_EQ(SinkManager::instance().cleanup_unused_sinks(), 2);
-
-  std::remove(file_1.data());
-  std::remove(file_2.data());
-}
-
-TEST_SUITE_END();
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/StringFromTimeTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/StringFromTimeTest.cpp
deleted file mode 100644
index 6085b3d..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/StringFromTimeTest.cpp
+++ /dev/null
@@ -1,449 +0,0 @@
-#include "quill/backend/StringFromTime.h"
-#include "DocTestExtensions.h"
-#include "doctest/doctest.h"
-#include <ctime>
-
-TEST_SUITE_BEGIN("StringFromTime");
-
-using namespace quill;
-using namespace quill::detail;
-
-/***/
-TEST_CASE("string_from_time_localtime_format_time")
-{
-  std::string fmt2 = "%H:%M:%S";
-  StringFromTime string_from_time;
-
-  string_from_time.init(fmt2, Timezone::LocalTime);
-
-  // Get the timestamp now
-  time_t raw_ts;
-  std::time(&raw_ts);
-
-  // Try for a few timestamps
-  for (uint32_t i = 0; i <= 500'000; ++i)
-  {
-    // Get the time from string from time
-    auto const& time_s1 = string_from_time.format_timestamp(raw_ts);
-
-    // Get the time from strftime
-    std::tm time_info{};
-    quill::detail::localtime_rs(&raw_ts, &time_info);
-
-    char buffer[256];
-    std::strftime(buffer, 256, fmt2.data(), &time_info);
-    auto const time_s2 = std::string{buffer};
-
-    REQUIRE_STREQ(time_s1.data(), time_s2.data());
-
-    // Increment the timestamp for the next loop
-    raw_ts += 1;
-  }
-}
-
-/***/
-TEST_CASE("string_from_time_localtime_format_I")
-{
-  std::string fmt2 = "%I:%M:%S%p";
-  StringFromTime string_from_time;
-
-  string_from_time.init(fmt2, Timezone::LocalTime);
-
-  // Get the timestamp now
-  time_t raw_ts;
-  std::time(&raw_ts);
-
-  // Try for a few timestamps
-  for (uint32_t i = 0; i <= 500'000; ++i)
-  {
-    // Get the time from string from time
-    auto const& time_s1 = string_from_time.format_timestamp(raw_ts);
-
-    // Get the time from strftime
-    std::tm time_info{};
-    quill::detail::localtime_rs(&raw_ts, &time_info);
-    char buffer[256];
-    std::strftime(buffer, 256, fmt2.data(), &time_info);
-    auto const time_s2 = std::string{buffer};
-
-    REQUIRE_STREQ(time_s1.data(), time_s2.data());
-
-    // Increment the timestamp for the next loop
-    raw_ts += 1;
-  }
-}
-
-/***/
-TEST_CASE("string_from_time_localtime_fallback_to_strftime")
-{
-  // In this edge case we pass a timestamp that is back in time from our cached timestamp value.
-
-  // Get the timestamp now
-  time_t raw_ts;
-  std::time(&raw_ts);
-
-  // This will create the StringFromTime class and pre-format a string for the timestamp now
-  std::string fmt2 = "%Y-%m-%dT%H:%M:%SZ";
-  StringFromTime string_from_time;
-
-  string_from_time.init(fmt2, Timezone::GmtTime);
-
-  // Ask StringFromTime to format timestamps in the past
-
-  // Try for a few timestamps
-  for (uint32_t i = 0; i <= 500'000; ++i)
-  {
-    // Get the time from string from time
-    auto const& time_s1 = string_from_time.format_timestamp(raw_ts);
-
-    // Get the time from strftime
-    std::tm time_info{};
-    quill::detail::gmtime_rs(&raw_ts, &time_info);
-    char buffer[256];
-    std::strftime(buffer, 256, fmt2.data(), &time_info);
-    auto const time_s2 = std::string{buffer};
-
-    REQUIRE_STREQ(time_s1.data(), time_s2.data());
-
-    // Decrement the timestamp for the next loop
-    raw_ts -= 1;
-  }
-}
-
-/***/
-TEST_CASE("string_from_time_localtime_main_format")
-{
-  std::string fmt2 = "%Y-%m-%dT%H:%M:%SZ";
-  StringFromTime string_from_time;
-
-  string_from_time.init(fmt2, Timezone::LocalTime);
-
-  // Get the timestamp now
-  time_t raw_ts;
-  std::time(&raw_ts);
-
-  // Try for a few timestamps
-  for (uint32_t i = 0; i <= 600'000; ++i)
-  {
-    // Get the time from string from time
-    auto const& time_s1 = string_from_time.format_timestamp(raw_ts);
-
-    // Get the time from strftime
-    std::tm time_info{};
-    quill::detail::localtime_rs(&raw_ts, &time_info);
-    char buffer[256];
-    std::strftime(buffer, 256, fmt2.data(), &time_info);
-    auto const time_s2 = std::string{buffer};
-
-    REQUIRE_STREQ(time_s1.data(), time_s2.data());
-
-    // Increment the timestamp for the next loop
-    raw_ts += 1;
-  }
-}
-
-/***/
-TEST_CASE("string_from_time_gmtime_main_format")
-{
-  std::string fmt2 = "%Y-%m-%dT%H:%M:%SZ";
-  StringFromTime string_from_time;
-
-  string_from_time.init(fmt2, Timezone::GmtTime);
-
-  // Get the timestamp now
-  time_t raw_ts;
-  std::time(&raw_ts);
-
-  // Try for a few timestamps
-  for (uint32_t i = 0; i <= 600'000; ++i)
-  {
-    // Get the time from string from time
-    auto const& time_s1 = string_from_time.format_timestamp(raw_ts);
-
-    // Get the time from strftime
-    std::tm time_info{};
-    quill::detail::gmtime_rs(&raw_ts, &time_info);
-    char buffer[256];
-    std::strftime(buffer, 256, fmt2.data(), &time_info);
-    auto const time_s2 = std::string{buffer};
-
-    REQUIRE_STREQ(time_s1.data(), time_s2.data());
-
-    // Increment the timestamp for the next loop
-    raw_ts += 1;
-  }
-}
-
-TEST_CASE("string_from_time_localtime_main_format_increment_ts")
-{
-  std::string fmt2 = "%Y-%m-%dT%H:%M:%SZ";
-  StringFromTime string_from_time;
-
-  string_from_time.init(fmt2, Timezone::LocalTime);
-
-  // Get the timestamp now
-  time_t raw_ts;
-  std::time(&raw_ts);
-
-  // Try for a few timestamps
-  for (uint32_t i = 0; i <= 10'000; ++i)
-  {
-    // Get the time from string from time
-    auto const& time_s1 = string_from_time.format_timestamp(raw_ts);
-
-    // Get the time from strftime
-    std::tm time_info{};
-    quill::detail::localtime_rs(&raw_ts, &time_info);
-    char buffer[256];
-    std::strftime(buffer, 256, fmt2.data(), &time_info);
-    auto const time_s2 = std::string{buffer};
-
-    REQUIRE_STREQ(time_s1.data(), time_s2.data());
-
-    // Increment the timestamp for the next loop
-    // This test increments the ts by a huge amount trying to mimic e.g. system clock changes
-    raw_ts += 7200;
-  }
-}
-
-/***/
-TEST_CASE("string_from_time_localtime_empty_cached_indexes")
-{
-  // try with a format that doesn't have hours, minutes, seconds
-  std::string fmt2 = "%Y-%m-%d";
-  StringFromTime string_from_time;
-
-  string_from_time.init(fmt2, Timezone::LocalTime);
-
-  // Get the timestamp now
-  time_t raw_ts;
-  std::time(&raw_ts);
-
-  // Try for a few timestamps
-  for (uint32_t i = 0; i <= 500'000; ++i)
-  {
-    // Get the time from string from time
-    auto const& time_s1 = string_from_time.format_timestamp(raw_ts);
-
-    // Get the time from strftime
-    std::tm time_info{};
-    quill::detail::localtime_rs(&raw_ts, &time_info);
-    char buffer[256];
-    std::strftime(buffer, 256, fmt2.data(), &time_info);
-    auto const time_s2 = std::string{buffer};
-
-    REQUIRE_STREQ(time_s1.data(), time_s2.data());
-
-    // Increment the timestamp for the next loop
-    raw_ts += 1;
-  }
-}
-
-#if !defined(_WIN32)
-// The following tests don't run on windows because the format identifiers are not supported.
-
-/***/
-TEST_CASE("string_from_time_localtime_format_l")
-{
-  std::string fmt2 = "%l:%M:%S%p";
-  StringFromTime string_from_time;
-
-  string_from_time.init(fmt2, Timezone::LocalTime);
-
-  // Get the timestamp now
-  time_t raw_ts;
-  std::time(&raw_ts);
-
-  // Try for a few timestamps
-  for (uint32_t i = 0; i <= 500'000; ++i)
-  {
-    // Get the time from string from time
-    auto const& time_s1 = string_from_time.format_timestamp(raw_ts);
-
-    // Get the time from strftime
-    std::tm* time_info;
-    time_info = std::localtime(&raw_ts);
-    char buffer[256];
-    std::strftime(buffer, 256, fmt2.data(), time_info);
-    auto const time_s2 = std::string{buffer};
-
-    REQUIRE_STREQ(time_s1.data(), time_s2.data());
-
-    // Increment the timestamp for the next loop
-    raw_ts += 1;
-  }
-}
-
-/***/
-TEST_CASE("string_from_time_localtime_format_k")
-{
-  std::string fmt2 = "%k:%M:%S%p";
-  StringFromTime string_from_time;
-
-  string_from_time.init(fmt2, Timezone::LocalTime);
-
-  // Get the timestamp now
-  time_t raw_ts;
-  std::time(&raw_ts);
-
-  // Try for a few timestamps
-  for (uint32_t i = 0; i <= 500'000; ++i)
-  {
-    // Get the time from string from time
-    auto const& time_s1 = string_from_time.format_timestamp(raw_ts);
-
-    // Get the time from strftime
-    std::tm* time_info;
-    time_info = std::localtime(&raw_ts);
-    char buffer[256];
-    std::strftime(buffer, 256, fmt2.data(), time_info);
-    auto const time_s2 = std::string{buffer};
-
-    REQUIRE_STREQ(time_s1.data(), time_s2.data());
-
-    // Increment the timestamp for the next loop
-    raw_ts += 1;
-  }
-}
-
-/***/
-TEST_CASE("string_from_time_localtime_format_s")
-{
-  std::string fmt2 = "%Y-%m-%d %s";
-  StringFromTime string_from_time;
-
-  string_from_time.init(fmt2, Timezone::LocalTime);
-
-  // Get the timestamp now
-  time_t raw_ts;
-  std::time(&raw_ts);
-
-  // Try for a few timestamps
-  for (uint32_t i = 0; i <= 100'000; ++i)
-  {
-    // Get the time from string from time
-    auto const& time_s1 = string_from_time.format_timestamp(raw_ts);
-
-    // Get the time from strftime
-    std::tm* time_info;
-    time_info = std::localtime(&raw_ts);
-    char buffer[256];
-    std::strftime(buffer, 256, fmt2.data(), time_info);
-    auto const time_s2 = std::string{buffer};
-
-    REQUIRE_STREQ(time_s1.data(), time_s2.data());
-
-    // Increment the timestamp for the next loop
-    raw_ts += 1;
-  }
-}
-#endif
-
-class StringFromTimeMock : public quill::detail::StringFromTime
-{
-public:
-  static time_t next_noon_or_midnight_timestamp(time_t timestamp, Timezone timezone) noexcept
-  {
-    return quill::detail::StringFromTime::_next_noon_or_midnight_timestamp(timestamp, timezone);
-  }
-
-  static time_t nearest_hour_timestamp(time_t timestamp) noexcept
-  {
-    return quill::detail::StringFromTime::_nearest_hour_timestamp(timestamp);
-  }
-
-  static time_t next_hour_timestamp(time_t timestamp) noexcept
-  {
-    return quill::detail::StringFromTime::_next_hour_timestamp(timestamp);
-  }
-
-  static std::vector<char> safe_strftime(char const* format_string, time_t timestamp, Timezone timezone)
-  {
-    return quill::detail::StringFromTime::_safe_strftime(format_string, timestamp, timezone);
-  }
-};
-
-/***/
-TEST_CASE("next_noon_or_midnight_timestamp")
-{
-  // We do not test local because if we hardcode an expected_timestamp in our local timezone
-  // it can be different in another system
-
-  {
-    // Noon utc
-    time_t constexpr timestamp{1599033200};
-    time_t constexpr expected_timestamp{1599048000};
-    time_t const res = StringFromTimeMock::next_noon_or_midnight_timestamp(timestamp, Timezone::GmtTime);
-    REQUIRE_EQ(res, expected_timestamp);
-  }
-
-  {
-    // Midnight utc
-    time_t constexpr timestamp{1599079200};
-    time_t constexpr expected_timestamp{1599091200};
-    time_t const res = StringFromTimeMock::next_noon_or_midnight_timestamp(timestamp, Timezone::GmtTime);
-    REQUIRE_EQ(res, expected_timestamp);
-  }
-}
-
-/***/
-TEST_CASE("nearest_hour_timestamp")
-{
-  time_t constexpr timestamp = 1599473669;
-  time_t constexpr expected_timestamp = 1599472800;
-  REQUIRE_EQ(StringFromTimeMock::nearest_hour_timestamp(timestamp), expected_timestamp);
-}
-
-/***/
-TEST_CASE("next_hour_timestamp")
-{
-  time_t constexpr timestamp = 1599473669;
-  time_t constexpr expected_timestamp = 1599476400;
-  REQUIRE_EQ(StringFromTimeMock::next_hour_timestamp(timestamp), expected_timestamp);
-}
-
-/***/
-TEST_CASE("safe_strftime_resize")
-{
-  // e.g. "Monday September 2020 (09/07/20) 15:37 EEST"
-  constexpr char const* format_string = "%A %B %Y (%x) %R %Z";
-
-  // Get the timestamp now
-  time_t raw_ts;
-  std::time(&raw_ts);
-
-  std::tm time_info{};
-  quill::detail::localtime_rs(&raw_ts, &time_info);
-
-  // we will format a string greater than 32
-  char expected_result[256];
-  std::strftime(expected_result, 256, format_string, &time_info);
-
-  // Also try our version
-  std::string const safe_strftime_result =
-    std::string{StringFromTimeMock::safe_strftime(format_string, raw_ts, Timezone::LocalTime).data()};
-
-  REQUIRE_STREQ(expected_result, safe_strftime_result.data());
-}
-
-TEST_CASE("safe_strftime_empty")
-{
-  // Get the timestamp now
-  time_t raw_ts;
-  std::time(&raw_ts);
-
-  std::tm time_info{};
-  quill::detail::localtime_rs(&raw_ts, &time_info);
-
-  // we will format a string greater than 32
-  char expected_result[256];
-  std::strftime(expected_result, 256, "", &time_info);
-
-  // Also try our version
-  std::string const safe_strftime_result =
-    std::string{StringFromTimeMock::safe_strftime("", raw_ts, Timezone::LocalTime).data()};
-
-  REQUIRE_STREQ(expected_result, safe_strftime_result.data());
-}
-
-TEST_SUITE_END();
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/ThreadContextManagerTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/ThreadContextManagerTest.cpp
deleted file mode 100644
index 08f5f4f..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/ThreadContextManagerTest.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "quill/core/FrontendOptions.h"
-#include "quill/core/ThreadContextManager.h"
-#include <array>
-#include <thread>
-
-TEST_SUITE_BEGIN("ThreadContextManager");
-
-using namespace quill;
-using namespace quill::detail;
-
-/***/
-TEST_CASE("add_and_remove_thread_contexts")
-{
-  // 1) Test that every time a new thread context is added to the thread context shared collection
-  // and to the thread context cache when a new thread spawns and we load the cache
-  // 2) Test that the thread context is invalidated when the thread that created it completes
-  // 3) Test that when the threads complete they are removed
-
-  constexpr uint32_t tries = 4;
-  for (uint32_t k = 0; k < tries; ++k)
-  {
-    constexpr size_t num_threads{25};
-    std::array<std::thread, num_threads> threads;
-    std::array<std::atomic<bool>, num_threads> terminate_flag{};
-    std::fill(terminate_flag.begin(), terminate_flag.end(), false);
-
-    std::atomic<uint32_t> threads_started{0};
-
-    // spawn x number of threads
-    for (size_t i = 0; i < threads.size(); ++i)
-    {
-      auto& thread_terminate_flag = terminate_flag[i];
-      threads[i] = std::thread(
-        [&thread_terminate_flag, &threads_started]()
-        {
-          // create a context for that thread
-          ThreadContext* tc = get_local_thread_context<FrontendOptions>();
-
-          REQUIRE(tc->has_unbounded_queue_type());
-          REQUIRE(tc->has_blocking_queue());
-
-          REQUIRE_FALSE(tc->has_bounded_queue_type());
-          REQUIRE_FALSE(tc->has_dropping_queue());
-
-          threads_started.fetch_add(1);
-          while (!thread_terminate_flag.load())
-          {
-            // loop waiting for main to signal
-            std::this_thread::sleep_for(std::chrono::milliseconds{1});
-          }
-        });
-    }
-
-    // main wait for all of them to start
-    while (threads_started.load() < num_threads)
-    {
-      std::this_thread::sleep_for(std::chrono::milliseconds{1});
-    }
-
-    // Check we have exactly as many thread contexts as the amount of threads in our backend cache
-    uint64_t thread_ctx_cnt{0};
-
-    // Check all thread contexts in the backend thread contexts cache
-    ThreadContextManager::instance().for_each_thread_context(
-      [&thread_ctx_cnt](ThreadContext const* tc)
-      {
-        REQUIRE(tc->is_valid_context());
-        REQUIRE(tc->get_spsc_queue<FrontendOptions::queue_type>().empty());
-        ++thread_ctx_cnt;
-      });
-
-    REQUIRE_EQ(thread_ctx_cnt, num_threads);
-    REQUIRE_FALSE(ThreadContextManager::instance().has_invalid_thread_context());
-
-    // terminate all threads - This will invalidate all the thread contexts
-    for (size_t j = 0; j < threads.size(); ++j)
-    {
-      terminate_flag[j].store(true);
-      threads[j].join();
-    }
-
-    REQUIRE(ThreadContextManager::instance().has_invalid_thread_context());
-
-    // Now check all thread contexts still exist but they are invalided and then remove them
-
-    REQUIRE(ThreadContextManager::instance().has_invalid_thread_context());
-
-    // For this we use the old cache avoiding to update it - This never happens in the real logger
-    std::vector<ThreadContext const*> tc_cache;
-    ThreadContextManager::instance().for_each_thread_context(
-      [&tc_cache](ThreadContext const* tc)
-      {
-        REQUIRE_FALSE(tc->is_valid_context());
-        REQUIRE(tc->get_spsc_queue<FrontendOptions::queue_type>().empty());
-        tc_cache.push_back(tc);
-      });
-
-    // Remove them
-    for (ThreadContext const* tc : tc_cache)
-    {
-      ThreadContextManager::instance().remove_shared_invalidated_thread_context(tc);
-    }
-
-    // Check all are removed
-    bool tc_found = false;
-    ThreadContextManager::instance().for_each_thread_context([&tc_found](ThreadContext const* tc)
-                                                             { tc_found = true; });
-
-    REQUIRE_FALSE(tc_found);
-  }
-}
-
-TEST_SUITE_END();
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/TimestampFormatterTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/TimestampFormatterTest.cpp
deleted file mode 100644
index a86f4b1..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/TimestampFormatterTest.cpp
+++ /dev/null
@@ -1,183 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "misc/DocTestExtensions.h"
-#include "quill/backend/TimestampFormatter.h"
-#include "quill/core/QuillError.h"
-
-TEST_SUITE_BEGIN("TimestampFormatter");
-
-using namespace quill::detail;
-
-/***/
-TEST_CASE("simple_format_string")
-{
-  // invalid format strings
-#if !defined(QUILL_NO_EXCEPTIONS)
-  REQUIRE_THROWS_AS(TimestampFormatter ts_formatter{"%I:%M%p%Qms%S%Qus z"}, quill::QuillError);
-  REQUIRE_THROWS_AS(TimestampFormatter ts_formatter{"%I:%M%p%Qms%S%Qus%Qns z"}, quill::QuillError);
-  REQUIRE_THROWS_AS(TimestampFormatter ts_formatter{"%I:%M%p%S%Qus%Qns z"}, quill::QuillError);
-#endif
-
-  // valid simple string
-  REQUIRE_NOTHROW(TimestampFormatter ts_formatter{"%I:%M%p%S%Qns z"});
-}
-
-/***/
-TEST_CASE("format_string_no_additional_specifier")
-{
-  std::chrono::nanoseconds constexpr timestamp{1587161887987654321};
-
-  // simple formats without any ms/us/ns specifiers
-  {
-    TimestampFormatter ts_formatter{"%H:%M:%S", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07");
-  }
-
-  {
-    TimestampFormatter ts_formatter{"%F %H:%M:%S", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "2020-04-17 22:18:07");
-  }
-
-  // large simple string to cause reallocation
-  {
-    TimestampFormatter ts_formatter{"%A %B %d %T %Y %F", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "Friday April 17 22:18:07 2020 2020-04-17");
-  }
-}
-
-/***/
-TEST_CASE("format_string_with_millisecond_precision")
-{
-  // simple
-  {
-    std::chrono::nanoseconds constexpr timestamp{1587161887987654321};
-    TimestampFormatter ts_formatter{"%H:%M:%S.%Qms", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07.987");
-  }
-
-  // with double formatting
-  {
-    std::chrono::nanoseconds constexpr timestamp{1587161887803654321};
-    TimestampFormatter ts_formatter{"%H:%M:%S.%Qms %D", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07.803 04/17/20");
-  }
-
-  // with double formatting 2
-  {
-    std::chrono::nanoseconds constexpr timestamp{1587161887023654321};
-    TimestampFormatter ts_formatter{"%H:%M:%S.%Qms-%G", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07.023-2020");
-  }
-
-  // with zeros
-  {
-    std::chrono::nanoseconds constexpr timestamp{1587161887009654321};
-    TimestampFormatter ts_formatter{"%H:%M:%S.%Qms", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07.009");
-  }
-}
-
-/***/
-TEST_CASE("format_string_with_microsecond_precision")
-{
-  // simple
-  {
-    std::chrono::nanoseconds constexpr timestamp{1587161887987654321};
-    TimestampFormatter ts_formatter{"%H:%M:%S.%Qus", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07.987654");
-  }
-
-  // with double formatting
-  {
-    std::chrono::nanoseconds constexpr timestamp{1587161887803654321};
-    TimestampFormatter ts_formatter{"%H:%M:%S.%Qus %D", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07.803654 04/17/20");
-  }
-
-  // with double formatting 2
-  {
-    std::chrono::nanoseconds constexpr timestamp{1587161887010654321};
-    TimestampFormatter ts_formatter{"%H:%M:%S.%Qus-%G", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07.010654-2020");
-  }
-
-  // with zeros
-  {
-    std::chrono::nanoseconds constexpr timestamp{1587161887000004321};
-    TimestampFormatter ts_formatter{"%H:%M:%S.%Qus", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07.000004");
-  }
-}
-
-/***/
-TEST_CASE("format_string_with_nanosecond_precision")
-{
-  // simple
-  {
-    std::chrono::nanoseconds constexpr timestamp{1587161887987654321};
-    TimestampFormatter ts_formatter{"%H:%M:%S.%Qns", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07.987654321");
-  }
-
-  // with double formatting
-  {
-    std::chrono::nanoseconds constexpr timestamp{1587161887803654320};
-    TimestampFormatter ts_formatter{"%H:%M:%S.%Qns %D", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07.803654320 04/17/20");
-  }
-
-  // with double formatting 2
-  {
-    std::chrono::nanoseconds constexpr timestamp{1587161887000654321};
-    TimestampFormatter ts_formatter{"%H:%M:%S.%Qns-%G", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07.000654321-2020");
-  }
-
-  // with zeros
-  {
-    std::chrono::nanoseconds constexpr timestamp{1587161887000000009};
-    TimestampFormatter ts_formatter{"%H:%M:%S.%Qns", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07.000000009");
-  }
-
-  // with max
-  {
-    std::chrono::nanoseconds constexpr timestamp{1587161887999999999};
-    TimestampFormatter ts_formatter{"%H:%M:%S.%Qns", quill::Timezone::GmtTime};
-
-    auto const& result = ts_formatter.format_timestamp(timestamp);
-    REQUIRE_STREQ(result.data(), "22:18:07.999999999");
-  }
-}
-
-TEST_SUITE_END();
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/TransitEventBufferTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/TransitEventBufferTest.cpp
deleted file mode 100644
index 6e86b07..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/TransitEventBufferTest.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-#include "DocTestExtensions.h"
-#include "doctest/doctest.h"
-
-#include "quill/backend/TransitEventBuffer.h"
-
-TEST_SUITE_BEGIN("TransitEventBuffer");
-
-using namespace quill;
-using namespace quill::detail;
-
-/***/
-TEST_CASE("transit_event_bounded_buffer")
-{
-  BoundedTransitEventBuffer bte{4};
-  REQUIRE_EQ(bte.capacity(), 4);
-
-  for (size_t i = 0; i < 12; ++i)
-  {
-    REQUIRE_FALSE(bte.front());
-    REQUIRE_EQ(bte.size(), 0);
-
-    {
-      TransitEvent* te1 = bte.back();
-      REQUIRE(te1);
-
-      te1->named_args = std::make_unique<std::vector<std::pair<std::string, std::string>>>();
-      te1->named_args->clear();
-      te1->named_args->emplace_back(std::string{"test1"} + std::to_string(i), std::string{});
-      bte.push_back();
-    }
-
-    REQUIRE_EQ(bte.size(), 1);
-
-    {
-      TransitEvent* te2 = bte.back();
-      REQUIRE(te2);
-
-      te2->named_args = std::make_unique<std::vector<std::pair<std::string, std::string>>>();
-      te2->named_args->clear();
-      te2->named_args->emplace_back(std::string{"test2"} + std::to_string(i), std::string{});
-      bte.push_back();
-    }
-
-    REQUIRE_EQ(bte.size(), 2);
-
-    {
-      TransitEvent* te3 = bte.back();
-      REQUIRE(te3);
-
-      te3->named_args = std::make_unique<std::vector<std::pair<std::string, std::string>>>();
-      te3->named_args->clear();
-      te3->named_args->emplace_back(std::string{"test3"} + std::to_string(i), std::string{});
-      bte.push_back();
-    }
-
-    REQUIRE_EQ(bte.size(), 3);
-
-    {
-      TransitEvent* te4 = bte.back();
-      REQUIRE(te4);
-
-      te4->named_args = std::make_unique<std::vector<std::pair<std::string, std::string>>>();
-      te4->named_args->clear();
-      te4->named_args->emplace_back(std::string{"test4"} + std::to_string(i), std::string{});
-      bte.push_back();
-    }
-
-    REQUIRE_EQ(bte.size(), 4);
-
-    // read
-    {
-      TransitEvent* te1 = bte.front();
-      REQUIRE(te1);
-      std::string const expected = std::string{"test1"} + std::to_string(i);
-      REQUIRE_STREQ((*te1->named_args)[0].first.data(), expected.data());
-      bte.pop_front();
-    }
-
-    REQUIRE_EQ(bte.size(), 3);
-
-    {
-      TransitEvent* te2 = bte.front();
-      REQUIRE(te2);
-      std::string const expected = std::string{"test2"} + std::to_string(i);
-      REQUIRE_STREQ((*te2->named_args)[0].first.data(), expected.data());
-      bte.pop_front();
-    }
-
-    REQUIRE_EQ(bte.size(), 2);
-
-    {
-      TransitEvent* te3 = bte.front();
-      REQUIRE(te3);
-      std::string const expected = std::string{"test3"} + std::to_string(i);
-      REQUIRE_STREQ((*te3->named_args)[0].first.data(), expected.data());
-      bte.pop_front();
-    }
-
-    REQUIRE_EQ(bte.size(), 1);
-
-    {
-      TransitEvent* te4 = bte.front();
-      REQUIRE(te4);
-      std::string const expected = std::string{"test4"} + std::to_string(i);
-      REQUIRE_STREQ((*te4->named_args)[0].first.data(), expected.data());
-      bte.pop_front();
-    }
-
-    REQUIRE_EQ(bte.size(), 0);
-    REQUIRE_FALSE(bte.front());
-  }
-}
-
-/***/
-TEST_CASE("transit_event_bounded_buffer_integer_overflow")
-{
-  BoundedTransitEventBufferImpl<uint8_t> bte{128};
-  size_t constexpr iterations = static_cast<size_t>(std::numeric_limits<uint8_t>::max()) * 8ull;
-
-  for (size_t i = 0; i < iterations; ++i)
-  {
-    REQUIRE_EQ(bte.size(), 0);
-
-    {
-      TransitEvent* te = bte.back();
-      REQUIRE(te);
-
-      te->named_args = std::make_unique<std::vector<std::pair<std::string, std::string>>>();
-      te->named_args->clear();
-      te->named_args->emplace_back(std::string{"test"} + std::to_string(i), std::string{});
-      bte.push_back();
-    }
-
-    REQUIRE_EQ(bte.size(), 1);
-
-    // read
-    {
-      TransitEvent* te = bte.front();
-      REQUIRE(te);
-      std::string const expected = std::string{"test"} + std::to_string(i);
-      REQUIRE_STREQ((*te->named_args)[0].first.data(), expected.data());
-      bte.pop_front();
-    }
-  }
-}
-
-/***/
-TEST_CASE("transit_event_unbounded_buffer")
-{
-  UnboundedTransitEventBuffer bte{4};
-
-  REQUIRE_FALSE(bte.front());
-  REQUIRE(bte.empty());
-  REQUIRE_EQ(bte.size(), 0);
-
-  for (size_t i = 0; i < 128; ++i)
-  {
-    {
-      TransitEvent* te1 = bte.back();
-      REQUIRE(te1);
-
-      te1->named_args = std::make_unique<std::vector<std::pair<std::string, std::string>>>();
-      te1->named_args->clear();
-      te1->named_args->emplace_back(std::string{"test1"} + std::to_string(i), std::string{});
-      bte.push_back();
-    }
-
-    REQUIRE_EQ(bte.size(), i * 4 + 1);
-
-    {
-      TransitEvent* te2 = bte.back();
-      REQUIRE(te2);
-
-      te2->named_args = std::make_unique<std::vector<std::pair<std::string, std::string>>>();
-      te2->named_args->clear();
-      te2->named_args->emplace_back(std::string{"test2"} + std::to_string(i), std::string{});
-      bte.push_back();
-    }
-
-    REQUIRE_EQ(bte.size(), i * 4 + 2);
-
-    {
-      TransitEvent* te3 = bte.back();
-      REQUIRE(te3);
-
-      te3->named_args = std::make_unique<std::vector<std::pair<std::string, std::string>>>();
-      te3->named_args->clear();
-      te3->named_args->emplace_back(std::string{"test3"} + std::to_string(i), std::string{});
-      bte.push_back();
-    }
-
-    REQUIRE_EQ(bte.size(), i * 4 + 3);
-
-    {
-      TransitEvent* te4 = bte.back();
-      REQUIRE(te4);
-
-      te4->named_args = std::make_unique<std::vector<std::pair<std::string, std::string>>>();
-      te4->named_args->clear();
-      te4->named_args->emplace_back(std::string{"test4"} + std::to_string(i), std::string{});
-      bte.push_back();
-    }
-
-    REQUIRE_EQ(bte.size(), i * 4 + 4);
-  }
-
-  for (size_t i = 0; i < 128; ++i)
-  {
-    // read
-    {
-      TransitEvent* te1 = bte.front();
-      REQUIRE(te1);
-      std::string const expected = std::string{"test1"} + std::to_string(i);
-      REQUIRE_STREQ((*te1->named_args)[0].first.data(), expected.data());
-      bte.pop_front();
-    }
-
-    REQUIRE_EQ(bte.size(), (128 - i) * 4 - 1);
-
-    {
-      TransitEvent* te2 = bte.front();
-      REQUIRE(te2);
-      std::string const expected = std::string{"test2"} + std::to_string(i);
-      REQUIRE_STREQ((*te2->named_args)[0].first.data(), expected.data());
-      bte.pop_front();
-    }
-
-    REQUIRE_EQ(bte.size(), (128 - i) * 4 - 2);
-
-    {
-      TransitEvent* te3 = bte.front();
-      REQUIRE(te3);
-      std::string const expected = std::string{"test3"} + std::to_string(i);
-      REQUIRE_STREQ((*te3->named_args)[0].first.data(), expected.data());
-      bte.pop_front();
-    }
-
-    REQUIRE_EQ(bte.size(), (128 - i) * 4 - 3);
-
-    {
-      TransitEvent* te4 = bte.front();
-      REQUIRE(te4);
-      std::string const expected = std::string{"test4"} + std::to_string(i);
-      REQUIRE_STREQ((*te4->named_args)[0].first.data(), expected.data());
-      bte.pop_front();
-    }
-
-    REQUIRE_EQ(bte.size(), (128 - i) * 4 - 4);
-  }
-
-  REQUIRE_FALSE(bte.front());
-  REQUIRE(bte.empty());
-  REQUIRE_EQ(bte.size(), 0);
-}
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/UnboundedQueueTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/UnboundedQueueTest.cpp
deleted file mode 100644
index 0b2cbff..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/UnboundedQueueTest.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "quill/core/UnboundedSPSCQueue.h"
-#include <cstring>
-#include <thread>
-#include <vector>
-
-TEST_SUITE_BEGIN("UnboundedQueue");
-
-using namespace quill::detail;
-
-TEST_CASE("unbounded_queue_read_write_multithreaded_plain_ints")
-{
-  UnboundedSPSCQueue buffer{1024};
-
-  std::thread producer_thread(
-    [&buffer]()
-    {
-      for (uint32_t wrap_cnt = 0; wrap_cnt < 20; ++wrap_cnt)
-      {
-        for (uint32_t i = 0; i < 8192; ++i)
-        {
-          auto* write_buffer = buffer.prepare_write(sizeof(uint32_t), quill::QueueType::UnboundedBlocking);
-
-          while (!write_buffer)
-          {
-            std::this_thread::sleep_for(std::chrono::microseconds{2});
-            write_buffer = buffer.prepare_write(sizeof(uint32_t), quill::QueueType::UnboundedBlocking);
-          }
-
-          std::memcpy(write_buffer, &i, sizeof(uint32_t));
-          buffer.finish_write(sizeof(uint32_t));
-          buffer.commit_write();
-        }
-      }
-    });
-
-  // Delay creating the consumer thread
-  std::this_thread::sleep_for(std::chrono::milliseconds{300});
-
-  std::thread consumer_thread(
-    [&buffer]()
-    {
-      for (uint32_t wrap_cnt = 0; wrap_cnt < 20; ++wrap_cnt)
-      {
-        for (uint32_t i = 0; i < 8192; ++i)
-        {
-          auto read_result = buffer.prepare_read();
-          while (!read_result.read_pos)
-          {
-            std::this_thread::sleep_for(std::chrono::microseconds{2});
-            read_result = buffer.prepare_read();
-          }
-
-          auto const value = reinterpret_cast<uint32_t const*>(read_result.read_pos);
-          REQUIRE_EQ(*value, i);
-          buffer.finish_read(sizeof(uint32_t));
-          buffer.commit_read();
-        }
-      }
-    });
-
-  producer_thread.join();
-  consumer_thread.join();
-  REQUIRE(buffer.empty());
-}
-
-TEST_SUITE_END();
\ No newline at end of file
diff --git a/subprojects/quill-4.2.0/quill/test/unit_tests/UtilityTest.cpp b/subprojects/quill-4.2.0/quill/test/unit_tests/UtilityTest.cpp
deleted file mode 100644
index 4dcc4e7..0000000
--- a/subprojects/quill-4.2.0/quill/test/unit_tests/UtilityTest.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "doctest/doctest.h"
-
-#include "quill/Utility.h"
-#include <cstdint>
-#include <cstring>
-#include <cstdint>
-
-TEST_SUITE_BEGIN("Utility");
-
-/***/
-TEST_CASE("ascii_string_to_hex_1")
-{
-  std::string buffer = "Hello World";
-  std::string const result = quill::utility::to_hex(buffer.data(), buffer.length());
-  std::string const expected = "48 65 6C 6C 6F 20 57 6F 72 6C 64";
-  REQUIRE_EQ(result, expected);
-}
-
-/***/
-TEST_CASE("ascii_string_to_hex_2")
-{
-  std::string buffer = "A longer ASCII text";
-  std::string const result = quill::utility::to_hex(buffer.data(), buffer.length());
-  std::string const expected = "41 20 6C 6F 6E 67 65 72 20 41 53 43 49 49 20 74 65 78 74";
-  REQUIRE_EQ(result, expected);
-}
-
-/***/
-TEST_CASE("ascii_string_to_hex_2_const")
-{
-  std::string const buffer = "A longer ASCII text";
-  std::string const result = quill::utility::to_hex(buffer.data(), buffer.length());
-  std::string const expected = "41 20 6C 6F 6E 67 65 72 20 41 53 43 49 49 20 74 65 78 74";
-  REQUIRE_EQ(result, expected);
-}
-
-/***/
-TEST_CASE("byte_buffer_to_hex_1")
-{
-  uint32_t input = 431234;
-  unsigned char buffer[4];
-  std::memcpy(buffer, reinterpret_cast<char*>(&input), sizeof(input));
-
-  // non const overload
-  std::string const result = quill::utility::to_hex(buffer, 4);
-  std::string const expected = "82 94 06 00";
-  REQUIRE_EQ(result, expected);
-
-  // const overload
-  unsigned char* const buffer_const = &buffer[0];
-  std::string const result_2 = quill::utility::to_hex(buffer_const, 4);
-  REQUIRE_EQ(result_2, expected);
-}
-
-TEST_SUITE_END();
diff --git a/subprojects/quill-4.2.0/scripts/rename_libfmt.py b/subprojects/quill-4.2.0/scripts/rename_libfmt.py
deleted file mode 100644
index 2774bda..0000000
--- a/subprojects/quill-4.2.0/scripts/rename_libfmt.py
+++ /dev/null
@@ -1,40 +0,0 @@
-# python3 rename_libfmt.py ~/git/quill/quill/include/quill/bundled/fmt FMTQUILL fmtquill
-# python3 rename_libfmt.py ~/git/quill/quill/src/bundled/fmt FMTQUILL fmtquill
-
-import sys
-import os
-import re
-
-def rename(file_path, macro_replace, namespace_replace):
-    # Read the source file
-    with open(file_path, 'r') as file:
-        content = file.read()
-
-    # Use regular expressions to find and replace macros and namespace
-    macro_pattern = r'\bFMT_'
-    namespace_pattern = r'namespace\s+fmt\b'
-
-    updated_content = re.sub(macro_pattern, macro_replace + '_', content)
-    updated_content = re.sub(r'fmt::', f'{namespace_replace}::', updated_content)
-    updated_content = re.sub(namespace_pattern, f'namespace {namespace_replace}', updated_content)
-
-    # Write the updated content back to the source file
-    with open(file_path, 'w') as file:
-        file.write(updated_content)
-
-def process_directory(directory, macro_replace, namespace_replace):
-    for root, _, files in os.walk(directory):
-        for file_name in files:
-            if file_name.endswith('.cc') or file_name.endswith('.h'):
-                file_path = os.path.join(root, file_name)
-                rename(file_path, macro_replace, namespace_replace)
-                print(f"Macros, 'fmt::', and 'namespace fmt' replaced successfully in '{file_path}'.")
-
-if __name__ == '__main__':
-    if len(sys.argv) != 4:
-        print("Usage: python rename.py <directory> <macro_replace> <namespace_replace>")
-    else:
-        directory = sys.argv[1]
-        macro_replace = sys.argv[2]
-        namespace_replace = sys.argv[3]
-        process_directory(directory, macro_replace, namespace_replace)
\ No newline at end of file
diff --git a/subprojects/quill.wrap b/subprojects/quill.wrap
deleted file mode 100644
index 447c8a4..0000000
--- a/subprojects/quill.wrap
+++ /dev/null
@@ -1,13 +0,0 @@
-[wrap-file]
-directory = quill-4.2.0
-source_url = https://github.com/odygrd/quill/archive/refs/tags/v4.2.0.tar.gz
-source_filename = quill-4.2.0.tar.gz
-source_hash = 32b0ee16da154afcb162063d4fe1ccdb5aabebca86724afd26b2a7e4c5b78cfa
-patch_filename = quill_4.2.0-1_patch.zip
-patch_url = https://wrapdb.mesonbuild.com/v2/quill_4.2.0-1/get_patch
-patch_hash = 79ea878946c095b6fdc9a77bea9c109593c8af285077e23365770d70620d218c
-source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/quill_4.2.0-1/quill-4.2.0.tar.gz
-wrapdb_version = 4.2.0-1
-
-[provide]
-quill = quill_dep