From 47b1cbaf042617a1bf447f9746fd9b9e32d5d4c2 Mon Sep 17 00:00:00 2001
From: Santiago Lema <santiago@lema.org>
Date: Wed, 7 May 2025 02:33:01 -0300
Subject: [PATCH] working request to openai

---
 DumBer         |   Bin 244038 -> 325310 bytes
 MainWindow.cpp |   112 +-
 MainWindow.h   |     7 +-
 json.hpp       | 25580 +++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 25693 insertions(+), 6 deletions(-)
 create mode 100644 json.hpp

diff --git a/DumBer b/DumBer
index 17f1c0af692d02265e572c4928dc39a46d01d5dd..622ebd3eea0f636c3860af736578dec7d0cc4af4 100755
GIT binary patch
literal 325310
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

literal 244038
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

diff --git a/MainWindow.cpp b/MainWindow.cpp
index 8b265c7..3b91d83 100644
--- a/MainWindow.cpp
+++ b/MainWindow.cpp
@@ -5,6 +5,8 @@
 
 #include "MainWindow.h"
 
+#include <cstring>
+
 #include <Url.h>
 
 #include <Application.h>
@@ -15,9 +17,21 @@
 #include <MenuBar.h>
 #include <ScrollView.h>
 #include <StringView.h>
+#include <MimeType.h>
+#include <memory.h>
 
 #include <View.h>
 
+#include <Path.h>
+#include <FindDirectory.h>
+#include <File.h>
+#include <String.h>
+#include <iostream>
+
+#include <algorithm> 
+
+#include "json.hpp"
+
 // #include <iostream>
 
 #include <cstdio>
@@ -45,6 +59,7 @@ MainWindow::MainWindow()
   _inputField = new BTextControl("", "What is the matrix ?",
                                  new BMessage(kQuestionChanged));
 
+
   _progress = new BStatusBar("prog");
   _progress->SetMaxValue(100);
   _progress->SetTo(0);
@@ -72,6 +87,10 @@ MainWindow::MainWindow()
   _inputField->SetExplicitMinSize(BSize(B_SIZE_UNSET, askH));
   _inputField->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, askH * 6));
 
+
+   _apiKey = ReadOpenAIKey();
+   printf("key is: %s", _apiKey.String());
+
   BButton *sendButton =
       new BButton("send", B_TRANSLATE("Send"), new BMessage(kSendPrompt),
                   B_WILL_DRAW | B_NAVIGABLE);
@@ -79,11 +98,10 @@ MainWindow::MainWindow()
   _answerView = new BTextView("answer", B_WILL_DRAW | B_FOLLOW_ALL);
   _answerView->MakeEditable(false);  // Disable editing
   _answerView->MakeSelectable(true); // Enable text selection
-
-  //_answerView->SetWordWrap(true);
+  _answerView->SetWordWrap(true);
+  
   BScrollView *scrollView =
-      new BScrollView("scroll_view", _answerView, 0, 0, false,
-                      true); // horizontal and vertical scrollbars
+      new BScrollView("scroll_view", _answerView, B_FOLLOW_ALL | B_WILL_DRAW ,0 , false, true); // horizontal and vertical scrollbars
 
   BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
 
@@ -241,8 +259,60 @@ void MainWindow::sendQuery() {
   _progress->SetMaxValue(100);
   _progress->SetTo(0);
 
-  auto url = BUrl("https://www.lema.org/");
+  auto url = BUrl("https://api.openai.com/v1/chat/completions");
   BHttpRequest request = BHttpRequest(url);
+  request.SetMethod(BHttpMethod::Post);
+
+  // if the API key file contains a new line bhttpfields will crash with invalid content
+  // .end() requires include algorithm
+  std::string key = _apiKey.String();
+  key.erase(std::remove(key.begin(), key.end(), '\n'), key.end());
+  key.erase(std::remove(key.begin(), key.end(), '\r'), key.end());
+  
+  std::string bearer = std::string("Bearer ")+std::string(key);
+
+  BHttpFields fields = BHttpFields();
+  fields.AddField("Authorization", bearer );
+//  fields.AddField("Content-Type", "application/json"); //NO, this will crash, we set it in request
+  request.SetFields(fields);
+
+
+nlohmann::json bodyJson = {
+    { "model", "gpt-3.5-turbo" },
+    { "messages", {
+        {
+            { "role", "user" },
+            { "content", "What is the capital of France?" }
+        }
+    }}
+};
+
+
+std::string body = bodyJson.dump();
+
+BString mime = BString("application/json");
+//request.SetRequestBody(body.c_str(),mime);
+
+
+// 2. Wrap it in BMemoryIO
+auto memoryIO = std::make_unique<BMemoryIO>(
+    body.c_str(),           // pointer to data
+    body.size()            // size of data
+);
+
+// 3. Set the request body with mime type
+request.SetRequestBody(std::move(memoryIO), "application/json", body.size());
+
+//curl https://api.openai.com/v1/chat/completions \
+ // -H "Authorization: Bearer YOUR_API_KEY" \
+ // -H "Content-Type: application/json" \
+ // -d '{
+ //   "model": "gpt-3.5-turbo",
+ //   "messages": [{"role": "user", "content": "What is the capital of France?"}]
+ // }'
+
+
+
 
   printf("Sending Prompt to server: %s\n", url.UrlString().String());
   _lastResult = _sharedSession.Execute(std::move(request), nullptr, this);
@@ -288,3 +358,35 @@ BMenuBar *MainWindow::_BuildMenu() {
 
   return menuBar;
 }
+
+
+
+BString MainWindow::ReadOpenAIKey() {
+
+	// /boot/home/config/openai_key
+	// or ~/.config/openai_key on linux
+	
+    BPath configPath;
+    if (find_directory(B_USER_SETTINGS_DIRECTORY, &configPath) != B_OK)
+        return "error: couldn't find config directory";
+
+    configPath.Append("openai_key");
+
+    BFile file(configPath.Path(), B_READ_ONLY);
+	
+	printf("full path:%s\n",configPath.Path());
+    if (file.InitCheck() != B_OK)
+        return "error: couldn't open key file ";
+
+    off_t size;
+    file.GetSize(&size);
+    
+    char* buffer = new char[size + 1];
+    file.Read(buffer, size);
+    buffer[size] = '\0';  // null-terminate
+
+    BString result(buffer);
+    delete[] buffer;
+
+    return result;
+}
diff --git a/MainWindow.h b/MainWindow.h
index 20613eb..e997826 100644
--- a/MainWindow.h
+++ b/MainWindow.h
@@ -10,6 +10,7 @@
 #include <TextView.h>
 #include <StatusBar.h>
 #include <Window.h>
+#include <String.h>
 
  
 
@@ -22,6 +23,7 @@
 #include "/boot/system/develop/headers/private/netservices2/HttpSession.h"
 #include "/boot/system/develop/headers/private/netservices2/HttpRequest.h"
 #include "/boot/system/develop/headers/private/netservices2/HttpResult.h"
+#include "/boot/system/develop/headers/private/netservices2/HttpFields.h"
 #include "/boot/system/develop/headers/private/netservices2/ErrorsExt.h"
 
 //From private headers !
@@ -43,9 +45,12 @@ public:
   virtual void MessageReceived(BMessage *msg);
 
   void 	sendQuery();
+  BString ReadOpenAIKey();
 
 private:
- 
+
+  
+  BString _apiKey;
   BHttpSession  _sharedSession = BHttpSession ();
 
   std::optional<BHttpResult> _lastResult;
diff --git a/json.hpp b/json.hpp
new file mode 100644
index 0000000..31590ff
--- /dev/null
+++ b/json.hpp
@@ -0,0 +1,25580 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+/****************************************************************************\
+ * Note on documentation: The source files contain links to the online      *
+ * documentation of the public API at https://json.nlohmann.me. This URL    *
+ * contains the most recent documentation and should also be applicable to  *
+ * previous versions; documentation for deprecated functions is not         *
+ * removed, but marked deprecated. See "Generate documentation" section in  *
+ * file docs/README.md.                                                     *
+\****************************************************************************/
+
+#ifndef INCLUDE_NLOHMANN_JSON_HPP_
+#define INCLUDE_NLOHMANN_JSON_HPP_
+
+#include <algorithm> // all_of, find, for_each
+#include <cstddef> // nullptr_t, ptrdiff_t, size_t
+#include <functional> // hash, less
+#include <initializer_list> // initializer_list
+#ifndef JSON_NO_IO
+    #include <iosfwd> // istream, ostream
+#endif  // JSON_NO_IO
+#include <iterator> // random_access_iterator_tag
+#include <memory> // unique_ptr
+#include <string> // string, stoi, to_string
+#include <utility> // declval, forward, move, pair, swap
+#include <vector> // vector
+
+// #include <nlohmann/adl_serializer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <utility>
+
+// #include <nlohmann/detail/abi_macros.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// This file contains all macro definitions affecting or depending on the ABI
+
+#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
+    #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
+        #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 12 || NLOHMANN_JSON_VERSION_PATCH != 0
+            #warning "Already included a different version of the library!"
+        #endif
+    #endif
+#endif
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3   // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_MINOR 12  // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_PATCH 0   // NOLINT(modernize-macro-to-enum)
+
+#ifndef JSON_DIAGNOSTICS
+    #define JSON_DIAGNOSTICS 0
+#endif
+
+#ifndef JSON_DIAGNOSTIC_POSITIONS
+    #define JSON_DIAGNOSTIC_POSITIONS 0
+#endif
+
+#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
+#endif
+
+#if JSON_DIAGNOSTICS
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
+#else
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
+#endif
+
+#if JSON_DIAGNOSTIC_POSITIONS
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS _dp
+#else
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS
+#endif
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
+#else
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
+    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
+#endif
+
+// Construct the namespace ABI tags component
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c)
+
+#define NLOHMANN_JSON_ABI_TAGS                                       \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
+            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS)
+
+// Construct the namespace version component
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
+    _v ## major ## _ ## minor ## _ ## patch
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
+
+#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
+#define NLOHMANN_JSON_NAMESPACE_VERSION
+#else
+#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
+                                           NLOHMANN_JSON_VERSION_MINOR, \
+                                           NLOHMANN_JSON_VERSION_PATCH)
+#endif
+
+// Combine namespace components
+#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
+#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
+    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
+
+#ifndef NLOHMANN_JSON_NAMESPACE
+#define NLOHMANN_JSON_NAMESPACE               \
+    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
+            NLOHMANN_JSON_ABI_TAGS,           \
+            NLOHMANN_JSON_NAMESPACE_VERSION)
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
+#define NLOHMANN_JSON_NAMESPACE_BEGIN                \
+    namespace nlohmann                               \
+    {                                                \
+    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
+                NLOHMANN_JSON_ABI_TAGS,              \
+                NLOHMANN_JSON_NAMESPACE_VERSION)     \
+    {
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_END
+#define NLOHMANN_JSON_NAMESPACE_END                                     \
+    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
+    }  // namespace nlohmann
+#endif
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // transform
+#include <array> // array
+#include <forward_list> // forward_list
+#include <iterator> // inserter, front_inserter, end
+#include <map> // map
+#include <string> // string
+#include <tuple> // tuple, make_tuple
+#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
+#include <unordered_map> // unordered_map
+#include <utility> // pair, declval
+#include <valarray> // valarray
+
+// #include <nlohmann/detail/exceptions.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // nullptr_t
+#include <exception> // exception
+#if JSON_DIAGNOSTICS
+    #include <numeric> // accumulate
+#endif
+#include <stdexcept> // runtime_error
+#include <string> // to_string
+#include <vector> // vector
+
+// #include <nlohmann/detail/value_t.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t
+#include <string> // string
+
+// #include <nlohmann/detail/macro_scope.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <utility> // declval, pair
+// #include <nlohmann/detail/meta/detected.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <type_traits>
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename ...Ts> struct make_void
+{
+    using type = void;
+};
+template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// https://en.cppreference.com/w/cpp/experimental/is_detected
+struct nonesuch
+{
+    nonesuch() = delete;
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const&) = delete;
+    nonesuch(nonesuch const&&) = delete;
+    void operator=(nonesuch const&) = delete;
+    void operator=(nonesuch&&) = delete;
+};
+
+template<class Default,
+         class AlwaysVoid,
+         template<class...> class Op,
+         class... Args>
+struct detector
+{
+    using value_t = std::false_type;
+    using type = Default;
+};
+
+template<class Default, template<class...> class Op, class... Args>
+struct detector<Default, void_t<Op<Args...>>, Op, Args...>
+{
+    using value_t = std::true_type;
+    using type = Op<Args...>;
+};
+
+template<template<class...> class Op, class... Args>
+using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
+
+template<template<class...> class Op, class... Args>
+struct is_detected_lazy : is_detected<Op, Args...> { };
+
+template<template<class...> class Op, class... Args>
+using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or = detector<Default, void, Op, Args...>;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+template<class Expected, template<class...> class Op, class... Args>
+using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
+
+template<class To, template<class...> class Op, class... Args>
+using is_detected_convertible =
+    std::is_convertible<detected_t<Op, Args...>, To>;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/thirdparty/hedley/hedley.hpp>
+
+
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-FileCopyrightText: 2016 - 2021 Evan Nemerson <evan@nemerson.com>
+// SPDX-License-Identifier: MIT
+
+/* Hedley - https://nemequ.github.io/hedley
+ * Created by Evan Nemerson <evan@nemerson.com>
+ */
+
+#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
+#if defined(JSON_HEDLEY_VERSION)
+    #undef JSON_HEDLEY_VERSION
+#endif
+#define JSON_HEDLEY_VERSION 15
+
+#if defined(JSON_HEDLEY_STRINGIFY_EX)
+    #undef JSON_HEDLEY_STRINGIFY_EX
+#endif
+#define JSON_HEDLEY_STRINGIFY_EX(x) #x
+
+#if defined(JSON_HEDLEY_STRINGIFY)
+    #undef JSON_HEDLEY_STRINGIFY
+#endif
+#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
+
+#if defined(JSON_HEDLEY_CONCAT_EX)
+    #undef JSON_HEDLEY_CONCAT_EX
+#endif
+#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
+
+#if defined(JSON_HEDLEY_CONCAT)
+    #undef JSON_HEDLEY_CONCAT
+#endif
+#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
+
+#if defined(JSON_HEDLEY_CONCAT3_EX)
+    #undef JSON_HEDLEY_CONCAT3_EX
+#endif
+#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
+
+#if defined(JSON_HEDLEY_CONCAT3)
+    #undef JSON_HEDLEY_CONCAT3
+#endif
+#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
+
+#if defined(JSON_HEDLEY_VERSION_ENCODE)
+    #undef JSON_HEDLEY_VERSION_ENCODE
+#endif
+#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
+    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
+
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #undef JSON_HEDLEY_GNUC_VERSION
+#endif
+#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#elif defined(__GNUC__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION)
+    #undef JSON_HEDLEY_MSVC_VERSION
+#endif
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
+#elif defined(_MSC_FULL_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
+#elif defined(_MSC_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#endif
+#if !defined(JSON_HEDLEY_MSVC_VERSION)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
+#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
+#else
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #undef JSON_HEDLEY_INTEL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
+#elif defined(__INTEL_COMPILER) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
+    #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #undef JSON_HEDLEY_PGI_VERSION
+#endif
+#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
+    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
+    #undef JSON_HEDLEY_PGI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #undef JSON_HEDLEY_SUNPRO_VERSION
+#endif
+#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
+#elif defined(__SUNPRO_C)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
+#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
+#elif defined(__SUNPRO_CC)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
+    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#endif
+#if defined(__EMSCRIPTEN__)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #undef JSON_HEDLEY_ARM_VERSION
+#endif
+#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
+#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
+    #undef JSON_HEDLEY_ARM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #undef JSON_HEDLEY_IBM_VERSION
+#endif
+#if defined(__ibmxl__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
+#elif defined(__xlC__) && defined(__xlC_ver__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
+#elif defined(__xlC__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
+    #undef JSON_HEDLEY_IBM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #undef JSON_HEDLEY_TI_VERSION
+#endif
+#if \
+    defined(__TI_COMPILER_VERSION__) && \
+    ( \
+      defined(__TMS470__) || defined(__TI_ARM__) || \
+      defined(__MSP430__) || \
+      defined(__TMS320C2000__) \
+    )
+#if (__TI_COMPILER_VERSION__ >= 16000000)
+    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
+    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #undef JSON_HEDLEY_TI_CL430_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
+    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
+    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
+    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
+    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #undef JSON_HEDLEY_CRAY_VERSION
+#endif
+#if defined(_CRAYC)
+    #if defined(_RELEASE_PATCHLEVEL)
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
+    #else
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
+    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #undef JSON_HEDLEY_IAR_VERSION
+#endif
+#if defined(__IAR_SYSTEMS_ICC__)
+    #if __VER__ > 1000
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
+    #else
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
+    #undef JSON_HEDLEY_IAR_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #undef JSON_HEDLEY_TINYC_VERSION
+#endif
+#if defined(__TINYC__)
+    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
+    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #undef JSON_HEDLEY_DMC_VERSION
+#endif
+#if defined(__DMC__)
+    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
+    #undef JSON_HEDLEY_DMC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #undef JSON_HEDLEY_COMPCERT_VERSION
+#endif
+#if defined(__COMPCERT_VERSION__)
+    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
+    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #undef JSON_HEDLEY_PELLES_VERSION
+#endif
+#if defined(__POCC__)
+    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
+    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #undef JSON_HEDLEY_MCST_LCC_VERSION
+#endif
+#if defined(__LCC__) && defined(__LCC_MINOR__)
+    #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
+#endif
+
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #undef JSON_HEDLEY_GCC_VERSION
+#endif
+#if \
+    defined(JSON_HEDLEY_GNUC_VERSION) && \
+    !defined(__clang__) && \
+    !defined(JSON_HEDLEY_INTEL_VERSION) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_ARM_VERSION) && \
+    !defined(JSON_HEDLEY_CRAY_VERSION) && \
+    !defined(JSON_HEDLEY_TI_VERSION) && \
+    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
+    !defined(__COMPCERT__) && \
+    !defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_ATTRIBUTE
+#endif
+#if \
+  defined(__has_attribute) && \
+  ( \
+    (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
+  )
+#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
+#else
+#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#endif
+#if \
+    defined(__has_cpp_attribute) && \
+    defined(__cplusplus) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#endif
+#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#elif \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_IAR_VERSION) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
+    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_BUILTIN)
+    #undef JSON_HEDLEY_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_FEATURE)
+    #undef JSON_HEDLEY_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GCC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_EXTENSION)
+    #undef JSON_HEDLEY_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_WARNING)
+    #undef JSON_HEDLEY_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
+    #undef JSON_HEDLEY_GNUC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
+    #undef JSON_HEDLEY_GCC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
+    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
+#else
+    #define JSON_HEDLEY_PRAGMA(value)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
+    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#endif
+#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
+    #undef JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
+    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
+#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
+    #define JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+
+/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
+#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
+#      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      else
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      endif
+#    else
+#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    endif
+#  endif
+#endif
+#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
+#endif
+
+#if defined(JSON_HEDLEY_CONST_CAST)
+    #undef JSON_HEDLEY_CONST_CAST
+#endif
+#if defined(__cplusplus)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
+#elif \
+  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_REINTERPRET_CAST)
+    #undef JSON_HEDLEY_REINTERPRET_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_CAST)
+    #undef JSON_HEDLEY_STATIC_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_CPP_CAST)
+    #undef JSON_HEDLEY_CPP_CAST
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
+    ((T) (expr)) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("diag_suppress=Pe137") \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
+#  endif
+#else
+#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#endif
+
+#if defined(JSON_HEDLEY_DEPRECATED)
+    #undef JSON_HEDLEY_DEPRECATED
+#endif
+#if defined(JSON_HEDLEY_DEPRECATED_FOR)
+    #undef JSON_HEDLEY_DEPRECATED_FOR
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
+#elif \
+    (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
+#elif defined(__cplusplus) && (__cplusplus >= 201402L)
+    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
+#else
+    #define JSON_HEDLEY_DEPRECATED(since)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
+#endif
+
+#if defined(JSON_HEDLEY_UNAVAILABLE)
+    #undef JSON_HEDLEY_UNAVAILABLE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
+#else
+    #define JSON_HEDLEY_UNAVAILABLE(available_since)
+#endif
+
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#endif
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
+#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+#elif defined(_Check_return_) /* SAL */
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
+#else
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
+#endif
+
+#if defined(JSON_HEDLEY_SENTINEL)
+    #undef JSON_HEDLEY_SENTINEL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
+#else
+    #define JSON_HEDLEY_SENTINEL(position)
+#endif
+
+#if defined(JSON_HEDLEY_NO_RETURN)
+    #undef JSON_HEDLEY_NO_RETURN
+#endif
+#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NO_RETURN __noreturn
+#elif \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+    #define JSON_HEDLEY_NO_RETURN _Noreturn
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#else
+    #define JSON_HEDLEY_NO_RETURN
+#endif
+
+#if defined(JSON_HEDLEY_NO_ESCAPE)
+    #undef JSON_HEDLEY_NO_ESCAPE
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
+    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
+#else
+    #define JSON_HEDLEY_NO_ESCAPE
+#endif
+
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #undef JSON_HEDLEY_UNREACHABLE
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
+    #undef JSON_HEDLEY_UNREACHABLE_RETURN
+#endif
+#if defined(JSON_HEDLEY_ASSUME)
+    #undef JSON_HEDLEY_ASSUME
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
+#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
+    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
+#elif \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+    #if defined(__cplusplus)
+        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
+    #endif
+#endif
+#if \
+    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
+#elif defined(JSON_HEDLEY_ASSUME)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+#if !defined(JSON_HEDLEY_ASSUME)
+    #if defined(JSON_HEDLEY_UNREACHABLE)
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
+    #endif
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #if  \
+        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
+    #else
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
+    #endif
+#else
+    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
+#endif
+#if !defined(JSON_HEDLEY_UNREACHABLE)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+
+JSON_HEDLEY_DIAGNOSTIC_PUSH
+#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
+    #pragma clang diagnostic ignored "-Wpedantic"
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
+    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#endif
+#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
+    #if defined(__clang__)
+        #pragma clang diagnostic ignored "-Wvariadic-macros"
+    #elif defined(JSON_HEDLEY_GCC_VERSION)
+        #pragma GCC diagnostic ignored "-Wvariadic-macros"
+    #endif
+#endif
+#if defined(JSON_HEDLEY_NON_NULL)
+    #undef JSON_HEDLEY_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
+#else
+    #define JSON_HEDLEY_NON_NULL(...)
+#endif
+JSON_HEDLEY_DIAGNOSTIC_POP
+
+#if defined(JSON_HEDLEY_PRINTF_FORMAT)
+    #undef JSON_HEDLEY_PRINTF_FORMAT
+#endif
+#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
+#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
+#else
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
+#endif
+
+#if defined(JSON_HEDLEY_CONSTEXPR)
+    #undef JSON_HEDLEY_CONSTEXPR
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
+    #endif
+#endif
+#if !defined(JSON_HEDLEY_CONSTEXPR)
+    #define JSON_HEDLEY_CONSTEXPR
+#endif
+
+#if defined(JSON_HEDLEY_PREDICT)
+    #undef JSON_HEDLEY_PREDICT
+#endif
+#if defined(JSON_HEDLEY_LIKELY)
+    #undef JSON_HEDLEY_LIKELY
+#endif
+#if defined(JSON_HEDLEY_UNLIKELY)
+    #undef JSON_HEDLEY_UNLIKELY
+#endif
+#if defined(JSON_HEDLEY_UNPREDICTABLE)
+    #undef JSON_HEDLEY_UNPREDICTABLE
+#endif
+#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
+#endif
+#if \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
+#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
+#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
+#elif \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
+  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
+    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
+#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
+#else
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
+#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
+#endif
+#if !defined(JSON_HEDLEY_UNPREDICTABLE)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
+#endif
+
+#if defined(JSON_HEDLEY_MALLOC)
+    #undef JSON_HEDLEY_MALLOC
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_MALLOC __declspec(restrict)
+#else
+    #define JSON_HEDLEY_MALLOC
+#endif
+
+#if defined(JSON_HEDLEY_PURE)
+    #undef JSON_HEDLEY_PURE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PURE __attribute__((__pure__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
+    )
+#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
+#else
+#  define JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_CONST)
+    #undef JSON_HEDLEY_CONST
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_CONST __attribute__((__const__))
+#elif \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
+#else
+    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_RESTRICT)
+    #undef JSON_HEDLEY_RESTRICT
+#endif
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT restrict
+#elif \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_RESTRICT __restrict
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT _Restrict
+#else
+    #define JSON_HEDLEY_RESTRICT
+#endif
+
+#if defined(JSON_HEDLEY_INLINE)
+    #undef JSON_HEDLEY_INLINE
+#endif
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    (defined(__cplusplus) && (__cplusplus >= 199711L))
+    #define JSON_HEDLEY_INLINE inline
+#elif \
+    defined(JSON_HEDLEY_GCC_VERSION) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
+    #define JSON_HEDLEY_INLINE __inline__
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_INLINE __inline
+#else
+    #define JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_ALWAYS_INLINE)
+    #undef JSON_HEDLEY_ALWAYS_INLINE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
+    )
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
+#else
+#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_NEVER_INLINE)
+    #undef JSON_HEDLEY_NEVER_INLINE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#else
+    #define JSON_HEDLEY_NEVER_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_PRIVATE)
+    #undef JSON_HEDLEY_PRIVATE
+#endif
+#if defined(JSON_HEDLEY_PUBLIC)
+    #undef JSON_HEDLEY_PUBLIC
+#endif
+#if defined(JSON_HEDLEY_IMPORT)
+    #undef JSON_HEDLEY_IMPORT
+#endif
+#if defined(_WIN32) || defined(__CYGWIN__)
+#  define JSON_HEDLEY_PRIVATE
+#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
+#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
+#else
+#  if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    ( \
+      defined(__TI_EABI__) && \
+      ( \
+        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
+      ) \
+    ) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
+#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
+#  else
+#    define JSON_HEDLEY_PRIVATE
+#    define JSON_HEDLEY_PUBLIC
+#  endif
+#  define JSON_HEDLEY_IMPORT    extern
+#endif
+
+#if defined(JSON_HEDLEY_NO_THROW)
+    #undef JSON_HEDLEY_NO_THROW
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
+#else
+    #define JSON_HEDLEY_NO_THROW
+#endif
+
+#if defined(JSON_HEDLEY_FALL_THROUGH)
+    #undef JSON_HEDLEY_FALL_THROUGH
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
+#elif defined(__fallthrough) /* SAL */
+    #define JSON_HEDLEY_FALL_THROUGH __fallthrough
+#else
+    #define JSON_HEDLEY_FALL_THROUGH
+#endif
+
+#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
+    #undef JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
+#elif defined(_Ret_notnull_) /* SAL */
+    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
+#else
+    #define JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+
+#if defined(JSON_HEDLEY_ARRAY_PARAM)
+    #undef JSON_HEDLEY_ARRAY_PARAM
+#endif
+#if \
+    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
+    !defined(__STDC_NO_VLA__) && \
+    !defined(__cplusplus) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
+#else
+    #define JSON_HEDLEY_ARRAY_PARAM(name)
+#endif
+
+#if defined(JSON_HEDLEY_IS_CONSTANT)
+    #undef JSON_HEDLEY_IS_CONSTANT
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
+    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#endif
+/* JSON_HEDLEY_IS_CONSTEXPR_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #undef JSON_HEDLEY_IS_CONSTEXPR_
+#endif
+#if \
+    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
+#endif
+#if !defined(__cplusplus)
+#  if \
+       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
+#endif
+#  elif \
+       ( \
+          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
+          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
+          !defined(JSON_HEDLEY_PGI_VERSION) && \
+          !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
+#endif
+#  elif \
+       defined(JSON_HEDLEY_GCC_VERSION) || \
+       defined(JSON_HEDLEY_INTEL_VERSION) || \
+       defined(JSON_HEDLEY_TINYC_VERSION) || \
+       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
+       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
+       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
+       defined(__clang__)
+#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
+        sizeof(void) != \
+        sizeof(*( \
+                  1 ? \
+                  ((void*) ((expr) * 0L) ) : \
+((struct { char v[sizeof(void) * 2]; } *) 1) \
+                ) \
+              ) \
+                                            )
+#  endif
+#endif
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
+#else
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
+    #undef JSON_HEDLEY_BEGIN_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_END_C_DECLS)
+    #undef JSON_HEDLEY_END_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_C_DECL)
+    #undef JSON_HEDLEY_C_DECL
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
+    #define JSON_HEDLEY_END_C_DECLS }
+    #define JSON_HEDLEY_C_DECL extern "C"
+#else
+    #define JSON_HEDLEY_BEGIN_C_DECLS
+    #define JSON_HEDLEY_END_C_DECLS
+    #define JSON_HEDLEY_C_DECL
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_ASSERT)
+    #undef JSON_HEDLEY_STATIC_ASSERT
+#endif
+#if \
+  !defined(__cplusplus) && ( \
+      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
+      (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
+      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+      defined(_Static_assert) \
+    )
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
+#elif \
+  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
+#else
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
+#endif
+
+#if defined(JSON_HEDLEY_NULL)
+    #undef JSON_HEDLEY_NULL
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
+    #elif defined(NULL)
+        #define JSON_HEDLEY_NULL NULL
+    #else
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
+    #endif
+#elif defined(NULL)
+    #define JSON_HEDLEY_NULL NULL
+#else
+    #define JSON_HEDLEY_NULL ((void*) 0)
+#endif
+
+#if defined(JSON_HEDLEY_MESSAGE)
+    #undef JSON_HEDLEY_MESSAGE
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_MESSAGE(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(message msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
+#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_WARNING)
+    #undef JSON_HEDLEY_WARNING
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_WARNING(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(clang warning msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_REQUIRE)
+    #undef JSON_HEDLEY_REQUIRE
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_MSG)
+    #undef JSON_HEDLEY_REQUIRE_MSG
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
+#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
+#    define JSON_HEDLEY_REQUIRE(expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), msg, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
+#  endif
+#else
+#  define JSON_HEDLEY_REQUIRE(expr)
+#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS)
+    #undef JSON_HEDLEY_FLAGS
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
+    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
+#else
+    #define JSON_HEDLEY_FLAGS
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS_CAST)
+    #undef JSON_HEDLEY_FLAGS_CAST
+#endif
+#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        _Pragma("warning(disable:188)") \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
+#endif
+
+#if defined(JSON_HEDLEY_EMPTY_BASES)
+    #undef JSON_HEDLEY_EMPTY_BASES
+#endif
+#if \
+    (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
+#else
+    #define JSON_HEDLEY_EMPTY_BASES
+#endif
+
+/* Remaining macros are deprecated. */
+
+#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
+#else
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
+    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#endif
+#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
+    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
+    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#endif
+#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
+    #undef JSON_HEDLEY_CLANG_HAS_WARNING
+#endif
+#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
+
+#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
+
+
+// This file contains all internal macro definitions (except those affecting ABI)
+// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+// exclude unsupported compilers
+#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
+    #if defined(__clang__)
+        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
+            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
+        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
+            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #endif
+#endif
+
+// C++ language standard detection
+// if the user manually specified the used C++ version, this is skipped
+#if !defined(JSON_HAS_CPP_23) && !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
+    #if (defined(__cplusplus) && __cplusplus > 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG > 202002L)
+        #define JSON_HAS_CPP_23
+        #define JSON_HAS_CPP_20
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus > 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG > 201703L)
+        #define JSON_HAS_CPP_20
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus > 201402L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus > 201103L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+        #define JSON_HAS_CPP_14
+    #endif
+    // the cpp 11 flag is always specified because it is the minimal required version
+    #define JSON_HAS_CPP_11
+#endif
+
+#ifdef __has_include
+    #if __has_include(<version>)
+        #include <version>
+    #endif
+#endif
+
+#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
+    #ifdef JSON_HAS_CPP_17
+        #if defined(__cpp_lib_filesystem)
+            #define JSON_HAS_FILESYSTEM 1
+        #elif defined(__cpp_lib_experimental_filesystem)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #elif !defined(__has_include)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #elif __has_include(<filesystem>)
+            #define JSON_HAS_FILESYSTEM 1
+        #elif __has_include(<experimental/filesystem>)
+            #define JSON_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 JSON_HAS_FILESYSTEM
+            #undef JSON_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 JSON_HAS_FILESYSTEM
+            #undef JSON_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 JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(_MSC_VER) && _MSC_VER < 1914
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before iOS 13
+        #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before macOS Catalina
+        #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+    #endif
+#endif
+
+#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+    #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
+#endif
+
+#ifndef JSON_HAS_FILESYSTEM
+    #define JSON_HAS_FILESYSTEM 0
+#endif
+
+#ifndef JSON_HAS_THREE_WAY_COMPARISON
+    #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \
+        && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L
+        #define JSON_HAS_THREE_WAY_COMPARISON 1
+    #else
+        #define JSON_HAS_THREE_WAY_COMPARISON 0
+    #endif
+#endif
+
+#ifndef JSON_HAS_RANGES
+    // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has a syntax error
+    #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427
+        #define JSON_HAS_RANGES 0
+    #elif defined(__cpp_lib_ranges)
+        #define JSON_HAS_RANGES 1
+    #else
+        #define JSON_HAS_RANGES 0
+    #endif
+#endif
+
+#ifndef JSON_HAS_STATIC_RTTI
+    #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0
+        #define JSON_HAS_STATIC_RTTI 1
+    #else
+        #define JSON_HAS_STATIC_RTTI 0
+    #endif
+#endif
+
+#ifdef JSON_HAS_CPP_17
+    #define JSON_INLINE_VARIABLE inline
+#else
+    #define JSON_INLINE_VARIABLE
+#endif
+
+#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address)
+    #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#else
+    #define JSON_NO_UNIQUE_ADDRESS
+#endif
+
+// disable documentation warnings on clang
+#if defined(__clang__)
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wdocumentation"
+    #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
+#endif
+
+// allow disabling exceptions
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
+    #define JSON_THROW(exception) throw exception
+    #define JSON_TRY try
+    #define JSON_CATCH(exception) catch(exception)
+    #define JSON_INTERNAL_CATCH(exception) catch(exception)
+#else
+    #include <cstdlib>
+    #define JSON_THROW(exception) std::abort()
+    #define JSON_TRY if(true)
+    #define JSON_CATCH(exception) if(false)
+    #define JSON_INTERNAL_CATCH(exception) if(false)
+#endif
+
+// override exception macros
+#if defined(JSON_THROW_USER)
+    #undef JSON_THROW
+    #define JSON_THROW JSON_THROW_USER
+#endif
+#if defined(JSON_TRY_USER)
+    #undef JSON_TRY
+    #define JSON_TRY JSON_TRY_USER
+#endif
+#if defined(JSON_CATCH_USER)
+    #undef JSON_CATCH
+    #define JSON_CATCH JSON_CATCH_USER
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
+#endif
+#if defined(JSON_INTERNAL_CATCH_USER)
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
+#endif
+
+// allow overriding assert
+#if !defined(JSON_ASSERT)
+    #include <cassert> // assert
+    #define JSON_ASSERT(x) assert(x)
+#endif
+
+// allow accessing some private functions (needed by the test suite)
+#if defined(JSON_TESTS_PRIVATE)
+    #define JSON_PRIVATE_UNLESS_TESTED public
+#else
+    #define JSON_PRIVATE_UNLESS_TESTED private
+#endif
+
+/*!
+@brief macro to briefly define a mapping between an enum and JSON
+@def NLOHMANN_JSON_SERIALIZE_ENUM
+@since version 3.4.0
+*/
+#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
+    template<typename BasicJsonType>                                                            \
+    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
+    {                                                                                           \
+        /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on <array> */       \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
+        {                                                                                       \
+            return ej_pair.first == e;                                                          \
+        });                                                                                     \
+        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
+    }                                                                                           \
+    template<typename BasicJsonType>                                                            \
+    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
+    {                                                                                           \
+        /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on <array> */       \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+        {                                                                                       \
+            return ej_pair.second == j;                                                         \
+        });                                                                                     \
+        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
+    }
+
+// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
+// may be removed in the future once the class is split.
+
+#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
+    template<template<typename, typename, typename...> class ObjectType,   \
+             template<typename, typename...> class ArrayType,              \
+             class StringType, class BooleanType, class NumberIntegerType, \
+             class NumberUnsignedType, class NumberFloatType,              \
+             template<typename> class AllocatorType,                       \
+             template<typename, typename = void> class JSONSerializer,     \
+             class BinaryType,                                             \
+             class CustomBaseClass>
+
+#define NLOHMANN_BASIC_JSON_TPL                                            \
+    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
+    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
+    AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>
+
+// Macros to simplify conversion from/to types
+
+#define NLOHMANN_JSON_EXPAND( x ) x
+#define NLOHMANN_JSON_GET_MACRO(_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, NAME,...) NAME
+#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
+        NLOHMANN_JSON_PASTE64, \
+        NLOHMANN_JSON_PASTE63, \
+        NLOHMANN_JSON_PASTE62, \
+        NLOHMANN_JSON_PASTE61, \
+        NLOHMANN_JSON_PASTE60, \
+        NLOHMANN_JSON_PASTE59, \
+        NLOHMANN_JSON_PASTE58, \
+        NLOHMANN_JSON_PASTE57, \
+        NLOHMANN_JSON_PASTE56, \
+        NLOHMANN_JSON_PASTE55, \
+        NLOHMANN_JSON_PASTE54, \
+        NLOHMANN_JSON_PASTE53, \
+        NLOHMANN_JSON_PASTE52, \
+        NLOHMANN_JSON_PASTE51, \
+        NLOHMANN_JSON_PASTE50, \
+        NLOHMANN_JSON_PASTE49, \
+        NLOHMANN_JSON_PASTE48, \
+        NLOHMANN_JSON_PASTE47, \
+        NLOHMANN_JSON_PASTE46, \
+        NLOHMANN_JSON_PASTE45, \
+        NLOHMANN_JSON_PASTE44, \
+        NLOHMANN_JSON_PASTE43, \
+        NLOHMANN_JSON_PASTE42, \
+        NLOHMANN_JSON_PASTE41, \
+        NLOHMANN_JSON_PASTE40, \
+        NLOHMANN_JSON_PASTE39, \
+        NLOHMANN_JSON_PASTE38, \
+        NLOHMANN_JSON_PASTE37, \
+        NLOHMANN_JSON_PASTE36, \
+        NLOHMANN_JSON_PASTE35, \
+        NLOHMANN_JSON_PASTE34, \
+        NLOHMANN_JSON_PASTE33, \
+        NLOHMANN_JSON_PASTE32, \
+        NLOHMANN_JSON_PASTE31, \
+        NLOHMANN_JSON_PASTE30, \
+        NLOHMANN_JSON_PASTE29, \
+        NLOHMANN_JSON_PASTE28, \
+        NLOHMANN_JSON_PASTE27, \
+        NLOHMANN_JSON_PASTE26, \
+        NLOHMANN_JSON_PASTE25, \
+        NLOHMANN_JSON_PASTE24, \
+        NLOHMANN_JSON_PASTE23, \
+        NLOHMANN_JSON_PASTE22, \
+        NLOHMANN_JSON_PASTE21, \
+        NLOHMANN_JSON_PASTE20, \
+        NLOHMANN_JSON_PASTE19, \
+        NLOHMANN_JSON_PASTE18, \
+        NLOHMANN_JSON_PASTE17, \
+        NLOHMANN_JSON_PASTE16, \
+        NLOHMANN_JSON_PASTE15, \
+        NLOHMANN_JSON_PASTE14, \
+        NLOHMANN_JSON_PASTE13, \
+        NLOHMANN_JSON_PASTE12, \
+        NLOHMANN_JSON_PASTE11, \
+        NLOHMANN_JSON_PASTE10, \
+        NLOHMANN_JSON_PASTE9, \
+        NLOHMANN_JSON_PASTE8, \
+        NLOHMANN_JSON_PASTE7, \
+        NLOHMANN_JSON_PASTE6, \
+        NLOHMANN_JSON_PASTE5, \
+        NLOHMANN_JSON_PASTE4, \
+        NLOHMANN_JSON_PASTE3, \
+        NLOHMANN_JSON_PASTE2, \
+        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
+#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
+#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
+#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
+#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
+#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
+#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
+#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
+#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
+#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
+#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
+#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
+#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
+#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
+#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
+#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
+#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
+#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
+#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
+#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
+#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
+#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
+#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
+#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
+#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
+#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
+#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
+#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
+#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
+#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
+#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
+#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
+#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
+#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
+#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
+#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
+#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
+#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
+#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
+#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
+#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
+#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
+#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
+#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
+#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
+#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
+#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
+#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
+#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
+#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
+#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
+#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
+#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
+#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
+#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
+#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
+#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
+#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
+#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
+#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
+#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
+#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
+
+#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
+#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
+#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1) : nlohmann_json_default_obj.v1;
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
+@since version 3.9.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
+*/
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT
+@since version 3.11.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
+*/
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE
+@since version 3.11.3
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
+*/
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
+@since version 3.9.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
+*/
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT
+@since version 3.11.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
+*/
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE
+@since version 3.11.3
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
+*/
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE
+@since version 3.12.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT
+@since version 3.12.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE
+@since version 3.12.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE
+@since version 3.12.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT
+@since version 3.12.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE
+@since version 3.12.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+// inspired from https://stackoverflow.com/a/26745591
+// allows calling any std function as if (e.g., with begin):
+// using std::begin; begin(x);
+//
+// it allows using the detected idiom to retrieve the return type
+// of such an expression
+#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)                                 \
+    namespace detail {                                                            \
+    using std::std_name;                                                          \
+    \
+    template<typename... T>                                                       \
+    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
+    }                                                                             \
+    \
+    namespace detail2 {                                                           \
+    struct std_name##_tag                                                         \
+    {                                                                             \
+    };                                                                            \
+    \
+    template<typename... T>                                                       \
+    std_name##_tag std_name(T&&...);                                              \
+    \
+    template<typename... T>                                                       \
+    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
+    \
+    template<typename... T>                                                       \
+    struct would_call_std_##std_name                                              \
+    {                                                                             \
+        static constexpr auto const value = ::nlohmann::detail::                  \
+                                            is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
+    };                                                                            \
+    } /* namespace detail2 */ \
+    \
+    template<typename... T>                                                       \
+    struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...>   \
+    {                                                                             \
+    }
+
+#ifndef JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_USE_IMPLICIT_CONVERSIONS 1
+#endif
+
+#if JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_EXPLICIT
+#else
+    #define JSON_EXPLICIT explicit
+#endif
+
+#ifndef JSON_DISABLE_ENUM_SERIALIZATION
+    #define JSON_DISABLE_ENUM_SERIALIZATION 0
+#endif
+
+#ifndef JSON_USE_GLOBAL_UDLS
+    #define JSON_USE_GLOBAL_UDLS 1
+#endif
+
+#if JSON_HAS_THREE_WAY_COMPARISON
+    #include <compare> // partial_ordering
+#endif
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////////////////////
+// JSON type enumeration //
+///////////////////////////
+
+/*!
+@brief the JSON type enumeration
+
+This enumeration collects the different JSON types. It is internally used to
+distinguish the stored values, and the functions @ref basic_json::is_null(),
+@ref basic_json::is_object(), @ref basic_json::is_array(),
+@ref basic_json::is_string(), @ref basic_json::is_boolean(),
+@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
+@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
+@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
+@ref basic_json::is_structured() rely on it.
+
+@note There are three enumeration entries (number_integer, number_unsigned, and
+number_float), because the library distinguishes these three types for numbers:
+@ref basic_json::number_unsigned_t is used for unsigned integers,
+@ref basic_json::number_integer_t is used for signed integers, and
+@ref basic_json::number_float_t is used for floating-point numbers or to
+approximate integers which do not fit in the limits of their respective type.
+
+@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
+value with the default value for a given type
+
+@since version 1.0.0
+*/
+enum class value_t : std::uint8_t
+{
+    null,             ///< null value
+    object,           ///< object (unordered set of name/value pairs)
+    array,            ///< array (ordered collection of values)
+    string,           ///< string value
+    boolean,          ///< boolean value
+    number_integer,   ///< number value (signed integer)
+    number_unsigned,  ///< number value (unsigned integer)
+    number_float,     ///< number value (floating-point)
+    binary,           ///< binary array (ordered collection of bytes)
+    discarded         ///< discarded by the parser callback function
+};
+
+/*!
+@brief comparison operator for JSON types
+
+Returns an ordering that is similar to Python:
+- order: null < boolean < number < object < array < string < binary
+- furthermore, each type is not smaller than itself
+- discarded values are not comparable
+- binary is represented as a b"" string in python and directly comparable to a
+  string; however, making a binary array directly comparable with a string would
+  be surprising behavior in a JSON file.
+
+@since version 1.0.0
+*/
+#if JSON_HAS_THREE_WAY_COMPARISON
+    inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*
+#else
+    inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+#endif
+{
+    static constexpr std::array<std::uint8_t, 9> order = {{
+            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
+            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
+            6 /* binary */
+        }
+    };
+
+    const auto l_index = static_cast<std::size_t>(lhs);
+    const auto r_index = static_cast<std::size_t>(rhs);
+#if JSON_HAS_THREE_WAY_COMPARISON
+    if (l_index < order.size() && r_index < order.size())
+    {
+        return order[l_index] <=> order[r_index]; // *NOPAD*
+    }
+    return std::partial_ordering::unordered;
+#else
+    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
+#endif
+}
+
+// GCC selects the built-in operator< over an operator rewritten from
+// a user-defined spaceship operator
+// Clang, MSVC, and ICC select the rewritten candidate
+// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200)
+#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__)
+inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+{
+    return std::is_lt(lhs <=> rhs); // *NOPAD*
+}
+#endif
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/string_escape.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief replace all occurrences of a substring by another string
+
+@param[in,out] s  the string to manipulate; changed so that all
+               occurrences of @a f are replaced with @a t
+@param[in]     f  the substring to replace with @a t
+@param[in]     t  the string to replace @a f
+
+@pre The search string @a f must not be empty. **This precondition is
+enforced with an assertion.**
+
+@since version 2.0.0
+*/
+template<typename StringType>
+inline void replace_substring(StringType& s, const StringType& f,
+                              const StringType& t)
+{
+    JSON_ASSERT(!f.empty());
+    for (auto pos = s.find(f);                // find the first occurrence of f
+            pos != StringType::npos;          // make sure f was found
+            s.replace(pos, f.size(), t),      // replace with t, and
+            pos = s.find(f, pos + t.size()))  // find the next occurrence of f
+    {}
+}
+
+/*!
+ * @brief string escaping as described in RFC 6901 (Sect. 4)
+ * @param[in] s string to escape
+ * @return    escaped string
+ *
+ * Note the order of escaping "~" to "~0" and "/" to "~1" is important.
+ */
+template<typename StringType>
+inline StringType escape(StringType s)
+{
+    replace_substring(s, StringType{"~"}, StringType{"~0"});
+    replace_substring(s, StringType{"/"}, StringType{"~1"});
+    return s;
+}
+
+/*!
+ * @brief string unescaping as described in RFC 6901 (Sect. 4)
+ * @param[in] s string to unescape
+ * @return    unescaped string
+ *
+ * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
+ */
+template<typename StringType>
+inline void unescape(StringType& s)
+{
+    replace_substring(s, StringType{"~1"}, StringType{"/"});
+    replace_substring(s, StringType{"~0"}, StringType{"~"});
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/position_t.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // size_t
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// struct to capture the start position of the current token
+struct position_t
+{
+    /// the total number of characters read
+    std::size_t chars_read_total = 0;
+    /// the number of characters read in the current line
+    std::size_t chars_read_current_line = 0;
+    /// the number of lines read
+    std::size_t lines_read = 0;
+
+    /// conversion to size_t to preserve SAX interface
+    constexpr operator size_t() const
+    {
+        return chars_read_total;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-FileCopyrightText: 2018 The Abseil Authors
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
+#include <utility> // index_sequence, make_index_sequence, index_sequence_for
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename T>
+using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+#ifdef JSON_HAS_CPP_14
+
+// the following utilities are natively available in C++14
+using std::enable_if_t;
+using std::index_sequence;
+using std::make_index_sequence;
+using std::index_sequence_for;
+
+#else
+
+// alias templates to reduce boilerplate
+template<bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
+// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.
+
+//// START OF CODE FROM GOOGLE ABSEIL
+
+// integer_sequence
+//
+// Class template representing a compile-time integer sequence. An instantiation
+// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
+// type through its template arguments (which is a common need when
+// working with C++11 variadic templates). `absl::integer_sequence` is designed
+// to be a drop-in replacement for C++14's `std::integer_sequence`.
+//
+// Example:
+//
+//   template< class T, T... Ints >
+//   void user_function(integer_sequence<T, Ints...>);
+//
+//   int main()
+//   {
+//     // user_function's `T` will be deduced to `int` and `Ints...`
+//     // will be deduced to `0, 1, 2, 3, 4`.
+//     user_function(make_integer_sequence<int, 5>());
+//   }
+template <typename T, T... Ints>
+struct integer_sequence
+{
+    using value_type = T;
+    static constexpr std::size_t size() noexcept
+    {
+        return sizeof...(Ints);
+    }
+};
+
+// index_sequence
+//
+// A helper template for an `integer_sequence` of `size_t`,
+// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
+// `std::index_sequence`.
+template <size_t... Ints>
+using index_sequence = integer_sequence<size_t, Ints...>;
+
+namespace utility_internal
+{
+
+template <typename Seq, size_t SeqSize, size_t Rem>
+struct Extend;
+
+// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
+{
+    using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
+};
+
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
+{
+    using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
+};
+
+// Recursion helper for 'make_integer_sequence<T, N>'.
+// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
+template <typename T, size_t N>
+struct Gen
+{
+    using type =
+        typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
+};
+
+template <typename T>
+struct Gen<T, 0>
+{
+    using type = integer_sequence<T>;
+};
+
+}  // namespace utility_internal
+
+// Compile-time sequences of integers
+
+// make_integer_sequence
+//
+// This template alias is equivalent to
+// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
+// replacement for C++14's `std::make_integer_sequence`.
+template <typename T, T N>
+using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
+
+// make_index_sequence
+//
+// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
+// and is designed to be a drop-in replacement for C++14's
+// `std::make_index_sequence`.
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
+
+// index_sequence_for
+//
+// Converts a typename pack into an index sequence of the same length, and
+// is designed to be a drop-in replacement for C++14's
+// `std::index_sequence_for()`
+template <typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+//// END OF CODE FROM GOOGLE ABSEIL
+
+#endif
+
+// dispatch utility (taken from ranges-v3)
+template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
+template<> struct priority_tag<0> {};
+
+// taken from ranges-v3
+template<typename T>
+struct static_const
+{
+    static JSON_INLINE_VARIABLE constexpr T value{};
+};
+
+#ifndef JSON_HAS_CPP_17
+    template<typename T>
+    constexpr T static_const<T>::value;
+#endif
+
+template<typename T, typename... Args>
+constexpr std::array<T, sizeof...(Args)> make_array(Args&& ... args)
+{
+    return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}};
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <limits> // numeric_limits
+#include <string> // char_traits
+#include <tuple> // tuple
+#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
+#include <utility> // declval
+#if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L
+    #include <cstddef> // byte
+#endif
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <iterator> // random_access_iterator_tag
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename It, typename = void>
+struct iterator_types {};
+
+template<typename It>
+struct iterator_types <
+    It,
+    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
+    typename It::reference, typename It::iterator_category >>
+{
+    using difference_type = typename It::difference_type;
+    using value_type = typename It::value_type;
+    using pointer = typename It::pointer;
+    using reference = typename It::reference;
+    using iterator_category = typename It::iterator_category;
+};
+
+// This is required as some compilers implement std::iterator_traits in a way that
+// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
+template<typename T, typename = void>
+struct iterator_traits
+{
+};
+
+template<typename T>
+struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
+    : iterator_types<T>
+{
+};
+
+template<typename T>
+struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
+{
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = T;
+    using difference_type = ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/call_std/begin.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/call_std/end.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/json_fwd.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
+    #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+    #include <cstdint> // int64_t, uint64_t
+    #include <map> // map
+    #include <memory> // allocator
+    #include <string> // string
+    #include <vector> // vector
+
+    // #include <nlohmann/detail/abi_macros.hpp>
+
+
+    /*!
+    @brief namespace for Niels Lohmann
+    @see https://github.com/nlohmann
+    @since version 1.0.0
+    */
+    NLOHMANN_JSON_NAMESPACE_BEGIN
+
+    /*!
+    @brief default JSONSerializer template argument
+
+    This serializer ignores the template arguments and uses ADL
+    ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
+    for serialization.
+    */
+    template<typename T = void, typename SFINAE = void>
+    struct adl_serializer;
+
+    /// a class to store JSON values
+    /// @sa https://json.nlohmann.me/api/basic_json/
+    template<template<typename U, typename V, typename... Args> class ObjectType =
+    std::map,
+    template<typename U, typename... Args> class ArrayType = std::vector,
+    class StringType = std::string, class BooleanType = bool,
+    class NumberIntegerType = std::int64_t,
+    class NumberUnsignedType = std::uint64_t,
+    class NumberFloatType = double,
+    template<typename U> class AllocatorType = std::allocator,
+    template<typename T, typename SFINAE = void> class JSONSerializer =
+    adl_serializer,
+    class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
+    class CustomBaseClass = void>
+    class basic_json;
+
+    /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+    /// @sa https://json.nlohmann.me/api/json_pointer/
+    template<typename RefStringType>
+    class json_pointer;
+
+    /*!
+    @brief default specialization
+    @sa https://json.nlohmann.me/api/json/
+    */
+    using json = basic_json<>;
+
+    /// @brief a minimal map-like container that preserves insertion order
+    /// @sa https://json.nlohmann.me/api/ordered_map/
+    template<class Key, class T, class IgnoredLess, class Allocator>
+    struct ordered_map;
+
+    /// @brief specialization that maintains the insertion order of object keys
+    /// @sa https://json.nlohmann.me/api/ordered_json/
+    using ordered_json = basic_json<nlohmann::ordered_map>;
+
+    NLOHMANN_JSON_NAMESPACE_END
+
+#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+/*!
+@brief detail namespace with internal helper functions
+
+This namespace collects functions that should not be exposed,
+implementations of some @ref basic_json methods, and meta-programming helpers.
+
+@since version 2.1.0
+*/
+namespace detail
+{
+
+/////////////
+// helpers //
+/////////////
+
+// Note to maintainers:
+//
+// Every trait in this file expects a non-CV-qualified type.
+// The only exceptions are in the 'aliases for detected' section
+// (i.e., those of the form: decltype(T::member_function(std::declval<T>())))
+//
+// In this case, T has to be properly CV-qualified to constraint the function arguments
+// (e.g., to_json(BasicJsonType&, const T&))
+
+template<typename> struct is_basic_json : std::false_type {};
+
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
+
+// used by exceptions create() member functions
+// true_type for the pointer to possibly cv-qualified basic_json or std::nullptr_t
+// false_type otherwise
+template<typename BasicJsonContext>
+struct is_basic_json_context :
+    std::integral_constant < bool,
+    is_basic_json<typename std::remove_cv<typename std::remove_pointer<BasicJsonContext>::type>::type>::value
+    || std::is_same<BasicJsonContext, std::nullptr_t>::value >
+{};
+
+//////////////////////
+// json_ref helpers //
+//////////////////////
+
+template<typename>
+class json_ref;
+
+template<typename>
+struct is_json_ref : std::false_type {};
+
+template<typename T>
+struct is_json_ref<json_ref<T>> : std::true_type {};
+
+//////////////////////////
+// aliases for detected //
+//////////////////////////
+
+template<typename T>
+using mapped_type_t = typename T::mapped_type;
+
+template<typename T>
+using key_type_t = typename T::key_type;
+
+template<typename T>
+using value_type_t = typename T::value_type;
+
+template<typename T>
+using difference_type_t = typename T::difference_type;
+
+template<typename T>
+using pointer_t = typename T::pointer;
+
+template<typename T>
+using reference_t = typename T::reference;
+
+template<typename T>
+using iterator_category_t = typename T::iterator_category;
+
+template<typename T, typename... Args>
+using to_json_function = decltype(T::to_json(std::declval<Args>()...));
+
+template<typename T, typename... Args>
+using from_json_function = decltype(T::from_json(std::declval<Args>()...));
+
+template<typename T, typename U>
+using get_template_function = decltype(std::declval<T>().template get<U>());
+
+// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
+template<typename BasicJsonType, typename T, typename = void>
+struct has_from_json : std::false_type {};
+
+// trait checking if j.get<T> is valid
+// use this trait instead of std::is_constructible or std::is_convertible,
+// both rely on, or make use of implicit conversions, and thus fail when T
+// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
+template <typename BasicJsonType, typename T>
+struct is_getable
+{
+    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
+};
+
+template<typename BasicJsonType, typename T>
+struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, from_json_function, serializer,
+        const BasicJsonType&, T&>::value;
+};
+
+// This trait checks if JSONSerializer<T>::from_json(json const&) exists
+// this overload is used for non-default-constructible user-defined-types
+template<typename BasicJsonType, typename T, typename = void>
+struct has_non_default_from_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<T, from_json_function, serializer,
+        const BasicJsonType&>::value;
+};
+
+// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
+// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
+template<typename BasicJsonType, typename T, typename = void>
+struct has_to_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
+        T>::value;
+};
+
+template<typename T>
+using detect_key_compare = typename T::key_compare;
+
+template<typename T>
+struct has_key_compare : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {};
+
+// obtains the actual object key comparator
+template<typename BasicJsonType>
+struct actual_object_comparator
+{
+    using object_t = typename BasicJsonType::object_t;
+    using object_comparator_t = typename BasicJsonType::default_object_comparator_t;
+    using type = typename std::conditional < has_key_compare<object_t>::value,
+          typename object_t::key_compare, object_comparator_t>::type;
+};
+
+template<typename BasicJsonType>
+using actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type;
+
+/////////////////
+// char_traits //
+/////////////////
+
+// Primary template of char_traits calls std char_traits
+template<typename T>
+struct char_traits : std::char_traits<T>
+{};
+
+// Explicitly define char traits for unsigned char since it is not standard
+template<>
+struct char_traits<unsigned char> : std::char_traits<char>
+{
+    using char_type = unsigned char;
+    using int_type = uint64_t;
+
+    // Redefine to_int_type function
+    static int_type to_int_type(char_type c) noexcept
+    {
+        return static_cast<int_type>(c);
+    }
+
+    static char_type to_char_type(int_type i) noexcept
+    {
+        return static_cast<char_type>(i);
+    }
+
+    static constexpr int_type eof() noexcept
+    {
+        return static_cast<int_type>(std::char_traits<char>::eof());
+    }
+};
+
+// Explicitly define char traits for signed char since it is not standard
+template<>
+struct char_traits<signed char> : std::char_traits<char>
+{
+    using char_type = signed char;
+    using int_type = uint64_t;
+
+    // Redefine to_int_type function
+    static int_type to_int_type(char_type c) noexcept
+    {
+        return static_cast<int_type>(c);
+    }
+
+    static char_type to_char_type(int_type i) noexcept
+    {
+        return static_cast<char_type>(i);
+    }
+
+    static constexpr int_type eof() noexcept
+    {
+        return static_cast<int_type>(std::char_traits<char>::eof());
+    }
+};
+
+#if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L
+template<>
+struct char_traits<std::byte> : std::char_traits<char>
+{
+    using char_type = std::byte;
+    using int_type = uint64_t;
+
+    static int_type to_int_type(char_type c) noexcept
+    {
+        return static_cast<int_type>(std::to_integer<unsigned char>(c));
+    }
+
+    static char_type to_char_type(int_type i) noexcept
+    {
+        return std::byte(static_cast<unsigned char>(i));
+    }
+
+    static constexpr int_type eof() noexcept
+    {
+        return static_cast<int_type>(std::char_traits<char>::eof());
+    }
+};
+#endif
+
+///////////////////
+// is_ functions //
+///////////////////
+
+// https://en.cppreference.com/w/cpp/types/conjunction
+template<class...> struct conjunction : std::true_type { };
+template<class B> struct conjunction<B> : B { };
+template<class B, class... Bn>
+struct conjunction<B, Bn...>
+: std::conditional<static_cast<bool>(B::value), conjunction<Bn...>, B>::type {};
+
+// https://en.cppreference.com/w/cpp/types/negation
+template<class B> struct negation : std::integral_constant < bool, !B::value > { };
+
+// Reimplementation of is_constructible and is_default_constructible, due to them being broken for
+// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
+// This causes compile errors in e.g., Clang 3.5 or GCC 4.9.
+template <typename T>
+struct is_default_constructible : std::is_default_constructible<T> {};
+
+template <typename T1, typename T2>
+struct is_default_constructible<std::pair<T1, T2>>
+    : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+
+template <typename T1, typename T2>
+struct is_default_constructible<const std::pair<T1, T2>>
+    : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+
+template <typename... Ts>
+struct is_default_constructible<std::tuple<Ts...>>
+    : conjunction<is_default_constructible<Ts>...> {};
+
+template <typename... Ts>
+struct is_default_constructible<const std::tuple<Ts...>>
+    : conjunction<is_default_constructible<Ts>...> {};
+
+template <typename T, typename... Args>
+struct is_constructible : std::is_constructible<T, Args...> {};
+
+template <typename T1, typename T2>
+struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
+
+template <typename T1, typename T2>
+struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
+
+template <typename... Ts>
+struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
+
+template <typename... Ts>
+struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
+
+template<typename T, typename = void>
+struct is_iterator_traits : std::false_type {};
+
+template<typename T>
+struct is_iterator_traits<iterator_traits<T>>
+{
+  private:
+    using traits = iterator_traits<T>;
+
+  public:
+    static constexpr auto value =
+        is_detected<value_type_t, traits>::value &&
+        is_detected<difference_type_t, traits>::value &&
+        is_detected<pointer_t, traits>::value &&
+        is_detected<iterator_category_t, traits>::value &&
+        is_detected<reference_t, traits>::value;
+};
+
+template<typename T>
+struct is_range
+{
+  private:
+    using t_ref = typename std::add_lvalue_reference<T>::type;
+
+    using iterator = detected_t<result_of_begin, t_ref>;
+    using sentinel = detected_t<result_of_end, t_ref>;
+
+    // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator
+    // and https://en.cppreference.com/w/cpp/iterator/sentinel_for
+    // but reimplementing these would be too much work, as a lot of other concepts are used underneath
+    static constexpr auto is_iterator_begin =
+        is_iterator_traits<iterator_traits<iterator>>::value;
+
+  public:
+    static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
+};
+
+template<typename R>
+using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
+
+template<typename T>
+using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
+
+// The following implementation of is_complete_type is taken from
+// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
+// and is written by Xiang Fan who agreed to use it in this library.
+
+template<typename T, typename = void>
+struct is_complete_type : std::false_type {};
+
+template<typename T>
+struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType,
+         typename = void>
+struct is_compatible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type_impl <
+    BasicJsonType, CompatibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
+    is_detected<key_type_t, CompatibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    // macOS's is_constructible does not play well with nonesuch...
+    static constexpr bool value =
+        is_constructible<typename object_t::key_type,
+        typename CompatibleObjectType::key_type>::value &&
+        is_constructible<typename object_t::mapped_type,
+        typename CompatibleObjectType::mapped_type>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type
+    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         typename = void>
+struct is_constructible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type_impl <
+    BasicJsonType, ConstructibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
+    is_detected<key_type_t, ConstructibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    static constexpr bool value =
+        (is_default_constructible<ConstructibleObjectType>::value &&
+         (std::is_move_assignable<ConstructibleObjectType>::value ||
+          std::is_copy_assignable<ConstructibleObjectType>::value) &&
+         (is_constructible<typename ConstructibleObjectType::key_type,
+          typename object_t::key_type>::value &&
+          std::is_same <
+          typename object_t::mapped_type,
+          typename ConstructibleObjectType::mapped_type >::value)) ||
+        (has_from_json<BasicJsonType,
+         typename ConstructibleObjectType::mapped_type>::value ||
+         has_non_default_from_json <
+         BasicJsonType,
+         typename ConstructibleObjectType::mapped_type >::value);
+};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type
+    : is_constructible_object_type_impl<BasicJsonType,
+      ConstructibleObjectType> {};
+
+template<typename BasicJsonType, typename CompatibleStringType>
+struct is_compatible_string_type
+{
+    static constexpr auto value =
+        is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type
+{
+    // launder type through decltype() to fix compilation failure on ICPC
+#ifdef __INTEL_COMPILER
+    using laundered_type = decltype(std::declval<ConstructibleStringType>());
+#else
+    using laundered_type = ConstructibleStringType;
+#endif
+
+    static constexpr auto value =
+        conjunction <
+        is_constructible<laundered_type, typename BasicJsonType::string_t>,
+        is_detected_exact<typename BasicJsonType::string_t::value_type,
+        value_type_t, laundered_type >>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
+struct is_compatible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type_impl <
+    BasicJsonType, CompatibleArrayType,
+    enable_if_t <
+    is_detected<iterator_t, CompatibleArrayType>::value&&
+    is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&
+// special case for types like std::filesystem::path whose iterator's value_type are themselves
+// c.f. https://github.com/nlohmann/json/pull/3073
+    !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
+{
+    static constexpr bool value =
+        is_constructible<BasicJsonType,
+        range_value_t<CompatibleArrayType>>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type
+    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
+struct is_constructible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t<std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value >>
+            : std::true_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t < !std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value&&
+    !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+    is_default_constructible<ConstructibleArrayType>::value&&
+(std::is_move_assignable<ConstructibleArrayType>::value ||
+ std::is_copy_assignable<ConstructibleArrayType>::value)&&
+is_detected<iterator_t, ConstructibleArrayType>::value&&
+is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
+is_detected<range_value_t, ConstructibleArrayType>::value&&
+// special case for types like std::filesystem::path whose iterator's value_type are themselves
+// c.f. https://github.com/nlohmann/json/pull/3073
+!std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
+is_complete_type <
+detected_t<range_value_t, ConstructibleArrayType >>::value >>
+{
+    using value_type = range_value_t<ConstructibleArrayType>;
+
+    static constexpr bool value =
+        std::is_same<value_type,
+        typename BasicJsonType::array_t::value_type>::value ||
+        has_from_json<BasicJsonType,
+        value_type>::value ||
+        has_non_default_from_json <
+        BasicJsonType,
+        value_type >::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type
+    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType,
+         typename = void>
+struct is_compatible_integer_type_impl : std::false_type {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type_impl <
+    RealIntegerType, CompatibleNumberIntegerType,
+    enable_if_t < std::is_integral<RealIntegerType>::value&&
+    std::is_integral<CompatibleNumberIntegerType>::value&&
+    !std::is_same<bool, CompatibleNumberIntegerType>::value >>
+{
+    // is there an assert somewhere on overflows?
+    using RealLimits = std::numeric_limits<RealIntegerType>;
+    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
+
+    static constexpr auto value =
+        is_constructible<RealIntegerType,
+        CompatibleNumberIntegerType>::value &&
+        CompatibleLimits::is_integer &&
+        RealLimits::is_signed == CompatibleLimits::is_signed;
+};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type
+    : is_compatible_integer_type_impl<RealIntegerType,
+      CompatibleNumberIntegerType> {};
+
+template<typename BasicJsonType, typename CompatibleType, typename = void>
+struct is_compatible_type_impl: std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type_impl <
+    BasicJsonType, CompatibleType,
+    enable_if_t<is_complete_type<CompatibleType>::value >>
+{
+    static constexpr bool value =
+        has_to_json<BasicJsonType, CompatibleType>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type
+    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
+
+template<typename T1, typename T2>
+struct is_constructible_tuple : std::false_type {};
+
+template<typename T1, typename... Args>
+struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
+
+template<typename BasicJsonType, typename T>
+struct is_json_iterator_of : std::false_type {};
+
+template<typename BasicJsonType>
+struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::iterator> : std::true_type {};
+
+template<typename BasicJsonType>
+struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::const_iterator> : std::true_type
+{};
+
+// checks if a given type T is a template specialization of Primary
+template<template <typename...> class Primary, typename T>
+struct is_specialization_of : std::false_type {};
+
+template<template <typename...> class Primary, typename... Args>
+struct is_specialization_of<Primary, Primary<Args...>> : std::true_type {};
+
+template<typename T>
+using is_json_pointer = is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>;
+
+// checks if A and B are comparable using Compare functor
+template<typename Compare, typename A, typename B, typename = void>
+struct is_comparable : std::false_type {};
+
+template<typename Compare, typename A, typename B>
+struct is_comparable<Compare, A, B, void_t<
+decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>())),
+decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>()))
+>> : std::true_type {};
+
+template<typename T>
+using detect_is_transparent = typename T::is_transparent;
+
+// type trait to check if KeyType can be used as an object key (without a BasicJsonType)
+// see is_usable_as_basic_json_key_type below
+template<typename Comparator, typename ObjectKeyType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
+         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
+using is_usable_as_key_type = typename std::conditional <
+                              is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value
+                              && !(ExcludeObjectKeyType && std::is_same<KeyType,
+                                   ObjectKeyType>::value)
+                              && (!RequireTransparentComparator
+                                  || is_detected <detect_is_transparent, Comparator>::value)
+                              && !is_json_pointer<KeyType>::value,
+                              std::true_type,
+                              std::false_type >::type;
+
+// type trait to check if KeyType can be used as an object key
+// true if:
+//   - KeyType is comparable with BasicJsonType::object_t::key_type
+//   - if ExcludeObjectKeyType is true, KeyType is not BasicJsonType::object_t::key_type
+//   - the comparator is transparent or RequireTransparentComparator is false
+//   - KeyType is not a JSON iterator or json_pointer
+template<typename BasicJsonType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
+         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
+using is_usable_as_basic_json_key_type = typename std::conditional <
+    is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
+    typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
+    RequireTransparentComparator, ExcludeObjectKeyType>::value
+    && !is_json_iterator_of<BasicJsonType, KeyType>::value,
+    std::true_type,
+    std::false_type >::type;
+
+template<typename ObjectType, typename KeyType>
+using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()));
+
+// type trait to check if object_t has an erase() member functions accepting KeyType
+template<typename BasicJsonType, typename KeyType>
+using has_erase_with_key_type = typename std::conditional <
+                                is_detected <
+                                detect_erase_with_key_type,
+                                typename BasicJsonType::object_t, KeyType >::value,
+                                std::true_type,
+                                std::false_type >::type;
+
+// a naive helper to check if a type is an ordered_map (exploits the fact that
+// ordered_map inherits capacity() from std::vector)
+template <typename T>
+struct is_ordered_map
+{
+    using one = char;
+
+    struct two
+    {
+        char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+    };
+
+    template <typename C> static one test( decltype(&C::capacity) ) ;
+    template <typename C> static two test(...);
+
+    enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+};
+
+// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
+template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
+T conditional_static_cast(U value)
+{
+    return static_cast<T>(value);
+}
+
+template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
+T conditional_static_cast(U value)
+{
+    return value;
+}
+
+template<typename... Types>
+using all_integral = conjunction<std::is_integral<Types>...>;
+
+template<typename... Types>
+using all_signed = conjunction<std::is_signed<Types>...>;
+
+template<typename... Types>
+using all_unsigned = conjunction<std::is_unsigned<Types>...>;
+
+// there's a disjunction trait in another PR; replace when merged
+template<typename... Types>
+using same_sign = std::integral_constant < bool,
+      all_signed<Types...>::value || all_unsigned<Types...>::value >;
+
+template<typename OfType, typename T>
+using never_out_of_range = std::integral_constant < bool,
+      (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType)))
+      || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) >;
+
+template<typename OfType, typename T,
+         bool OfTypeSigned = std::is_signed<OfType>::value,
+         bool TSigned = std::is_signed<T>::value>
+struct value_in_range_of_impl2;
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, false, false>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, true, false>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, false, true>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return val >= 0 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, true, true>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) >= static_cast<CommonType>((std::numeric_limits<OfType>::min)())
+               && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T,
+         bool NeverOutOfRange = never_out_of_range<OfType, T>::value,
+         typename = detail::enable_if_t<all_integral<OfType, T>::value>>
+struct value_in_range_of_impl1;
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl1<OfType, T, false>
+{
+    static constexpr bool test(T val)
+    {
+        return value_in_range_of_impl2<OfType, T>::test(val);
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl1<OfType, T, true>
+{
+    static constexpr bool test(T /*val*/)
+    {
+        return true;
+    }
+};
+
+template<typename OfType, typename T>
+constexpr bool value_in_range_of(T val)
+{
+    return value_in_range_of_impl1<OfType, T>::test(val);
+}
+
+template<bool Value>
+using bool_constant = std::integral_constant<bool, Value>;
+
+///////////////////////////////////////////////////////////////////////////////
+// is_c_string
+///////////////////////////////////////////////////////////////////////////////
+
+namespace impl
+{
+
+template<typename T>
+constexpr bool is_c_string()
+{
+    using TUnExt = typename std::remove_extent<T>::type;
+    using TUnCVExt = typename std::remove_cv<TUnExt>::type;
+    using TUnPtr = typename std::remove_pointer<T>::type;
+    using TUnCVPtr = typename std::remove_cv<TUnPtr>::type;
+    return
+        (std::is_array<T>::value && std::is_same<TUnCVExt, char>::value)
+        || (std::is_pointer<T>::value && std::is_same<TUnCVPtr, char>::value);
+}
+
+}  // namespace impl
+
+// checks whether T is a [cv] char */[cv] char[] C string
+template<typename T>
+struct is_c_string : bool_constant<impl::is_c_string<T>()> {};
+
+template<typename T>
+using is_c_string_uncvref = is_c_string<uncvref_t<T>>;
+
+///////////////////////////////////////////////////////////////////////////////
+// is_transparent
+///////////////////////////////////////////////////////////////////////////////
+
+namespace impl
+{
+
+template<typename T>
+constexpr bool is_transparent()
+{
+    return is_detected<detect_is_transparent, T>::value;
+}
+
+}  // namespace impl
+
+// checks whether T has a member named is_transparent
+template<typename T>
+struct is_transparent : bool_constant<impl::is_transparent<T>()> {};
+
+///////////////////////////////////////////////////////////////////////////////
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/string_concat.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstring> // strlen
+#include <string> // string
+#include <utility> // forward
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+inline std::size_t concat_length()
+{
+    return 0;
+}
+
+template<typename... Args>
+inline std::size_t concat_length(const char* cstr, const Args& ... rest);
+
+template<typename StringType, typename... Args>
+inline std::size_t concat_length(const StringType& str, const Args& ... rest);
+
+template<typename... Args>
+inline std::size_t concat_length(const char /*c*/, const Args& ... rest)
+{
+    return 1 + concat_length(rest...);
+}
+
+template<typename... Args>
+inline std::size_t concat_length(const char* cstr, const Args& ... rest)
+{
+    // cppcheck-suppress ignoredReturnValue
+    return ::strlen(cstr) + concat_length(rest...);
+}
+
+template<typename StringType, typename... Args>
+inline std::size_t concat_length(const StringType& str, const Args& ... rest)
+{
+    return str.size() + concat_length(rest...);
+}
+
+template<typename OutStringType>
+inline void concat_into(OutStringType& /*out*/)
+{}
+
+template<typename StringType, typename Arg>
+using string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg && > ()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append = is_detected<string_can_append, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg && > ());
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_op = is_detected<string_can_append_op, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_iter = is_detected<string_can_append_iter, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_data = is_detected<string_can_append_data, StringType, Arg>;
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && detect_string_can_append_op<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest);
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && !detect_string_can_append_iter<OutStringType, Arg>::value
+                         && detect_string_can_append_data<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
+
+template<typename OutStringType, typename Arg, typename... Args,
+         enable_if_t<detect_string_can_append<OutStringType, Arg>::value, int> = 0>
+inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest)
+{
+    out.append(std::forward<Arg>(arg));
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && detect_string_can_append_op<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, Arg&& arg, Args&& ... rest)
+{
+    out += std::forward<Arg>(arg);
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
+{
+    out.append(arg.begin(), arg.end());
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && !detect_string_can_append_iter<OutStringType, Arg>::value
+                         && detect_string_can_append_data<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
+{
+    out.append(arg.data(), arg.size());
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template<typename OutStringType = std::string, typename... Args>
+inline OutStringType concat(Args && ... args)
+{
+    OutStringType str;
+    str.reserve(concat_length(args...));
+    concat_into(str, std::forward<Args>(args)...);
+    return str;
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+
+// With -Wweak-vtables, Clang will complain about the exception classes as they
+// have no out-of-line virtual method definitions and their vtable will be
+// emitted in every translation unit. This issue cannot be fixed with a
+// header-only library as there is no implementation file to move these
+// functions to. As a result, we suppress this warning here to avoid client
+// code stumbling over this. See https://github.com/nlohmann/json/issues/4087
+// for a discussion.
+#if defined(__clang__)
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+////////////////
+// exceptions //
+////////////////
+
+/// @brief general exception of the @ref basic_json class
+/// @sa https://json.nlohmann.me/api/basic_json/exception/
+class exception : public std::exception
+{
+  public:
+    /// returns the explanatory string
+    const char* what() const noexcept override
+    {
+        return m.what();
+    }
+
+    /// the id of the exception
+    const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
+
+  protected:
+    JSON_HEDLEY_NON_NULL(3)
+    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
+
+    static std::string name(const std::string& ename, int id_)
+    {
+        return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
+    }
+
+    static std::string diagnostics(std::nullptr_t /*leaf_element*/)
+    {
+        return "";
+    }
+
+    template<typename BasicJsonType>
+    static std::string diagnostics(const BasicJsonType* leaf_element)
+    {
+#if JSON_DIAGNOSTICS
+        std::vector<std::string> tokens;
+        for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent)
+        {
+            switch (current->m_parent->type())
+            {
+                case value_t::array:
+                {
+                    for (std::size_t i = 0; i < current->m_parent->m_data.m_value.array->size(); ++i)
+                    {
+                        if (&current->m_parent->m_data.m_value.array->operator[](i) == current)
+                        {
+                            tokens.emplace_back(std::to_string(i));
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                case value_t::object:
+                {
+                    for (const auto& element : *current->m_parent->m_data.m_value.object)
+                    {
+                        if (&element.second == current)
+                        {
+                            tokens.emplace_back(element.first.c_str());
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                case value_t::null: // LCOV_EXCL_LINE
+                case value_t::string: // LCOV_EXCL_LINE
+                case value_t::boolean: // LCOV_EXCL_LINE
+                case value_t::number_integer: // LCOV_EXCL_LINE
+                case value_t::number_unsigned: // LCOV_EXCL_LINE
+                case value_t::number_float: // LCOV_EXCL_LINE
+                case value_t::binary: // LCOV_EXCL_LINE
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:   // LCOV_EXCL_LINE
+                    break; // LCOV_EXCL_LINE
+            }
+        }
+
+        if (tokens.empty())
+        {
+            return "";
+        }
+
+        auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
+                                   [](const std::string & a, const std::string & b)
+        {
+            return concat(a, '/', detail::escape(b));
+        });
+
+        return concat('(', str, ") ", get_byte_positions(leaf_element));
+#else
+        return get_byte_positions(leaf_element);
+#endif
+    }
+
+  private:
+    /// an exception object as storage for error messages
+    std::runtime_error m;
+#if JSON_DIAGNOSTIC_POSITIONS
+    template<typename BasicJsonType>
+    static std::string get_byte_positions(const BasicJsonType* leaf_element)
+    {
+        if ((leaf_element->start_pos() != std::string::npos) && (leaf_element->end_pos() != std::string::npos))
+        {
+            return concat("(bytes ", std::to_string(leaf_element->start_pos()), "-", std::to_string(leaf_element->end_pos()), ") ");
+        }
+        return "";
+    }
+#else
+    template<typename BasicJsonType>
+    static std::string get_byte_positions(const BasicJsonType* leaf_element)
+    {
+        static_cast<void>(leaf_element);
+        return "";
+    }
+#endif
+};
+
+/// @brief exception indicating a parse error
+/// @sa https://json.nlohmann.me/api/basic_json/parse_error/
+class parse_error : public exception
+{
+  public:
+    /*!
+    @brief create a parse error exception
+    @param[in] id_       the id of the exception
+    @param[in] pos       the position where the error occurred (or with
+                         chars_read_total=0 if the position cannot be
+                         determined)
+    @param[in] what_arg  the explanatory string
+    @return parse_error object
+    */
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("parse_error", id_), "parse error",
+                                     position_string(pos), ": ", exception::diagnostics(context), what_arg);
+        return {id_, pos.chars_read_total, w.c_str()};
+    }
+
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("parse_error", id_), "parse error",
+                                     (byte_ != 0 ? (concat(" at byte ", std::to_string(byte_))) : ""),
+                                     ": ", exception::diagnostics(context), what_arg);
+        return {id_, byte_, w.c_str()};
+    }
+
+    /*!
+    @brief byte index of the parse error
+
+    The byte index of the last read character in the input file.
+
+    @note For an input with n bytes, 1 is the index of the first character and
+          n+1 is the index of the terminating null byte or the end of file.
+          This also holds true when reading a byte vector (CBOR or MessagePack).
+    */
+    const std::size_t byte;
+
+  private:
+    parse_error(int id_, std::size_t byte_, const char* what_arg)
+        : exception(id_, what_arg), byte(byte_) {}
+
+    static std::string position_string(const position_t& pos)
+    {
+        return concat(" at line ", std::to_string(pos.lines_read + 1),
+                      ", column ", std::to_string(pos.chars_read_current_line));
+    }
+};
+
+/// @brief exception indicating errors with iterators
+/// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/
+class invalid_iterator : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    invalid_iterator(int id_, const char* what_arg)
+        : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating executing a member function with a wrong type
+/// @sa https://json.nlohmann.me/api/basic_json/type_error/
+class type_error : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating access out of the defined range
+/// @sa https://json.nlohmann.me/api/basic_json/out_of_range/
+class out_of_range : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating other library errors
+/// @sa https://json.nlohmann.me/api/basic_json/other_error/
+class other_error : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static other_error create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/identity_tag.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// dispatching helper struct
+template <class T> struct identity_tag {};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/std_fs.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
+#include <experimental/filesystem>
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace std_fs = std::experimental::filesystem;
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+#elif JSON_HAS_FILESYSTEM
+#include <filesystem> // NOLINT(build/c++17)
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace std_fs = std::filesystem;
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+#endif
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+// include after macro_scope.hpp
+#ifdef JSON_HAS_CPP_17
+    #include <optional> // optional
+#endif
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+    #include <string_view> // u8string_view
+#endif
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be null, but is ", j.type_name()), &j));
+    }
+    n = nullptr;
+}
+
+#ifdef JSON_HAS_CPP_17
+template<typename BasicJsonType, typename T>
+void from_json(const BasicJsonType& j, std::optional<T>& opt)
+{
+    if (j.is_null())
+    {
+        opt = std::nullopt;
+    }
+    else
+    {
+        opt.emplace(j.template get<T>());
+    }
+}
+#endif // JSON_HAS_CPP_17
+
+// overloads for basic_json template parameters
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
+                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+                         int > = 0 >
+void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+
+        case value_t::null:
+        case value_t::object:
+        case value_t::array:
+        case value_t::string:
+        case value_t::boolean:
+        case value_t::binary:
+        case value_t::discarded:
+        default:
+            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
+    }
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
+    }
+    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template <
+    typename BasicJsonType, typename StringType,
+    enable_if_t <
+        std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value
+        && is_detected_exact<typename BasicJsonType::string_t::value_type, value_type_t, StringType>::value
+        && !std::is_same<typename BasicJsonType::string_t, StringType>::value
+        && !is_json_ref<StringType>::value, int > = 0 >
+inline void from_json(const BasicJsonType& j, StringType& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+#if !JSON_DISABLE_ENUM_SERIALIZATION
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, EnumType& e)
+{
+    typename std::underlying_type<EnumType>::type val;
+    get_arithmetic_value(j, val);
+    e = static_cast<EnumType>(val);
+}
+#endif  // JSON_DISABLE_ENUM_SERIALIZATION
+
+// forward_list doesn't have an insert method
+template<typename BasicJsonType, typename T, typename Allocator,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    l.clear();
+    std::transform(j.rbegin(), j.rend(),
+                   std::front_inserter(l), [](const BasicJsonType & i)
+    {
+        return i.template get<T>();
+    });
+}
+
+// valarray doesn't have an insert method
+template<typename BasicJsonType, typename T,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    l.resize(j.size());
+    std::transform(j.begin(), j.end(), std::begin(l),
+                   [](const BasicJsonType & elem)
+    {
+        return elem.template get<T>();
+    });
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType, typename T, std::size_t N1, std::size_t N2>
+auto from_json(const BasicJsonType& j, T (&arr)[N1][N2])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i1 = 0; i1 < N1; ++i1)
+    {
+        for (std::size_t i2 = 0; i2 < N2; ++i2)
+        {
+            arr[i1][i2] = j.at(i1).at(i2).template get<T>();
+        }
+    }
+}
+
+template<typename BasicJsonType, typename T, std::size_t N1, std::size_t N2, std::size_t N3>
+auto from_json(const BasicJsonType& j, T (&arr)[N1][N2][N3])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i1 = 0; i1 < N1; ++i1)
+    {
+        for (std::size_t i2 = 0; i2 < N2; ++i2)
+        {
+            for (std::size_t i3 = 0; i3 < N3; ++i3)
+            {
+                arr[i1][i2][i3] = j.at(i1).at(i2).at(i3).template get<T>();
+            }
+        }
+    }
+}
+
+template<typename BasicJsonType, typename T, std::size_t N1, std::size_t N2, std::size_t N3, std::size_t N4>
+auto from_json(const BasicJsonType& j, T (&arr)[N1][N2][N3][N4])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i1 = 0; i1 < N1; ++i1)
+    {
+        for (std::size_t i2 = 0; i2 < N2; ++i2)
+        {
+            for (std::size_t i3 = 0; i3 < N3; ++i3)
+            {
+                for (std::size_t i4 = 0; i4 < N4; ++i4)
+                {
+                    arr[i1][i2][i3][i4] = j.at(i1).at(i2).at(i3).at(i4).template get<T>();
+                }
+            }
+        }
+    }
+}
+
+template<typename BasicJsonType>
+inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
+{
+    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
+                          priority_tag<2> /*unused*/)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType,
+         enable_if_t<
+             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
+             int> = 0>
+auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
+-> decltype(
+    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
+    j.template get<typename ConstructibleArrayType::value_type>(),
+    void())
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    ret.reserve(j.size());
+    std::transform(j.begin(), j.end(),
+                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType,
+         enable_if_t<
+             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
+             int> = 0>
+inline void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
+                                 priority_tag<0> /*unused*/)
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    std::transform(
+        j.begin(), j.end(), std::inserter(ret, end(ret)),
+        [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template < typename BasicJsonType, typename ConstructibleArrayType,
+           enable_if_t <
+               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
+               !is_basic_json<ConstructibleArrayType>::value,
+               int > = 0 >
+auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
+-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
+j.template get<typename ConstructibleArrayType::value_type>(),
+void())
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    from_json_array_impl(j, arr, priority_tag<3> {});
+}
+
+template < typename BasicJsonType, typename T, std::size_t... Idx >
+std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
+                     identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
+{
+    return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
+}
+
+template < typename BasicJsonType, typename T, std::size_t N >
+auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
+-> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be binary, but is ", j.type_name()), &j));
+    }
+
+    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
+}
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be object, but is ", j.type_name()), &j));
+    }
+
+    ConstructibleObjectType ret;
+    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
+    using value_type = typename ConstructibleObjectType::value_type;
+    std::transform(
+        inner_object->begin(), inner_object->end(),
+        std::inserter(ret, ret.begin()),
+        [](typename BasicJsonType::object_t::value_type const & p)
+    {
+        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
+    });
+    obj = std::move(ret);
+}
+
+// overload for arithmetic types, not chosen for basic_json template arguments
+// (BooleanType, etc.); note: Is it really necessary to provide explicit
+// overloads for boolean_t etc. in case of a custom BooleanType which is not
+// an arithmetic type?
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t <
+               std::is_arithmetic<ArithmeticType>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+               int > = 0 >
+inline void from_json(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+        case value_t::boolean:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
+            break;
+        }
+
+        case value_t::null:
+        case value_t::object:
+        case value_t::array:
+        case value_t::string:
+        case value_t::binary:
+        case value_t::discarded:
+        default:
+            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
+    }
+}
+
+template<typename BasicJsonType, typename... Args, std::size_t... Idx>
+std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
+{
+    return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
+}
+
+template<typename BasicJsonType>
+std::tuple<> from_json_tuple_impl_base(BasicJsonType& /*unused*/, index_sequence<> /*unused*/)
+{
+    return {};
+}
+
+template < typename BasicJsonType, class A1, class A2 >
+std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
+{
+    return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
+            std::forward<BasicJsonType>(j).at(1).template get<A2>()};
+}
+
+template<typename BasicJsonType, typename A1, typename A2>
+inline void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
+{
+    p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
+}
+
+template<typename BasicJsonType, typename... Args>
+std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
+{
+    return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+}
+
+template<typename BasicJsonType, typename... Args>
+inline void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
+{
+    t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+}
+
+template<typename BasicJsonType, typename TupleRelated>
+auto from_json(BasicJsonType&& j, TupleRelated&& t)
+-> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+inline void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+inline void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, std_fs::path& p)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+    const auto& s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+    // Checking for C++20 standard or later can be insufficient in case the
+    // library support for char8_t is either incomplete or was disabled
+    // altogether. Use the __cpp_lib_char8_t feature test instead.
+#if defined(__cpp_lib_char8_t) && (__cpp_lib_char8_t >= 201907L)
+    p = std_fs::path(std::u8string_view(reinterpret_cast<const char8_t*>(s.data()), s.size()));
+#else
+    p = std_fs::u8path(s); // accepts UTF-8 encoded std::string in C++17, deprecated in C++20
+#endif
+}
+#endif
+
+struct from_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(const BasicJsonType& j, T&& val) const
+    noexcept(noexcept(from_json(j, std::forward<T>(val))))
+    -> decltype(from_json(j, std::forward<T>(val)))
+    {
+        return from_json(j, std::forward<T>(val));
+    }
+};
+
+}  // namespace detail
+
+#ifndef JSON_HAS_CPP_17
+/// namespace to hold default `from_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+{
+#endif
+JSON_INLINE_VARIABLE constexpr const auto& from_json = // NOLINT(misc-definitions-in-headers)
+    detail::static_const<detail::from_json_fn>::value;
+#ifndef JSON_HAS_CPP_17
+}  // namespace
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+// JSON_HAS_CPP_17
+#ifdef JSON_HAS_CPP_17
+    #include <optional> // optional
+#endif
+
+#include <algorithm> // copy
+#include <iterator> // begin, end
+#include <memory> // allocator_traits
+#include <string> //  basic_string, char_traits
+#include <tuple> // tuple, get
+#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
+#include <utility> // move, forward, declval, pair
+#include <valarray> // valarray
+#include <vector> // vector
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // size_t
+#include <iterator> // forward_iterator_tag
+#include <tuple> // tuple_size, get, tuple_element
+#include <utility> // move
+
+#if JSON_HAS_RANGES
+    #include <ranges> // enable_borrowed_range
+#endif
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/string_utils.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // size_t
+#include <string> // string, to_string
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename StringType>
+void int_to_string(StringType& target, std::size_t value)
+{
+    // For ADL
+    using std::to_string;
+    target = to_string(value);
+}
+
+template<typename StringType>
+StringType to_string(std::size_t value)
+{
+    StringType result;
+    int_to_string(result, value);
+    return result;
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename IteratorType> class iteration_proxy_value
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    using value_type = iteration_proxy_value;
+    using pointer = value_type *;
+    using reference = value_type &;
+    using iterator_category = std::forward_iterator_tag;
+    using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
+
+  private:
+    /// the iterator
+    IteratorType anchor{};
+    /// an index for arrays (used to create key names)
+    std::size_t array_index = 0;
+    /// last stringified array index
+    mutable std::size_t array_index_last = 0;
+    /// a string representation of the array index
+    mutable string_type array_index_str = "0";
+    /// an empty string (to return a reference for primitive values)
+    string_type empty_str{};
+
+  public:
+    explicit iteration_proxy_value() = default;
+    explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
+    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
+             && std::is_nothrow_default_constructible<string_type>::value)
+        : anchor(std::move(it))
+        , array_index(array_index_)
+    {}
+
+    iteration_proxy_value(iteration_proxy_value const&) = default;
+    iteration_proxy_value& operator=(iteration_proxy_value const&) = default;
+    // older GCCs are a bit fussy and require explicit noexcept specifiers on defaulted functions
+    iteration_proxy_value(iteration_proxy_value&&)
+    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
+             && std::is_nothrow_move_constructible<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
+    iteration_proxy_value& operator=(iteration_proxy_value&&)
+    noexcept(std::is_nothrow_move_assignable<IteratorType>::value
+             && std::is_nothrow_move_assignable<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
+    ~iteration_proxy_value() = default;
+
+    /// dereference operator (needed for range-based for)
+    const iteration_proxy_value& operator*() const
+    {
+        return *this;
+    }
+
+    /// increment operator (needed for range-based for)
+    iteration_proxy_value& operator++()
+    {
+        ++anchor;
+        ++array_index;
+
+        return *this;
+    }
+
+    iteration_proxy_value operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto tmp = iteration_proxy_value(anchor, array_index);
+        ++anchor;
+        ++array_index;
+        return tmp;
+    }
+
+    /// equality operator (needed for InputIterator)
+    bool operator==(const iteration_proxy_value& o) const
+    {
+        return anchor == o.anchor;
+    }
+
+    /// inequality operator (needed for range-based for)
+    bool operator!=(const iteration_proxy_value& o) const
+    {
+        return anchor != o.anchor;
+    }
+
+    /// return key of the iterator
+    const string_type& key() const
+    {
+        JSON_ASSERT(anchor.m_object != nullptr);
+
+        switch (anchor.m_object->type())
+        {
+            // use integer array index as key
+            case value_t::array:
+            {
+                if (array_index != array_index_last)
+                {
+                    int_to_string( array_index_str, array_index );
+                    array_index_last = array_index;
+                }
+                return array_index_str;
+            }
+
+            // use key from the object
+            case value_t::object:
+                return anchor.key();
+
+            // use an empty key for all primitive types
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return empty_str;
+        }
+    }
+
+    /// return value of the iterator
+    typename IteratorType::reference value() const
+    {
+        return anchor.value();
+    }
+};
+
+/// proxy class for the items() function
+template<typename IteratorType> class iteration_proxy
+{
+  private:
+    /// the container to iterate
+    typename IteratorType::pointer container = nullptr;
+
+  public:
+    explicit iteration_proxy() = default;
+
+    /// construct iteration proxy from a container
+    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
+        : container(&cont) {}
+
+    iteration_proxy(iteration_proxy const&) = default;
+    iteration_proxy& operator=(iteration_proxy const&) = default;
+    iteration_proxy(iteration_proxy&&) noexcept = default;
+    iteration_proxy& operator=(iteration_proxy&&) noexcept = default;
+    ~iteration_proxy() = default;
+
+    /// return iterator begin (needed for range-based for)
+    iteration_proxy_value<IteratorType> begin() const noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container->begin());
+    }
+
+    /// return iterator end (needed for range-based for)
+    iteration_proxy_value<IteratorType> end() const noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container->end());
+    }
+};
+
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
+{
+    return i.key();
+}
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
+{
+    return i.value();
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// The Addition to the STD Namespace is required to add
+// Structured Bindings Support to the iteration_proxy_value class
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+namespace std
+{
+
+#if defined(__clang__)
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+template<typename IteratorType>
+class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
+    : public std::integral_constant<std::size_t, 2> {};
+
+template<std::size_t N, typename IteratorType>
+class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >> // NOLINT(cert-dcl58-cpp)
+{
+  public:
+    using type = decltype(
+                     get<N>(std::declval <
+                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
+};
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+}  // namespace std
+
+#if JSON_HAS_RANGES
+    template <typename IteratorType>
+    inline constexpr bool ::std::ranges::enable_borrowed_range<::nlohmann::detail::iteration_proxy<IteratorType>> = true;
+#endif
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/std_fs.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+//////////////////
+// constructors //
+//////////////////
+
+/*
+ * Note all external_constructor<>::construct functions need to call
+ * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an
+ * allocated value (e.g., a string). See bug issue
+ * https://github.com/nlohmann/json/issues/2865 for more information.
+ */
+
+template<value_t> struct external_constructor;
+
+template<>
+struct external_constructor<value_t::boolean>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::boolean;
+        j.m_data.m_value = b;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::string>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value = s;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value = std::move(s);
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleStringType,
+               enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleStringType& str)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::binary>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::binary;
+        j.m_data.m_value = typename BasicJsonType::binary_t(b);
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::binary;
+        j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_float>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_float;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_unsigned>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_unsigned;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_integer>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_integer;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::array>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = arr;
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = std::move(arr);
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleArrayType,
+               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->reserve(arr.size());
+        for (const bool x : arr)
+        {
+            j.m_data.m_value.array->push_back(x);
+            j.set_parent(j.m_data.m_value.array->back());
+        }
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename T,
+             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->resize(arr.size());
+        if (arr.size() > 0)
+        {
+            std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin());
+        }
+        j.set_parents();
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::object>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value = obj;
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value = std::move(obj);
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleObjectType,
+               enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
+        j.set_parents();
+        j.assert_invariant();
+    }
+};
+
+/////////////
+// to_json //
+/////////////
+
+#ifdef JSON_HAS_CPP_17
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_constructible<BasicJsonType, T>::value, int> = 0>
+void to_json(BasicJsonType& j, const std::optional<T>& opt) noexcept
+{
+    if (opt.has_value())
+    {
+        j = *opt;
+    }
+    else
+    {
+        j = nullptr;
+    }
+}
+#endif
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
+inline void to_json(BasicJsonType& j, T b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, b);
+}
+
+template < typename BasicJsonType, typename BoolRef,
+           enable_if_t <
+               ((std::is_same<std::vector<bool>::reference, BoolRef>::value
+                 && !std::is_same <std::vector<bool>::reference, typename BasicJsonType::boolean_t&>::value)
+                || (std::is_same<std::vector<bool>::const_reference, BoolRef>::value
+                    && !std::is_same <detail::uncvref_t<std::vector<bool>::const_reference>,
+                                      typename BasicJsonType::boolean_t >::value))
+               && std::is_convertible<const BoolRef&, typename BasicJsonType::boolean_t>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const BoolRef& b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, static_cast<typename BasicJsonType::boolean_t>(b));
+}
+
+template<typename BasicJsonType, typename CompatibleString,
+         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const CompatibleString& s)
+{
+    external_constructor<value_t::string>::construct(j, s);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+{
+    external_constructor<value_t::string>::construct(j, std::move(s));
+}
+
+template<typename BasicJsonType, typename FloatType,
+         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, FloatType val) noexcept
+{
+    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
+{
+    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberIntegerType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
+{
+    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
+}
+
+#if !JSON_DISABLE_ENUM_SERIALIZATION
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, EnumType e) noexcept
+{
+    using underlying_type = typename std::underlying_type<EnumType>::type;
+    static constexpr value_t integral_value_t = std::is_unsigned<underlying_type>::value ? value_t::number_unsigned : value_t::number_integer;
+    external_constructor<integral_value_t>::construct(j, static_cast<underlying_type>(e));
+}
+#endif  // JSON_DISABLE_ENUM_SERIALIZATION
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const std::vector<bool>& e)
+{
+    external_constructor<value_t::array>::construct(j, e);
+}
+
+template < typename BasicJsonType, typename CompatibleArrayType,
+           enable_if_t < is_compatible_array_type<BasicJsonType,
+                         CompatibleArrayType>::value&&
+                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
+                         !is_basic_json<CompatibleArrayType>::value,
+                         int > = 0 >
+inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
+{
+    external_constructor<value_t::binary>::construct(j, bin);
+}
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template < typename BasicJsonType, typename CompatibleObjectType,
+           enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
+{
+    external_constructor<value_t::object>::construct(j, obj);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+{
+    external_constructor<value_t::object>::construct(j, std::move(obj));
+}
+
+template <
+    typename BasicJsonType, typename T, std::size_t N,
+    enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
+                  const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+                  int > = 0 >
+inline void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
+{
+    j = { p.first, p.second };
+}
+
+// for https://github.com/nlohmann/json/pull/1134
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const T& b)
+{
+    j = { {b.key(), b.value()} };
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    j = { std::get<Idx>(t)... };
+}
+
+template<typename BasicJsonType, typename Tuple>
+inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& /*unused*/, index_sequence<> /*unused*/)
+{
+    using array_t = typename BasicJsonType::array_t;
+    j = array_t();
+}
+
+template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
+inline void to_json(BasicJsonType& j, const T& t)
+{
+    to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
+}
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+#if defined(__cpp_lib_char8_t)
+template<typename BasicJsonType, typename Tr, typename Allocator>
+inline void to_json(BasicJsonType& j, const std::basic_string<char8_t, Tr, Allocator>& s)
+{
+    using OtherAllocator = typename std::allocator_traits<Allocator>::template rebind_alloc<char>;
+    j = std::basic_string<char, std::char_traits<char>, OtherAllocator>(s.begin(), s.end(), s.get_allocator());
+}
+#endif
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const std_fs::path& p)
+{
+    // Returns either a std::string or a std::u8string depending whether library
+    // support for char8_t is enabled.
+    j = p.u8string();
+}
+#endif
+
+struct to_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
+    -> decltype(to_json(j, std::forward<T>(val)), void())
+    {
+        return to_json(j, std::forward<T>(val));
+    }
+};
+}  // namespace detail
+
+#ifndef JSON_HAS_CPP_17
+/// namespace to hold default `to_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+{
+#endif
+JSON_INLINE_VARIABLE constexpr const auto& to_json = // NOLINT(misc-definitions-in-headers)
+    detail::static_const<detail::to_json_fn>::value;
+#ifndef JSON_HAS_CPP_17
+}  // namespace
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/identity_tag.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @sa https://json.nlohmann.me/api/adl_serializer/
+template<typename ValueType, typename>
+struct adl_serializer
+{
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
+        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
+    {
+        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
+    }
+
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j) noexcept(
+    noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
+    {
+        return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
+    }
+
+    /// @brief convert any value type to a JSON value
+    /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
+        noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
+    -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
+    {
+        ::nlohmann::to_json(j, std::forward<TargetType>(val));
+    }
+};
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/byte_container_with_subtype.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstdint> // uint8_t, uint64_t
+#include <tuple> // tie
+#include <utility> // move
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @brief an internal type for a backed binary type
+/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/
+template<typename BinaryType>
+class byte_container_with_subtype : public BinaryType
+{
+  public:
+    using container_type = BinaryType;
+    using subtype_type = std::uint64_t;
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype() noexcept(noexcept(container_type()))
+        : container_type()
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    bool operator==(const byte_container_with_subtype& rhs) const
+    {
+        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
+               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
+    }
+
+    bool operator!=(const byte_container_with_subtype& rhs) const
+    {
+        return !(rhs == *this);
+    }
+
+    /// @brief sets the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/
+    void set_subtype(subtype_type subtype_) noexcept
+    {
+        m_subtype = subtype_;
+        m_has_subtype = true;
+    }
+
+    /// @brief return the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/
+    constexpr subtype_type subtype() const noexcept
+    {
+        return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
+    }
+
+    /// @brief return whether the value has a subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/
+    constexpr bool has_subtype() const noexcept
+    {
+        return m_has_subtype;
+    }
+
+    /// @brief clears the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/
+    void clear_subtype() noexcept
+    {
+        m_subtype = 0;
+        m_has_subtype = false;
+    }
+
+  private:
+    subtype_type m_subtype = 0;
+    bool m_has_subtype = false;
+};
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/hash.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstdint> // uint8_t
+#include <cstddef> // size_t
+#include <functional> // hash
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// boost::hash_combine
+inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
+{
+    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
+    return seed;
+}
+
+/*!
+@brief hash a JSON value
+
+The hash function tries to rely on std::hash where possible. Furthermore, the
+type of the JSON value is taken into account to have different hash values for
+null, 0, 0U, and false, etc.
+
+@tparam BasicJsonType basic_json specialization
+@param j JSON value to hash
+@return hash value of j
+*/
+template<typename BasicJsonType>
+std::size_t hash(const BasicJsonType& j)
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+    const auto type = static_cast<std::size_t>(j.type());
+    switch (j.type())
+    {
+        case BasicJsonType::value_t::null:
+        case BasicJsonType::value_t::discarded:
+        {
+            return combine(type, 0);
+        }
+
+        case BasicJsonType::value_t::object:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j.items())
+            {
+                const auto h = std::hash<string_t> {}(element.key());
+                seed = combine(seed, h);
+                seed = combine(seed, hash(element.value()));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::array:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j)
+            {
+                seed = combine(seed, hash(element));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::string:
+        {
+            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::boolean:
+        {
+            const auto h = std::hash<bool> {}(j.template get<bool>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_integer:
+        {
+            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_unsigned:
+        {
+            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_float:
+        {
+            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::binary:
+        {
+            auto seed = combine(type, j.get_binary().size());
+            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
+            seed = combine(seed, h);
+            seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
+            for (const auto byte : j.get_binary())
+            {
+                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
+            }
+            return seed;
+        }
+
+        default:                   // LCOV_EXCL_LINE
+            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            return 0;              // LCOV_EXCL_LINE
+    }
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // generate_n
+#include <array> // array
+#include <cmath> // ldexp
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstdio> // snprintf
+#include <cstring> // memcpy
+#include <iterator> // back_inserter
+#include <limits> // numeric_limits
+#include <string> // char_traits, string
+#include <utility> // make_pair, move
+#include <vector> // vector
+#ifdef __cpp_lib_byteswap
+    #include <bit>  //byteswap
+#endif
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstring> // strlen
+#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
+#include <memory> // shared_ptr, make_shared, addressof
+#include <numeric> // accumulate
+#include <string> // string, char_traits
+#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
+#include <utility> // pair, declval
+
+#ifndef JSON_NO_IO
+    #include <cstdio>   // FILE *
+    #include <istream>  // istream
+#endif                  // JSON_NO_IO
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// the supported input formats
+enum class input_format_t { json, cbor, msgpack, ubjson, bson, bjdata };
+
+////////////////////
+// input adapters //
+////////////////////
+
+#ifndef JSON_NO_IO
+/*!
+Input adapter for stdio file access. This adapter read only 1 byte and do not use any
+ buffer. This adapter is a very low level adapter.
+*/
+class file_input_adapter
+{
+  public:
+    using char_type = char;
+
+    JSON_HEDLEY_NON_NULL(2)
+    explicit file_input_adapter(std::FILE* f) noexcept
+        : m_file(f)
+    {
+        JSON_ASSERT(m_file != nullptr);
+    }
+
+    // make class move-only
+    file_input_adapter(const file_input_adapter&) = delete;
+    file_input_adapter(file_input_adapter&&) noexcept = default;
+    file_input_adapter& operator=(const file_input_adapter&) = delete;
+    file_input_adapter& operator=(file_input_adapter&&) = delete;
+    ~file_input_adapter() = default;
+
+    std::char_traits<char>::int_type get_character() noexcept
+    {
+        return std::fgetc(m_file);
+    }
+
+    // returns the number of characters successfully read
+    template<class T>
+    std::size_t get_elements(T* dest, std::size_t count = 1)
+    {
+        return fread(dest, 1, sizeof(T) * count, m_file);
+    }
+
+  private:
+    /// the file pointer to read from
+    std::FILE* m_file;
+};
+
+/*!
+Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
+beginning of input. Does not support changing the underlying std::streambuf
+in mid-input. Maintains underlying std::istream and std::streambuf to support
+subsequent use of standard std::istream operations to process any input
+characters following those used in parsing the JSON input.  Clears the
+std::istream flags; any input errors (e.g., EOF) will be detected by the first
+subsequent call for input from the std::istream.
+*/
+class input_stream_adapter
+{
+  public:
+    using char_type = char;
+
+    ~input_stream_adapter()
+    {
+        // clear stream flags; we use underlying streambuf I/O, do not
+        // maintain ifstream flags, except eof
+        if (is != nullptr)
+        {
+            is->clear(is->rdstate() & std::ios::eofbit);
+        }
+    }
+
+    explicit input_stream_adapter(std::istream& i)
+        : is(&i), sb(i.rdbuf())
+    {}
+
+    // deleted because of pointer members
+    input_stream_adapter(const input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&&) = delete;
+
+    input_stream_adapter(input_stream_adapter&& rhs) noexcept
+        : is(rhs.is), sb(rhs.sb)
+    {
+        rhs.is = nullptr;
+        rhs.sb = nullptr;
+    }
+
+    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
+    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
+    // end up as the same value, e.g., 0xFFFFFFFF.
+    std::char_traits<char>::int_type get_character()
+    {
+        auto res = sb->sbumpc();
+        // set eof manually, as we don't use the istream interface.
+        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
+        {
+            is->clear(is->rdstate() | std::ios::eofbit);
+        }
+        return res;
+    }
+
+    template<class T>
+    std::size_t get_elements(T* dest, std::size_t count = 1)
+    {
+        auto res = static_cast<std::size_t>(sb->sgetn(reinterpret_cast<char*>(dest), static_cast<std::streamsize>(count * sizeof(T))));
+        if (JSON_HEDLEY_UNLIKELY(res < count * sizeof(T)))
+        {
+            is->clear(is->rdstate() | std::ios::eofbit);
+        }
+        return res;
+    }
+
+  private:
+    /// the associated input stream
+    std::istream* is = nullptr;
+    std::streambuf* sb = nullptr;
+};
+#endif  // JSON_NO_IO
+
+// General-purpose iterator-based adapter. It might not be as fast as
+// theoretically possible for some containers, but it is extremely versatile.
+template<typename IteratorType>
+class iterator_input_adapter
+{
+  public:
+    using char_type = typename std::iterator_traits<IteratorType>::value_type;
+
+    iterator_input_adapter(IteratorType first, IteratorType last)
+        : current(std::move(first)), end(std::move(last))
+    {}
+
+    typename char_traits<char_type>::int_type get_character()
+    {
+        if (JSON_HEDLEY_LIKELY(current != end))
+        {
+            auto result = char_traits<char_type>::to_int_type(*current);
+            std::advance(current, 1);
+            return result;
+        }
+
+        return char_traits<char_type>::eof();
+    }
+
+    // for general iterators, we cannot really do something better than falling back to processing the range one-by-one
+    template<class T>
+    std::size_t get_elements(T* dest, std::size_t count = 1)
+    {
+        auto* ptr = reinterpret_cast<char*>(dest);
+        for (std::size_t read_index = 0; read_index < count * sizeof(T); ++read_index)
+        {
+            if (JSON_HEDLEY_LIKELY(current != end))
+            {
+                ptr[read_index] = static_cast<char>(*current);
+                std::advance(current, 1);
+            }
+            else
+            {
+                return read_index;
+            }
+        }
+        return count * sizeof(T);
+    }
+
+  private:
+    IteratorType current;
+    IteratorType end;
+
+    template<typename BaseInputAdapter, size_t T>
+    friend struct wide_string_input_helper;
+
+    bool empty() const
+    {
+        return current == end;
+    }
+};
+
+template<typename BaseInputAdapter, size_t T>
+struct wide_string_input_helper;
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 4>
+{
+    // UTF-32
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-32 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (wc <= 0xFFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else if (wc <= 0x10FFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 4;
+            }
+            else
+            {
+                // unknown character
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+        }
+    }
+};
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 2>
+{
+    // UTF-16
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-16 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (0xD800 > wc || wc >= 0xE000)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else
+            {
+                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
+                {
+                    const auto wc2 = static_cast<unsigned int>(input.get_character());
+                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
+                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
+                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
+                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
+                    utf8_bytes_filled = 4;
+                }
+                else
+                {
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                    utf8_bytes_filled = 1;
+                }
+            }
+        }
+    }
+};
+
+// Wraps another input adapter to convert wide character types into individual bytes.
+template<typename BaseInputAdapter, typename WideCharType>
+class wide_string_input_adapter
+{
+  public:
+    using char_type = char;
+
+    wide_string_input_adapter(BaseInputAdapter base)
+        : base_adapter(base) {}
+
+    typename std::char_traits<char>::int_type get_character() noexcept
+    {
+        // check if the buffer needs to be filled
+        if (utf8_bytes_index == utf8_bytes_filled)
+        {
+            fill_buffer<sizeof(WideCharType)>();
+
+            JSON_ASSERT(utf8_bytes_filled > 0);
+            JSON_ASSERT(utf8_bytes_index == 0);
+        }
+
+        // use buffer
+        JSON_ASSERT(utf8_bytes_filled > 0);
+        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
+        return utf8_bytes[utf8_bytes_index++];
+    }
+
+    // parsing binary with wchar doesn't make sense, but since the parsing mode can be runtime, we need something here
+    template<class T>
+    std::size_t get_elements(T* /*dest*/, std::size_t /*count*/ = 1)
+    {
+        JSON_THROW(parse_error::create(112, 1, "wide string type cannot be interpreted as binary data", nullptr));
+    }
+
+  private:
+    BaseInputAdapter base_adapter;
+
+    template<size_t T>
+    void fill_buffer()
+    {
+        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
+    }
+
+    /// a buffer for UTF-8 bytes
+    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
+
+    /// index to the utf8_codes array for the next valid byte
+    std::size_t utf8_bytes_index = 0;
+    /// number of valid bytes in the utf8_codes array
+    std::size_t utf8_bytes_filled = 0;
+};
+
+template<typename IteratorType, typename Enable = void>
+struct iterator_input_adapter_factory
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using adapter_type = iterator_input_adapter<iterator_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(std::move(first), std::move(last));
+    }
+};
+
+template<typename T>
+struct is_iterator_of_multibyte
+{
+    using value_type = typename std::iterator_traits<T>::value_type;
+    enum
+    {
+        value = sizeof(value_type) > 1
+    };
+};
+
+template<typename IteratorType>
+struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using base_adapter_type = iterator_input_adapter<iterator_type>;
+    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(base_adapter_type(std::move(first), std::move(last)));
+    }
+};
+
+// General purpose iterator-based input
+template<typename IteratorType>
+typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
+{
+    using factory_type = iterator_input_adapter_factory<IteratorType>;
+    return factory_type::create(first, last);
+}
+
+// Convenience shorthand from container to iterator
+// Enables ADL on begin(container) and end(container)
+// Encloses the using declarations in namespace for not to leak them to outside scope
+
+namespace container_input_adapter_factory_impl
+{
+
+using std::begin;
+using std::end;
+
+template<typename ContainerType, typename Enable = void>
+struct container_input_adapter_factory {};
+
+template<typename ContainerType>
+struct container_input_adapter_factory< ContainerType,
+       void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
+       {
+           using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
+
+           static adapter_type create(const ContainerType& container)
+{
+    return input_adapter(begin(container), end(container));
+}
+       };
+
+}  // namespace container_input_adapter_factory_impl
+
+template<typename ContainerType>
+typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
+{
+    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
+}
+
+// specialization for std::string
+using string_input_adapter_type = decltype(input_adapter(std::declval<std::string>()));
+
+#ifndef JSON_NO_IO
+// Special cases with fast paths
+inline file_input_adapter input_adapter(std::FILE* file)
+{
+    if (file == nullptr)
+    {
+        JSON_THROW(parse_error::create(101, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
+    }
+    return file_input_adapter(file);
+}
+
+inline input_stream_adapter input_adapter(std::istream& stream)
+{
+    return input_stream_adapter(stream);
+}
+
+inline input_stream_adapter input_adapter(std::istream&& stream)
+{
+    return input_stream_adapter(stream);
+}
+#endif  // JSON_NO_IO
+
+using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
+
+// Null-delimited strings, and the like.
+template < typename CharT,
+           typename std::enable_if <
+               std::is_pointer<CharT>::value&&
+               !std::is_array<CharT>::value&&
+               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+               sizeof(typename std::remove_pointer<CharT>::type) == 1,
+               int >::type = 0 >
+contiguous_bytes_input_adapter input_adapter(CharT b)
+{
+    if (b == nullptr)
+    {
+        JSON_THROW(parse_error::create(101, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
+    }
+    auto length = std::strlen(reinterpret_cast<const char*>(b));
+    const auto* ptr = reinterpret_cast<const char*>(b);
+    return input_adapter(ptr, ptr + length); // cppcheck-suppress[nullPointerArithmeticRedundantCheck]
+}
+
+template<typename T, std::size_t N>
+auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+{
+    return input_adapter(array, array + N);
+}
+
+// This class only handles inputs of input_buffer_adapter type.
+// It's required so that expressions like {ptr, len} can be implicitly cast
+// to the correct adapter.
+class span_input_adapter
+{
+  public:
+    template < typename CharT,
+               typename std::enable_if <
+                   std::is_pointer<CharT>::value&&
+                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+                   sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                   int >::type = 0 >
+    span_input_adapter(CharT b, std::size_t l)
+        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
+
+    template<class IteratorType,
+             typename std::enable_if<
+                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
+                 int>::type = 0>
+    span_input_adapter(IteratorType first, IteratorType last)
+        : ia(input_adapter(first, last)) {}
+
+    contiguous_bytes_input_adapter&& get()
+    {
+        return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
+    }
+
+  private:
+    contiguous_bytes_input_adapter ia;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef>
+#include <string> // string
+#include <type_traits> // enable_if_t
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <clocale> // localeconv
+#include <cstddef> // size_t
+#include <cstdio> // snprintf
+#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
+#include <initializer_list> // initializer_list
+#include <string> // char_traits, string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////
+// lexer //
+///////////
+
+template<typename BasicJsonType>
+class lexer_base
+{
+  public:
+    /// token types for the parser
+    enum class token_type
+    {
+        uninitialized,    ///< indicating the scanner is uninitialized
+        literal_true,     ///< the `true` literal
+        literal_false,    ///< the `false` literal
+        literal_null,     ///< the `null` literal
+        value_string,     ///< a string -- use get_string() for actual value
+        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
+        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
+        value_float,      ///< an floating point number -- use get_number_float() for actual value
+        begin_array,      ///< the character for array begin `[`
+        begin_object,     ///< the character for object begin `{`
+        end_array,        ///< the character for array end `]`
+        end_object,       ///< the character for object end `}`
+        name_separator,   ///< the name separator `:`
+        value_separator,  ///< the value separator `,`
+        parse_error,      ///< indicating a parse error
+        end_of_input,     ///< indicating the end of the input buffer
+        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
+    };
+
+    /// return name of values of type token_type (only used for errors)
+    JSON_HEDLEY_RETURNS_NON_NULL
+    JSON_HEDLEY_CONST
+    static const char* token_type_name(const token_type t) noexcept
+    {
+        switch (t)
+        {
+            case token_type::uninitialized:
+                return "<uninitialized>";
+            case token_type::literal_true:
+                return "true literal";
+            case token_type::literal_false:
+                return "false literal";
+            case token_type::literal_null:
+                return "null literal";
+            case token_type::value_string:
+                return "string literal";
+            case token_type::value_unsigned:
+            case token_type::value_integer:
+            case token_type::value_float:
+                return "number literal";
+            case token_type::begin_array:
+                return "'['";
+            case token_type::begin_object:
+                return "'{'";
+            case token_type::end_array:
+                return "']'";
+            case token_type::end_object:
+                return "'}'";
+            case token_type::name_separator:
+                return "':'";
+            case token_type::value_separator:
+                return "','";
+            case token_type::parse_error:
+                return "<parse error>";
+            case token_type::end_of_input:
+                return "end of input";
+            case token_type::literal_or_value:
+                return "'[', '{', or a literal";
+            // LCOV_EXCL_START
+            default: // catch non-enum values
+                return "unknown token";
+                // LCOV_EXCL_STOP
+        }
+    }
+};
+/*!
+@brief lexical analysis
+
+This class organizes the lexical analysis during JSON deserialization.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class lexer : public lexer_base<BasicJsonType>
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename char_traits<char_type>::int_type;
+
+  public:
+    using token_type = typename lexer_base<BasicJsonType>::token_type;
+
+    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
+        : ia(std::move(adapter))
+        , ignore_comments(ignore_comments_)
+        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
+    {}
+
+    // deleted because of pointer members
+    lexer(const lexer&) = delete;
+    lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    lexer& operator=(lexer&) = delete;
+    lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~lexer() = default;
+
+  private:
+    /////////////////////
+    // locales
+    /////////////////////
+
+    /// return the locale-dependent decimal point
+    JSON_HEDLEY_PURE
+    static char get_decimal_point() noexcept
+    {
+        const auto* loc = localeconv();
+        JSON_ASSERT(loc != nullptr);
+        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
+    }
+
+    /////////////////////
+    // scan functions
+    /////////////////////
+
+    /*!
+    @brief get codepoint from 4 hex characters following `\u`
+
+    For input "\u c1 c2 c3 c4" the codepoint is:
+      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
+    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
+
+    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
+    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
+    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
+    between the ASCII value of the character and the desired integer value.
+
+    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
+            non-hex character)
+    */
+    int get_codepoint()
+    {
+        // this function only makes sense after reading `\u`
+        JSON_ASSERT(current == 'u');
+        int codepoint = 0;
+
+        const auto factors = { 12u, 8u, 4u, 0u };
+        for (const auto factor : factors)
+        {
+            get();
+
+            if (current >= '0' && current <= '9')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
+            }
+            else if (current >= 'A' && current <= 'F')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
+            }
+            else if (current >= 'a' && current <= 'f')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
+        return codepoint;
+    }
+
+    /*!
+    @brief check if the next byte(s) are inside a given range
+
+    Adds the current byte and, for each passed range, reads a new byte and
+    checks if it is inside the range. If a violation was detected, set up an
+    error message and return false. Otherwise, return true.
+
+    @param[in] ranges  list of integers; interpreted as list of pairs of
+                       inclusive lower and upper bound, respectively
+
+    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
+         1, 2, or 3 pairs. This precondition is enforced by an assertion.
+
+    @return true if and only if no range violation was detected
+    */
+    bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
+    {
+        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
+        add(current);
+
+        for (auto range = ranges.begin(); range != ranges.end(); ++range)
+        {
+            get();
+            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
+            {
+                add(current);
+            }
+            else
+            {
+                error_message = "invalid string: ill-formed UTF-8 byte";
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief scan a string literal
+
+    This function scans a string according to Sect. 7 of RFC 8259. While
+    scanning, bytes are escaped and copied into buffer token_buffer. Then the
+    function returns successfully, token_buffer is *not* null-terminated (as it
+    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
+    string.
+
+    @return token_type::value_string if string could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note In case of errors, variable error_message contains a textual
+          description.
+    */
+    token_type scan_string()
+    {
+        // reset token_buffer (ignore opening quote)
+        reset();
+
+        // we entered the function by reading an open quote
+        JSON_ASSERT(current == '\"');
+
+        while (true)
+        {
+            // get the next character
+            switch (get())
+            {
+                // end of file while parsing the string
+                case char_traits<char_type>::eof():
+                {
+                    error_message = "invalid string: missing closing quote";
+                    return token_type::parse_error;
+                }
+
+                // closing quote
+                case '\"':
+                {
+                    return token_type::value_string;
+                }
+
+                // escapes
+                case '\\':
+                {
+                    switch (get())
+                    {
+                        // quotation mark
+                        case '\"':
+                            add('\"');
+                            break;
+                        // reverse solidus
+                        case '\\':
+                            add('\\');
+                            break;
+                        // solidus
+                        case '/':
+                            add('/');
+                            break;
+                        // backspace
+                        case 'b':
+                            add('\b');
+                            break;
+                        // form feed
+                        case 'f':
+                            add('\f');
+                            break;
+                        // line feed
+                        case 'n':
+                            add('\n');
+                            break;
+                        // carriage return
+                        case 'r':
+                            add('\r');
+                            break;
+                        // tab
+                        case 't':
+                            add('\t');
+                            break;
+
+                        // unicode escapes
+                        case 'u':
+                        {
+                            const int codepoint1 = get_codepoint();
+                            int codepoint = codepoint1; // start with codepoint1
+
+                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
+                            {
+                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                return token_type::parse_error;
+                            }
+
+                            // check if code point is a high surrogate
+                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
+                            {
+                                // expect next \uxxxx entry
+                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
+                                {
+                                    const int codepoint2 = get_codepoint();
+
+                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
+                                    {
+                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                        return token_type::parse_error;
+                                    }
+
+                                    // check if codepoint2 is a low surrogate
+                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
+                                    {
+                                        // overwrite codepoint
+                                        codepoint = static_cast<int>(
+                                                        // high surrogate occupies the most significant 22 bits
+                                                        (static_cast<unsigned int>(codepoint1) << 10u)
+                                                        // low surrogate occupies the least significant 15 bits
+                                                        + static_cast<unsigned int>(codepoint2)
+                                                        // there is still the 0xD800, 0xDC00, and 0x10000 noise
+                                                        // in the result, so we have to subtract with:
+                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                                                        - 0x35FDC00u);
+                                    }
+                                    else
+                                    {
+                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                        return token_type::parse_error;
+                                    }
+                                }
+                                else
+                                {
+                                    error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+                            else
+                            {
+                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
+                                {
+                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+
+                            // the result of the above calculation yields a proper codepoint
+                            JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
+
+                            // translate codepoint into bytes
+                            if (codepoint < 0x80)
+                            {
+                                // 1-byte characters: 0xxxxxxx (ASCII)
+                                add(static_cast<char_int_type>(codepoint));
+                            }
+                            else if (codepoint <= 0x7FF)
+                            {
+                                // 2-byte characters: 110xxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else if (codepoint <= 0xFFFF)
+                            {
+                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else
+                            {
+                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+
+                            break;
+                        }
+
+                        // other characters after escape
+                        default:
+                            error_message = "invalid string: forbidden character after backslash";
+                            return token_type::parse_error;
+                    }
+
+                    break;
+                }
+
+                // invalid control characters
+                case 0x00:
+                {
+                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
+                    return token_type::parse_error;
+                }
+
+                case 0x01:
+                {
+                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
+                    return token_type::parse_error;
+                }
+
+                case 0x02:
+                {
+                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
+                    return token_type::parse_error;
+                }
+
+                case 0x03:
+                {
+                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
+                    return token_type::parse_error;
+                }
+
+                case 0x04:
+                {
+                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
+                    return token_type::parse_error;
+                }
+
+                case 0x05:
+                {
+                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
+                    return token_type::parse_error;
+                }
+
+                case 0x06:
+                {
+                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
+                    return token_type::parse_error;
+                }
+
+                case 0x07:
+                {
+                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
+                    return token_type::parse_error;
+                }
+
+                case 0x08:
+                {
+                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
+                    return token_type::parse_error;
+                }
+
+                case 0x09:
+                {
+                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
+                    return token_type::parse_error;
+                }
+
+                case 0x0A:
+                {
+                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
+                    return token_type::parse_error;
+                }
+
+                case 0x0B:
+                {
+                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
+                    return token_type::parse_error;
+                }
+
+                case 0x0C:
+                {
+                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
+                    return token_type::parse_error;
+                }
+
+                case 0x0D:
+                {
+                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
+                    return token_type::parse_error;
+                }
+
+                case 0x0E:
+                {
+                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
+                    return token_type::parse_error;
+                }
+
+                case 0x0F:
+                {
+                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
+                    return token_type::parse_error;
+                }
+
+                case 0x10:
+                {
+                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
+                    return token_type::parse_error;
+                }
+
+                case 0x11:
+                {
+                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
+                    return token_type::parse_error;
+                }
+
+                case 0x12:
+                {
+                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
+                    return token_type::parse_error;
+                }
+
+                case 0x13:
+                {
+                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
+                    return token_type::parse_error;
+                }
+
+                case 0x14:
+                {
+                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
+                    return token_type::parse_error;
+                }
+
+                case 0x15:
+                {
+                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
+                    return token_type::parse_error;
+                }
+
+                case 0x16:
+                {
+                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
+                    return token_type::parse_error;
+                }
+
+                case 0x17:
+                {
+                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
+                    return token_type::parse_error;
+                }
+
+                case 0x18:
+                {
+                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
+                    return token_type::parse_error;
+                }
+
+                case 0x19:
+                {
+                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
+                    return token_type::parse_error;
+                }
+
+                case 0x1A:
+                {
+                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
+                    return token_type::parse_error;
+                }
+
+                case 0x1B:
+                {
+                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
+                    return token_type::parse_error;
+                }
+
+                case 0x1C:
+                {
+                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
+                    return token_type::parse_error;
+                }
+
+                case 0x1D:
+                {
+                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
+                    return token_type::parse_error;
+                }
+
+                case 0x1E:
+                {
+                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
+                    return token_type::parse_error;
+                }
+
+                case 0x1F:
+                {
+                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
+                    return token_type::parse_error;
+                }
+
+                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
+                case 0x20:
+                case 0x21:
+                case 0x23:
+                case 0x24:
+                case 0x25:
+                case 0x26:
+                case 0x27:
+                case 0x28:
+                case 0x29:
+                case 0x2A:
+                case 0x2B:
+                case 0x2C:
+                case 0x2D:
+                case 0x2E:
+                case 0x2F:
+                case 0x30:
+                case 0x31:
+                case 0x32:
+                case 0x33:
+                case 0x34:
+                case 0x35:
+                case 0x36:
+                case 0x37:
+                case 0x38:
+                case 0x39:
+                case 0x3A:
+                case 0x3B:
+                case 0x3C:
+                case 0x3D:
+                case 0x3E:
+                case 0x3F:
+                case 0x40:
+                case 0x41:
+                case 0x42:
+                case 0x43:
+                case 0x44:
+                case 0x45:
+                case 0x46:
+                case 0x47:
+                case 0x48:
+                case 0x49:
+                case 0x4A:
+                case 0x4B:
+                case 0x4C:
+                case 0x4D:
+                case 0x4E:
+                case 0x4F:
+                case 0x50:
+                case 0x51:
+                case 0x52:
+                case 0x53:
+                case 0x54:
+                case 0x55:
+                case 0x56:
+                case 0x57:
+                case 0x58:
+                case 0x59:
+                case 0x5A:
+                case 0x5B:
+                case 0x5D:
+                case 0x5E:
+                case 0x5F:
+                case 0x60:
+                case 0x61:
+                case 0x62:
+                case 0x63:
+                case 0x64:
+                case 0x65:
+                case 0x66:
+                case 0x67:
+                case 0x68:
+                case 0x69:
+                case 0x6A:
+                case 0x6B:
+                case 0x6C:
+                case 0x6D:
+                case 0x6E:
+                case 0x6F:
+                case 0x70:
+                case 0x71:
+                case 0x72:
+                case 0x73:
+                case 0x74:
+                case 0x75:
+                case 0x76:
+                case 0x77:
+                case 0x78:
+                case 0x79:
+                case 0x7A:
+                case 0x7B:
+                case 0x7C:
+                case 0x7D:
+                case 0x7E:
+                case 0x7F:
+                {
+                    add(current);
+                    break;
+                }
+
+                // U+0080..U+07FF: bytes C2..DF 80..BF
+                case 0xC2:
+                case 0xC3:
+                case 0xC4:
+                case 0xC5:
+                case 0xC6:
+                case 0xC7:
+                case 0xC8:
+                case 0xC9:
+                case 0xCA:
+                case 0xCB:
+                case 0xCC:
+                case 0xCD:
+                case 0xCE:
+                case 0xCF:
+                case 0xD0:
+                case 0xD1:
+                case 0xD2:
+                case 0xD3:
+                case 0xD4:
+                case 0xD5:
+                case 0xD6:
+                case 0xD7:
+                case 0xD8:
+                case 0xD9:
+                case 0xDA:
+                case 0xDB:
+                case 0xDC:
+                case 0xDD:
+                case 0xDE:
+                case 0xDF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
+                case 0xE0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
+                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
+                case 0xE1:
+                case 0xE2:
+                case 0xE3:
+                case 0xE4:
+                case 0xE5:
+                case 0xE6:
+                case 0xE7:
+                case 0xE8:
+                case 0xE9:
+                case 0xEA:
+                case 0xEB:
+                case 0xEC:
+                case 0xEE:
+                case 0xEF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
+                case 0xED:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
+                case 0xF0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
+                case 0xF1:
+                case 0xF2:
+                case 0xF3:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
+                case 0xF4:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // the remaining bytes (80..C1 and F5..FF) are ill-formed
+                default:
+                {
+                    error_message = "invalid string: ill-formed UTF-8 byte";
+                    return token_type::parse_error;
+                }
+            }
+        }
+    }
+
+    /*!
+     * @brief scan a comment
+     * @return whether comment could be scanned successfully
+     */
+    bool scan_comment()
+    {
+        switch (get())
+        {
+            // single-line comments skip input until a newline or EOF is read
+            case '/':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case '\n':
+                        case '\r':
+                        case char_traits<char_type>::eof():
+                        case '\0':
+                            return true;
+
+                        default:
+                            break;
+                    }
+                }
+            }
+
+            // multi-line comments skip input until */ is read
+            case '*':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case char_traits<char_type>::eof():
+                        case '\0':
+                        {
+                            error_message = "invalid comment; missing closing '*/'";
+                            return false;
+                        }
+
+                        case '*':
+                        {
+                            switch (get())
+                            {
+                                case '/':
+                                    return true;
+
+                                default:
+                                {
+                                    unget();
+                                    continue;
+                                }
+                            }
+                        }
+
+                        default:
+                            continue;
+                    }
+                }
+            }
+
+            // unexpected character after reading '/'
+            default:
+            {
+                error_message = "invalid comment; expecting '/' or '*' after '/'";
+                return false;
+            }
+        }
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(float& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtof(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtod(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(long double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtold(str, endptr);
+    }
+
+    /*!
+    @brief scan a number literal
+
+    This function scans a string according to Sect. 6 of RFC 8259.
+
+    The function is realized with a deterministic finite state machine derived
+    from the grammar described in RFC 8259. Starting in state "init", the
+    input is read and used to determined the next state. Only state "done"
+    accepts the number. State "error" is a trap state to model errors. In the
+    table below, "anything" means any character but the ones listed before.
+
+    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
+    ---------|----------|----------|----------|---------|---------|----------|-----------
+    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
+    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
+    zero     | done     | done     | exponent | done    | done    | decimal1 | done
+    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
+    decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]
+    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
+    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
+    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
+    any2     | any2     | any2     | done     | done    | done    | done     | done
+
+    The state machine is realized with one label per state (prefixed with
+    "scan_number_") and `goto` statements between them. The state machine
+    contains cycles, but any cycle can be left when EOF is read. Therefore,
+    the function is guaranteed to terminate.
+
+    During scanning, the read bytes are stored in token_buffer. This string is
+    then converted to a signed integer, an unsigned integer, or a
+    floating-point number.
+
+    @return token_type::value_unsigned, token_type::value_integer, or
+            token_type::value_float if number could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note The scanner is independent of the current locale. Internally, the
+          locale's decimal point is used instead of `.` to work with the
+          locale-dependent converters.
+    */
+    token_type scan_number()  // lgtm [cpp/use-of-goto] `goto` is used in this function to implement the number-parsing state machine described above. By design, any finite input will eventually reach the "done" state or return token_type::parse_error. In each intermediate state, 1 byte of the input is appended to the token_buffer vector, and only the already initialized variables token_buffer, number_type, and error_message are manipulated.
+    {
+        // reset token_buffer to store the number's bytes
+        reset();
+
+        // the type of the parsed number; initially set to unsigned; will be
+        // changed if minus sign, decimal point, or exponent is read
+        token_type number_type = token_type::value_unsigned;
+
+        // state (init): we just found out we need to scan a number
+        switch (current)
+        {
+            case '-':
+            {
+                add(current);
+                goto scan_number_minus;
+            }
+
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            // all other characters are rejected outside scan_number()
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+scan_number_minus:
+        // state: we just parsed a leading minus sign
+        number_type = token_type::value_integer;
+        switch (get())
+        {
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '-'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_zero:
+        // state: we just parse a zero (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '.':
+            {
+                add(decimal_point_char);
+                decimal_point_position = token_buffer.size() - 1;
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_any1:
+        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            case '.':
+            {
+                add(decimal_point_char);
+                decimal_point_position = token_buffer.size() - 1;
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_decimal1:
+        // state: we just parsed a decimal point
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '.'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_decimal2:
+        // we just parsed at least one number after a decimal point
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_exponent:
+        // we just parsed an exponent
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '+':
+            case '-':
+            {
+                add(current);
+                goto scan_number_sign;
+            }
+
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message =
+                    "invalid number; expected '+', '-', or digit after exponent";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_sign:
+        // we just parsed an exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after exponent sign";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_any2:
+        // we just parsed a number after the exponent or exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_done:
+        // unget the character after the number (we only read it to know that
+        // we are done scanning a number)
+        unget();
+
+        char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        errno = 0;
+
+        // try to parse integers first and fall back to floats
+        if (number_type == token_type::value_unsigned)
+        {
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno != ERANGE)
+            {
+                value_unsigned = static_cast<number_unsigned_t>(x);
+                if (value_unsigned == x)
+                {
+                    return token_type::value_unsigned;
+                }
+            }
+        }
+        else if (number_type == token_type::value_integer)
+        {
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno != ERANGE)
+            {
+                value_integer = static_cast<number_integer_t>(x);
+                if (value_integer == x)
+                {
+                    return token_type::value_integer;
+                }
+            }
+        }
+
+        // this code is reached if we parse a floating-point number or if an
+        // integer conversion above failed
+        strtof(value_float, token_buffer.data(), &endptr);
+
+        // we checked the number format before
+        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+        return token_type::value_float;
+    }
+
+    /*!
+    @param[in] literal_text  the literal text to expect
+    @param[in] length        the length of the passed literal text
+    @param[in] return_type   the token type to return on success
+    */
+    JSON_HEDLEY_NON_NULL(2)
+    token_type scan_literal(const char_type* literal_text, const std::size_t length,
+                            token_type return_type)
+    {
+        JSON_ASSERT(char_traits<char_type>::to_char_type(current) == literal_text[0]);
+        for (std::size_t i = 1; i < length; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(char_traits<char_type>::to_char_type(get()) != literal_text[i]))
+            {
+                error_message = "invalid literal";
+                return token_type::parse_error;
+            }
+        }
+        return return_type;
+    }
+
+    /////////////////////
+    // input management
+    /////////////////////
+
+    /// reset token_buffer; current character is beginning of token
+    void reset() noexcept
+    {
+        token_buffer.clear();
+        token_string.clear();
+        decimal_point_position = std::string::npos;
+        token_string.push_back(char_traits<char_type>::to_char_type(current));
+    }
+
+    /*
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a
+    `char_traits<char>::eof()` in that case.  Stores the scanned characters
+    for use in error messages.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++position.chars_read_total;
+        ++position.chars_read_current_line;
+
+        if (next_unget)
+        {
+            // only reset the next_unget variable and work with current
+            next_unget = false;
+        }
+        else
+        {
+            current = ia.get_character();
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
+        {
+            token_string.push_back(char_traits<char_type>::to_char_type(current));
+        }
+
+        if (current == '\n')
+        {
+            ++position.lines_read;
+            position.chars_read_current_line = 0;
+        }
+
+        return current;
+    }
+
+    /*!
+    @brief unget current character (read it again on next get)
+
+    We implement unget by setting variable next_unget to true. The input is not
+    changed - we just simulate ungetting by modifying chars_read_total,
+    chars_read_current_line, and token_string. The next call to get() will
+    behave as if the unget character is read again.
+    */
+    void unget()
+    {
+        next_unget = true;
+
+        --position.chars_read_total;
+
+        // in case we "unget" a newline, we have to also decrement the lines_read
+        if (position.chars_read_current_line == 0)
+        {
+            if (position.lines_read > 0)
+            {
+                --position.lines_read;
+            }
+        }
+        else
+        {
+            --position.chars_read_current_line;
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
+        {
+            JSON_ASSERT(!token_string.empty());
+            token_string.pop_back();
+        }
+    }
+
+    /// add a character to token_buffer
+    void add(char_int_type c)
+    {
+        token_buffer.push_back(static_cast<typename string_t::value_type>(c));
+    }
+
+  public:
+    /////////////////////
+    // value getters
+    /////////////////////
+
+    /// return integer value
+    constexpr number_integer_t get_number_integer() const noexcept
+    {
+        return value_integer;
+    }
+
+    /// return unsigned integer value
+    constexpr number_unsigned_t get_number_unsigned() const noexcept
+    {
+        return value_unsigned;
+    }
+
+    /// return floating-point value
+    constexpr number_float_t get_number_float() const noexcept
+    {
+        return value_float;
+    }
+
+    /// return current string value (implicitly resets the token; useful only once)
+    string_t& get_string()
+    {
+        // translate decimal points from locale back to '.' (#4084)
+        if (decimal_point_char != '.' && decimal_point_position != std::string::npos)
+        {
+            token_buffer[decimal_point_position] = '.';
+        }
+        return token_buffer;
+    }
+
+    /////////////////////
+    // diagnostics
+    /////////////////////
+
+    /// return position of last read token
+    constexpr position_t get_position() const noexcept
+    {
+        return position;
+    }
+
+    /// return the last read token (for errors only).  Will never contain EOF
+    /// (an arbitrary value that is not a valid char value, often -1), because
+    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
+    std::string get_token_string() const
+    {
+        // escape control characters
+        std::string result;
+        for (const auto c : token_string)
+        {
+            if (static_cast<unsigned char>(c) <= '\x1F')
+            {
+                // escape control characters
+                std::array<char, 9> cs{{}};
+                static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                result += cs.data();
+            }
+            else
+            {
+                // add character as is
+                result.push_back(static_cast<std::string::value_type>(c));
+            }
+        }
+
+        return result;
+    }
+
+    /// return syntax error message
+    JSON_HEDLEY_RETURNS_NON_NULL
+    constexpr const char* get_error_message() const noexcept
+    {
+        return error_message;
+    }
+
+    /////////////////////
+    // actual scanner
+    /////////////////////
+
+    /*!
+    @brief skip the UTF-8 byte order mark
+    @return true iff there is no BOM or the correct BOM has been skipped
+    */
+    bool skip_bom()
+    {
+        if (get() == 0xEF)
+        {
+            // check if we completely parse the BOM
+            return get() == 0xBB && get() == 0xBF;
+        }
+
+        // the first character is not the beginning of the BOM; unget it to
+        // process is later
+        unget();
+        return true;
+    }
+
+    void skip_whitespace()
+    {
+        do
+        {
+            get();
+        }
+        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
+    }
+
+    token_type scan()
+    {
+        // initially, skip the BOM
+        if (position.chars_read_total == 0 && !skip_bom())
+        {
+            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
+            return token_type::parse_error;
+        }
+
+        // read the next character and ignore whitespace
+        skip_whitespace();
+
+        // ignore comments
+        while (ignore_comments && current == '/')
+        {
+            if (!scan_comment())
+            {
+                return token_type::parse_error;
+            }
+
+            // skip following whitespace
+            skip_whitespace();
+        }
+
+        switch (current)
+        {
+            // structural characters
+            case '[':
+                return token_type::begin_array;
+            case ']':
+                return token_type::end_array;
+            case '{':
+                return token_type::begin_object;
+            case '}':
+                return token_type::end_object;
+            case ':':
+                return token_type::name_separator;
+            case ',':
+                return token_type::value_separator;
+
+            // literals
+            case 't':
+            {
+                std::array<char_type, 4> true_literal = {{static_cast<char_type>('t'), static_cast<char_type>('r'), static_cast<char_type>('u'), static_cast<char_type>('e')}};
+                return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
+            }
+            case 'f':
+            {
+                std::array<char_type, 5> false_literal = {{static_cast<char_type>('f'), static_cast<char_type>('a'), static_cast<char_type>('l'), static_cast<char_type>('s'), static_cast<char_type>('e')}};
+                return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
+            }
+            case 'n':
+            {
+                std::array<char_type, 4> null_literal = {{static_cast<char_type>('n'), static_cast<char_type>('u'), static_cast<char_type>('l'), static_cast<char_type>('l')}};
+                return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
+            }
+
+            // string
+            case '\"':
+                return scan_string();
+
+            // number
+            case '-':
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                return scan_number();
+
+            // end of input (the null byte is needed when parsing from
+            // string literals)
+            case '\0':
+            case char_traits<char_type>::eof():
+                return token_type::end_of_input;
+
+            // error
+            default:
+                error_message = "invalid literal";
+                return token_type::parse_error;
+        }
+    }
+
+  private:
+    /// input adapter
+    InputAdapterType ia;
+
+    /// whether comments should be ignored (true) or signaled as errors (false)
+    const bool ignore_comments = false;
+
+    /// the current character
+    char_int_type current = char_traits<char_type>::eof();
+
+    /// whether the next get() call should just return current
+    bool next_unget = false;
+
+    /// the start position of the current token
+    position_t position {};
+
+    /// raw input token string (for error messages)
+    std::vector<char_type> token_string {};
+
+    /// buffer for variable-length tokens (numbers, strings)
+    string_t token_buffer {};
+
+    /// a description of occurred lexer errors
+    const char* error_message = "";
+
+    // number values
+    number_integer_t value_integer = 0;
+    number_unsigned_t value_unsigned = 0;
+    number_float_t value_float = 0;
+
+    /// the decimal point
+    const char_int_type decimal_point_char = '.';
+    /// the position of the decimal point in the input
+    std::size_t decimal_point_position = std::string::npos;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/*!
+@brief SAX interface
+
+This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
+Each function is called in different situations while the input is parsed. The
+boolean return value informs the parser whether to continue processing the
+input.
+*/
+template<typename BasicJsonType>
+struct json_sax
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @brief a null value was read
+    @return whether parsing should proceed
+    */
+    virtual bool null() = 0;
+
+    /*!
+    @brief a boolean value was read
+    @param[in] val  boolean value
+    @return whether parsing should proceed
+    */
+    virtual bool boolean(bool val) = 0;
+
+    /*!
+    @brief an integer number was read
+    @param[in] val  integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_integer(number_integer_t val) = 0;
+
+    /*!
+    @brief an unsigned integer number was read
+    @param[in] val  unsigned integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_unsigned(number_unsigned_t val) = 0;
+
+    /*!
+    @brief a floating-point number was read
+    @param[in] val  floating-point value
+    @param[in] s    raw token value
+    @return whether parsing should proceed
+    */
+    virtual bool number_float(number_float_t val, const string_t& s) = 0;
+
+    /*!
+    @brief a string value was read
+    @param[in] val  string value
+    @return whether parsing should proceed
+    @note It is safe to move the passed string value.
+    */
+    virtual bool string(string_t& val) = 0;
+
+    /*!
+    @brief a binary value was read
+    @param[in] val  binary value
+    @return whether parsing should proceed
+    @note It is safe to move the passed binary value.
+    */
+    virtual bool binary(binary_t& val) = 0;
+
+    /*!
+    @brief the beginning of an object was read
+    @param[in] elements  number of object elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_object(std::size_t elements) = 0;
+
+    /*!
+    @brief an object key was read
+    @param[in] val  object key
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool key(string_t& val) = 0;
+
+    /*!
+    @brief the end of an object was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_object() = 0;
+
+    /*!
+    @brief the beginning of an array was read
+    @param[in] elements  number of array elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_array(std::size_t elements) = 0;
+
+    /*!
+    @brief the end of an array was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_array() = 0;
+
+    /*!
+    @brief a parse error occurred
+    @param[in] position    the position in the input where the error occurs
+    @param[in] last_token  the last read token
+    @param[in] ex          an exception object describing the error
+    @return whether parsing should proceed (must return false)
+    */
+    virtual bool parse_error(std::size_t position,
+                             const std::string& last_token,
+                             const detail::exception& ex) = 0;
+
+    json_sax() = default;
+    json_sax(const json_sax&) = default;
+    json_sax(json_sax&&) noexcept = default;
+    json_sax& operator=(const json_sax&) = default;
+    json_sax& operator=(json_sax&&) noexcept = default;
+    virtual ~json_sax() = default;
+};
+
+namespace detail
+{
+constexpr std::size_t unknown_size()
+{
+    return (std::numeric_limits<std::size_t>::max)();
+}
+
+/*!
+@brief SAX implementation to create a JSON value from SAX events
+
+This class implements the @ref json_sax interface and processes the SAX events
+to create a JSON value which makes it basically a DOM parser. The structure or
+hierarchy of the JSON value is managed by the stack `ref_stack` which contains
+a pointer to the respective array or object for each recursion depth.
+
+After successful parsing, the value that is passed by reference to the
+constructor contains the parsed value.
+
+@tparam BasicJsonType  the JSON type
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class json_sax_dom_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
+
+    /*!
+    @param[in,out] r  reference to a JSON value that is manipulated while
+                       parsing
+    @param[in] allow_exceptions_  whether parse errors yield exceptions
+    */
+    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true, lexer_t* lexer_ = nullptr)
+        : root(r), allow_exceptions(allow_exceptions_), m_lexer_ref(lexer_)
+    {}
+
+    // make class move-only
+    json_sax_dom_parser(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~json_sax_dom_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        // Manually set the start position of the object here.
+        // Ensure this is after the call to handle_value to ensure correct start position.
+        if (m_lexer_ref)
+        {
+            // Lexer has read the first character of the object, so
+            // subtract 1 from the position to get the correct start position.
+            ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
+        }
+#endif
+
+        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_object());
+
+        // add null at the given key and store the reference for later
+        object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val));
+        return true;
+    }
+
+    bool end_object()
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_object());
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        if (m_lexer_ref)
+        {
+            // Lexer's position is past the closing brace, so set that as the end position.
+            ref_stack.back()->end_position = m_lexer_ref->get_position();
+        }
+#endif
+
+        ref_stack.back()->set_parents();
+        ref_stack.pop_back();
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        // Manually set the start position of the array here.
+        // Ensure this is after the call to handle_value to ensure correct start position.
+        if (m_lexer_ref)
+        {
+            ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
+        }
+#endif
+
+        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_array());
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        if (m_lexer_ref)
+        {
+            // Lexer's position is past the closing bracket, so set that as the end position.
+            ref_stack.back()->end_position = m_lexer_ref->get_position();
+        }
+#endif
+
+        ref_stack.back()->set_parents();
+        ref_stack.pop_back();
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+
+#if JSON_DIAGNOSTIC_POSITIONS
+    void handle_diagnostic_positions_for_json_value(BasicJsonType& v)
+    {
+        if (m_lexer_ref)
+        {
+            // Lexer has read past the current field value, so set the end position to the current position.
+            // The start position will be set below based on the length of the string representation
+            // of the value.
+            v.end_position = m_lexer_ref->get_position();
+
+            switch (v.type())
+            {
+                case value_t::boolean:
+                {
+                    // 4 and 5 are the string length of "true" and "false"
+                    v.start_position = v.end_position - (v.m_data.m_value.boolean ? 4 : 5);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    // 4 is the string length of "null"
+                    v.start_position = v.end_position - 4;
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    // include the length of the quotes, which is 2
+                    v.start_position = v.end_position - v.m_data.m_value.string->size() - 2;
+                    break;
+                }
+
+                // As we handle the start and end positions for values created during parsing,
+                // we do not expect the following value type to be called. Regardless, set the positions
+                // in case this is created manually or through a different constructor. Exclude from lcov
+                // since the exact condition of this switch is esoteric.
+                // LCOV_EXCL_START
+                case value_t::discarded:
+                {
+                    v.end_position = std::string::npos;
+                    v.start_position = v.end_position;
+                    break;
+                }
+                // LCOV_EXCL_STOP
+                case value_t::binary:
+                case value_t::number_integer:
+                case value_t::number_unsigned:
+                case value_t::number_float:
+                {
+                    v.start_position = v.end_position - m_lexer_ref->get_string().size();
+                    break;
+                }
+                case value_t::object:
+                case value_t::array:
+                {
+                    // object and array are handled in start_object() and start_array() handlers
+                    // skip setting the values here.
+                    break;
+                }
+                default: // LCOV_EXCL_LINE
+                    // Handle all possible types discretely, default handler should never be reached.
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert,-warnings-as-errors) LCOV_EXCL_LINE
+            }
+        }
+    }
+#endif
+
+    /*!
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+    */
+    template<typename Value>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    BasicJsonType* handle_value(Value&& v)
+    {
+        if (ref_stack.empty())
+        {
+            root = BasicJsonType(std::forward<Value>(v));
+
+#if JSON_DIAGNOSTIC_POSITIONS
+            handle_diagnostic_positions_for_json_value(root);
+#endif
+
+            return &root;
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->emplace_back(std::forward<Value>(v));
+
+#if JSON_DIAGNOSTIC_POSITIONS
+            handle_diagnostic_positions_for_json_value(ref_stack.back()->m_data.m_value.array->back());
+#endif
+
+            return &(ref_stack.back()->m_data.m_value.array->back());
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_object());
+        JSON_ASSERT(object_element);
+        *object_element = BasicJsonType(std::forward<Value>(v));
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        handle_diagnostic_positions_for_json_value(*object_element);
+#endif
+
+        return object_element;
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+    /// the lexer reference to obtain the current position
+    lexer_t* m_lexer_ref = nullptr;
+};
+
+template<typename BasicJsonType, typename InputAdapterType>
+class json_sax_dom_callback_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using parser_callback_t = typename BasicJsonType::parser_callback_t;
+    using parse_event_t = typename BasicJsonType::parse_event_t;
+    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
+
+    json_sax_dom_callback_parser(BasicJsonType& r,
+                                 parser_callback_t cb,
+                                 const bool allow_exceptions_ = true,
+                                 lexer_t* lexer_ = nullptr)
+        : root(r), callback(std::move(cb)), allow_exceptions(allow_exceptions_), m_lexer_ref(lexer_)
+    {
+        keep_stack.push_back(true);
+    }
+
+    // make class move-only
+    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~json_sax_dom_callback_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        // check callback for object start
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::object, true);
+        ref_stack.push_back(val.second);
+
+        if (ref_stack.back())
+        {
+
+#if JSON_DIAGNOSTIC_POSITIONS
+            // Manually set the start position of the object here.
+            // Ensure this is after the call to handle_value to ensure correct start position.
+            if (m_lexer_ref)
+            {
+                // Lexer has read the first character of the object, so
+                // subtract 1 from the position to get the correct start position.
+                ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
+            }
+#endif
+
+            // check object limit
+            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
+            {
+                JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+            }
+        }
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        BasicJsonType k = BasicJsonType(val);
+
+        // check callback for the key
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
+        key_keep_stack.push_back(keep);
+
+        // add discarded value at the given key and store the reference for later
+        if (keep && ref_stack.back())
+        {
+            object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
+        }
+
+        return true;
+    }
+
+    bool end_object()
+    {
+        if (ref_stack.back())
+        {
+            if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
+            {
+                // discard object
+                *ref_stack.back() = discarded;
+
+#if JSON_DIAGNOSTIC_POSITIONS
+                // Set start/end positions for discarded object.
+                handle_diagnostic_positions_for_json_value(*ref_stack.back());
+#endif
+            }
+            else
+            {
+
+#if JSON_DIAGNOSTIC_POSITIONS
+                if (m_lexer_ref)
+                {
+                    // Lexer's position is past the closing brace, so set that as the end position.
+                    ref_stack.back()->end_position = m_lexer_ref->get_position();
+                }
+#endif
+
+                ref_stack.back()->set_parents();
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
+        {
+            // remove discarded value
+            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
+            {
+                if (it->is_discarded())
+                {
+                    ref_stack.back()->erase(it);
+                    break;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::array, true);
+        ref_stack.push_back(val.second);
+
+        if (ref_stack.back())
+        {
+
+#if JSON_DIAGNOSTIC_POSITIONS
+            // Manually set the start position of the array here.
+            // Ensure this is after the call to handle_value to ensure correct start position.
+            if (m_lexer_ref)
+            {
+                // Lexer has read the first character of the array, so
+                // subtract 1 from the position to get the correct start position.
+                ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
+            }
+#endif
+
+            // check array limit
+            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
+            {
+                JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+            }
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        bool keep = true;
+
+        if (ref_stack.back())
+        {
+            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
+            if (keep)
+            {
+
+#if JSON_DIAGNOSTIC_POSITIONS
+                if (m_lexer_ref)
+                {
+                    // Lexer's position is past the closing bracket, so set that as the end position.
+                    ref_stack.back()->end_position = m_lexer_ref->get_position();
+                }
+#endif
+
+                ref_stack.back()->set_parents();
+            }
+            else
+            {
+                // discard array
+                *ref_stack.back() = discarded;
+
+#if JSON_DIAGNOSTIC_POSITIONS
+                // Set start/end positions for discarded array.
+                handle_diagnostic_positions_for_json_value(*ref_stack.back());
+#endif
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        // remove discarded value
+        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->pop_back();
+        }
+
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+
+#if JSON_DIAGNOSTIC_POSITIONS
+    void handle_diagnostic_positions_for_json_value(BasicJsonType& v)
+    {
+        if (m_lexer_ref)
+        {
+            // Lexer has read past the current field value, so set the end position to the current position.
+            // The start position will be set below based on the length of the string representation
+            // of the value.
+            v.end_position = m_lexer_ref->get_position();
+
+            switch (v.type())
+            {
+                case value_t::boolean:
+                {
+                    // 4 and 5 are the string length of "true" and "false"
+                    v.start_position = v.end_position - (v.m_data.m_value.boolean ? 4 : 5);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    // 4 is the string length of "null"
+                    v.start_position = v.end_position - 4;
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    // include the length of the quotes, which is 2
+                    v.start_position = v.end_position - v.m_data.m_value.string->size() - 2;
+                    break;
+                }
+
+                case value_t::discarded:
+                {
+                    v.end_position = std::string::npos;
+                    v.start_position = v.end_position;
+                    break;
+                }
+
+                case value_t::binary:
+                case value_t::number_integer:
+                case value_t::number_unsigned:
+                case value_t::number_float:
+                {
+                    v.start_position = v.end_position - m_lexer_ref->get_string().size();
+                    break;
+                }
+
+                case value_t::object:
+                case value_t::array:
+                {
+                    // object and array are handled in start_object() and start_array() handlers
+                    // skip setting the values here.
+                    break;
+                }
+                default: // LCOV_EXCL_LINE
+                    // Handle all possible types discretely, default handler should never be reached.
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert,-warnings-as-errors) LCOV_EXCL_LINE
+            }
+        }
+    }
+#endif
+
+    /*!
+    @param[in] v  value to add to the JSON value we build during parsing
+    @param[in] skip_callback  whether we should skip calling the callback
+               function; this is required after start_array() and
+               start_object() SAX events, because otherwise we would call the
+               callback function with an empty array or object, respectively.
+
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+
+    @return pair of boolean (whether value should be kept) and pointer (to the
+            passed value in the ref_stack hierarchy; nullptr if not kept)
+    */
+    template<typename Value>
+    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
+    {
+        JSON_ASSERT(!keep_stack.empty());
+
+        // do not handle this value if we know it would be added to a discarded
+        // container
+        if (!keep_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // create value
+        auto value = BasicJsonType(std::forward<Value>(v));
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        handle_diagnostic_positions_for_json_value(value);
+#endif
+
+        // check callback
+        const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
+
+        // do not handle this value if we just learnt it shall be discarded
+        if (!keep)
+        {
+            return {false, nullptr};
+        }
+
+        if (ref_stack.empty())
+        {
+            root = std::move(value);
+            return {true, & root};
+        }
+
+        // skip this value if we already decided to skip the parent
+        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
+        if (!ref_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // we now only expect arrays and objects
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        // array
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
+            return {true, & (ref_stack.back()->m_data.m_value.array->back())};
+        }
+
+        // object
+        JSON_ASSERT(ref_stack.back()->is_object());
+        // check if we should store an element for the current key
+        JSON_ASSERT(!key_keep_stack.empty());
+        const bool store_element = key_keep_stack.back();
+        key_keep_stack.pop_back();
+
+        if (!store_element)
+        {
+            return {false, nullptr};
+        }
+
+        JSON_ASSERT(object_element);
+        *object_element = std::move(value);
+        return {true, object_element};
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// stack to manage which values to keep
+    std::vector<bool> keep_stack {}; // NOLINT(readability-redundant-member-init)
+    /// stack to manage which object keys to keep
+    std::vector<bool> key_keep_stack {}; // NOLINT(readability-redundant-member-init)
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+    /// a discarded value for the callback
+    BasicJsonType discarded = BasicJsonType::value_t::discarded;
+    /// the lexer reference to obtain the current position
+    lexer_t* m_lexer_ref = nullptr;
+};
+
+template<typename BasicJsonType>
+class json_sax_acceptor
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    bool null()
+    {
+        return true;
+    }
+
+    bool boolean(bool /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_integer(number_integer_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool string(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool binary(binary_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool start_object(std::size_t /*unused*/ = detail::unknown_size())
+    {
+        return true;
+    }
+
+    bool key(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool end_object()
+    {
+        return true;
+    }
+
+    bool start_array(std::size_t /*unused*/ = detail::unknown_size())
+    {
+        return true;
+    }
+
+    bool end_array()
+    {
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
+    {
+        return false;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstdint> // size_t
+#include <utility> // declval
+#include <string> // string
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename T>
+using null_function_t = decltype(std::declval<T&>().null());
+
+template<typename T>
+using boolean_function_t =
+    decltype(std::declval<T&>().boolean(std::declval<bool>()));
+
+template<typename T, typename Integer>
+using number_integer_function_t =
+    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
+
+template<typename T, typename Unsigned>
+using number_unsigned_function_t =
+    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
+
+template<typename T, typename Float, typename String>
+using number_float_function_t = decltype(std::declval<T&>().number_float(
+                                    std::declval<Float>(), std::declval<const String&>()));
+
+template<typename T, typename String>
+using string_function_t =
+    decltype(std::declval<T&>().string(std::declval<String&>()));
+
+template<typename T, typename Binary>
+using binary_function_t =
+    decltype(std::declval<T&>().binary(std::declval<Binary&>()));
+
+template<typename T>
+using start_object_function_t =
+    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
+
+template<typename T, typename String>
+using key_function_t =
+    decltype(std::declval<T&>().key(std::declval<String&>()));
+
+template<typename T>
+using end_object_function_t = decltype(std::declval<T&>().end_object());
+
+template<typename T>
+using start_array_function_t =
+    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
+
+template<typename T>
+using end_array_function_t = decltype(std::declval<T&>().end_array());
+
+template<typename T, typename Exception>
+using parse_error_function_t = decltype(std::declval<T&>().parse_error(
+        std::declval<std::size_t>(), std::declval<const std::string&>(),
+        std::declval<const Exception&>()));
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static constexpr bool value =
+        is_detected_exact<bool, null_function_t, SAX>::value &&
+        is_detected_exact<bool, boolean_function_t, SAX>::value &&
+        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
+        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
+        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
+        is_detected_exact<bool, start_object_function_t, SAX>::value &&
+        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, end_object_function_t, SAX>::value &&
+        is_detected_exact<bool, start_array_function_t, SAX>::value &&
+        is_detected_exact<bool, end_array_function_t, SAX>::value &&
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
+};
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax_static_asserts
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
+                  "Missing/invalid function: bool null()");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(
+        is_detected_exact<bool, number_integer_function_t, SAX,
+        number_integer_t>::value,
+        "Missing/invalid function: bool number_integer(number_integer_t)");
+    static_assert(
+        is_detected_exact<bool, number_unsigned_function_t, SAX,
+        number_unsigned_t>::value,
+        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
+    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
+                  number_float_t, string_t>::value,
+                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
+    static_assert(
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
+        "Missing/invalid function: bool string(string_t&)");
+    static_assert(
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
+        "Missing/invalid function: bool binary(binary_t&)");
+    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_object(std::size_t)");
+    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
+                  "Missing/invalid function: bool key(string_t&)");
+    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_object()");
+    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_array(std::size_t)");
+    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_array()");
+    static_assert(
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
+        "Missing/invalid function: bool parse_error(std::size_t, const "
+        "std::string&, const exception&)");
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// how to treat CBOR tags
+enum class cbor_tag_handler_t
+{
+    error,   ///< throw a parse_error exception in case of a tag
+    ignore,  ///< ignore tags
+    store    ///< store tags as binary type
+};
+
+/*!
+@brief determine system byte order
+
+@return true if and only if system's byte order is little endian
+
+@note from https://stackoverflow.com/a/1001328/266378
+*/
+inline bool little_endianness(int num = 1) noexcept
+{
+    return *reinterpret_cast<char*>(&num) == 1;
+}
+
+///////////////////
+// binary reader //
+///////////////////
+
+/*!
+@brief deserialization of CBOR, MessagePack, and UBJSON values
+*/
+template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType, InputAdapterType>>
+class binary_reader
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using json_sax_t = SAX;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename char_traits<char_type>::int_type;
+
+  public:
+    /*!
+    @brief create a binary reader
+
+    @param[in] adapter  input adapter to read from
+    */
+    explicit binary_reader(InputAdapterType&& adapter, const input_format_t format = input_format_t::json) noexcept : ia(std::move(adapter)), input_format(format)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+    }
+
+    // make class move-only
+    binary_reader(const binary_reader&) = delete;
+    binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    binary_reader& operator=(const binary_reader&) = delete;
+    binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~binary_reader() = default;
+
+    /*!
+    @param[in] format  the binary format to parse
+    @param[in] sax_    a SAX event processor
+    @param[in] strict  whether to expect the input to be consumed completed
+    @param[in] tag_handler  how to treat CBOR tags
+
+    @return whether parsing was successful
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool sax_parse(const input_format_t format,
+                   json_sax_t* sax_,
+                   const bool strict = true,
+                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        sax = sax_;
+        bool result = false;
+
+        switch (format)
+        {
+            case input_format_t::bson:
+                result = parse_bson_internal();
+                break;
+
+            case input_format_t::cbor:
+                result = parse_cbor_internal(true, tag_handler);
+                break;
+
+            case input_format_t::msgpack:
+                result = parse_msgpack_internal();
+                break;
+
+            case input_format_t::ubjson:
+            case input_format_t::bjdata:
+                result = parse_ubjson_internal();
+                break;
+
+            case input_format_t::json: // LCOV_EXCL_LINE
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+        // strict mode: next byte must be EOF
+        if (result && strict)
+        {
+            if (input_format == input_format_t::ubjson || input_format == input_format_t::bjdata)
+            {
+                get_ignore_noop();
+            }
+            else
+            {
+                get();
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(current != char_traits<char_type>::eof()))
+            {
+                return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read,
+                                        exception_message(input_format, concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr));
+            }
+        }
+
+        return result;
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @brief Reads in a BSON-object and passes it to the SAX-parser.
+    @return whether a valid BSON-value was passed to the SAX parser
+    */
+    bool parse_bson_internal()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
+        {
+            return false;
+        }
+
+        return sax->end_object();
+    }
+
+    /*!
+    @brief Parses a C-style string from the BSON input.
+    @param[in,out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @return `true` if the \x00-byte indicating the end of the string was
+             encountered before the EOF; false` indicates an unexpected EOF.
+    */
+    bool get_bson_cstr(string_t& result)
+    {
+        auto out = std::back_inserter(result);
+        while (true)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
+            {
+                return false;
+            }
+            if (current == 0x00)
+            {
+                return true;
+            }
+            *out++ = static_cast<typename string_t::value_type>(current);
+        }
+    }
+
+    /*!
+    @brief Parses a zero-terminated string of length @a len from the BSON
+           input.
+    @param[in] len  The length (including the zero-byte at the end) of the
+                    string to be read.
+    @param[in,out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 1
+    @return `true` if the string was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_string(const NumberType len, string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 1))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr));
+        }
+
+        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != char_traits<char_type>::eof();
+    }
+
+    /*!
+    @brief Parses a byte array input of length @a len from the BSON input.
+    @param[in] len  The length of the byte array to be read.
+    @param[in,out] result  A reference to the binary variable where the read
+                            array is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 0
+    @return `true` if the byte array was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_binary(const NumberType len, binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 0))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr));
+        }
+
+        // All BSON binary values have a subtype
+        std::uint8_t subtype{};
+        get_number<std::uint8_t>(input_format_t::bson, subtype);
+        result.set_subtype(subtype);
+
+        return get_binary(input_format_t::bson, len, result);
+    }
+
+    /*!
+    @brief Read a BSON document element of the given @a element_type.
+    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
+    @param[in] element_type_parse_position The position in the input stream,
+               where the `element_type` was read.
+    @warning Not all BSON element types are supported yet. An unsupported
+             @a element_type will give rise to a parse_error.114:
+             Unsupported BSON record type 0x...
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_internal(const char_int_type element_type,
+                                     const std::size_t element_type_parse_position)
+    {
+        switch (element_type)
+        {
+            case 0x01: // double
+            {
+                double number{};
+                return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0x02: // string
+            {
+                std::int32_t len{};
+                string_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
+            }
+
+            case 0x03: // object
+            {
+                return parse_bson_internal();
+            }
+
+            case 0x04: // array
+            {
+                return parse_bson_array();
+            }
+
+            case 0x05: // binary
+            {
+                std::int32_t len{};
+                binary_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
+            }
+
+            case 0x08: // boolean
+            {
+                return sax->boolean(get() != 0);
+            }
+
+            case 0x0A: // null
+            {
+                return sax->null();
+            }
+
+            case 0x10: // int32
+            {
+                std::int32_t value{};
+                return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            case 0x12: // int64
+            {
+                std::int64_t value{};
+                return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            case 0x11: // uint64
+            {
+                std::uint64_t value{};
+                return get_number<std::uint64_t, true>(input_format_t::bson, value) && sax->number_unsigned(value);
+            }
+
+            default: // anything else is not supported (yet)
+            {
+                std::array<char, 3> cr{{}};
+                static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                const std::string cr_str{cr.data()};
+                return sax->parse_error(element_type_parse_position, cr_str,
+                                        parse_error::create(114, element_type_parse_position, concat("Unsupported BSON record type 0x", cr_str), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief Read a BSON element list (as specified in the BSON-spec)
+
+    The same binary layout is used for objects and arrays, hence it must be
+    indicated with the argument @a is_array which one is expected
+    (true --> array, false --> object).
+
+    @param[in] is_array Determines if the element list being read is to be
+                        treated as an object (@a is_array == false), or as an
+                        array (@a is_array == true).
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_list(const bool is_array)
+    {
+        string_t key;
+
+        while (auto element_type = get())
+        {
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
+            {
+                return false;
+            }
+
+            const std::size_t element_type_parse_position = chars_read;
+            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
+            {
+                return false;
+            }
+
+            if (!is_array && !sax->key(key))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
+            {
+                return false;
+            }
+
+            // get_bson_cstr only appends
+            key.clear();
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief Reads an array from the BSON input and passes it to the SAX-parser.
+    @return whether a valid BSON-array was passed to the SAX parser
+    */
+    bool parse_bson_array()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
+        {
+            return false;
+        }
+
+        return sax->end_array();
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true) or whether the last read character should
+                         be considered instead (false)
+    @param[in] tag_handler how CBOR tags should be treated
+
+    @return whether a valid CBOR value was passed to the SAX parser
+    */
+    bool parse_cbor_internal(const bool get_char,
+                             const cbor_tag_handler_t tag_handler)
+    {
+        switch (get_char ? get() : current)
+        {
+            // EOF
+            case char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::cbor, "value");
+
+            // Integer 0x00..0x17 (0..23)
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            case 0x18: // Unsigned integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x19: // Unsigned integer (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            // Negative integer -1-0x00..-1-0x17 (-1..-24)
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
+
+            case 0x38: // Negative integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
+                        - static_cast<number_integer_t>(number));
+            }
+
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            case 0x5F: // Binary data (indefinite length)
+            {
+                binary_t b;
+                return get_cbor_binary(b) && sax->binary(b);
+            }
+
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                string_t s;
+                return get_cbor_string(s) && sax->string(s);
+            }
+
+            // array (0x00..0x17 data items follow)
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+                return get_cbor_array(
+                           conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0x98: // array (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x99: // array (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9A: // array (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9B: // array (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9F: // array (indefinite length)
+                return get_cbor_array(detail::unknown_size(), tag_handler);
+
+            // map (0x00..0x17 pairs of data items follow)
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+                return get_cbor_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0xB8: // map (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xB9: // map (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBA: // map (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBB: // map (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBF: // map (indefinite length)
+                return get_cbor_object(detail::unknown_size(), tag_handler);
+
+            case 0xC6: // tagged item
+            case 0xC7:
+            case 0xC8:
+            case 0xC9:
+            case 0xCA:
+            case 0xCB:
+            case 0xCC:
+            case 0xCD:
+            case 0xCE:
+            case 0xCF:
+            case 0xD0:
+            case 0xD1:
+            case 0xD2:
+            case 0xD3:
+            case 0xD4:
+            case 0xD8: // tagged item (1 byte follows)
+            case 0xD9: // tagged item (2 bytes follow)
+            case 0xDA: // tagged item (4 bytes follow)
+            case 0xDB: // tagged item (8 bytes follow)
+            {
+                switch (tag_handler)
+                {
+                    case cbor_tag_handler_t::error:
+                    {
+                        auto last_token = get_token_string();
+                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                                exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
+                    }
+
+                    case cbor_tag_handler_t::ignore:
+                    {
+                        // ignore binary subtype
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            default:
+                                break;
+                        }
+                        return parse_cbor_internal(true, tag_handler);
+                    }
+
+                    case cbor_tag_handler_t::store:
+                    {
+                        binary_t b;
+                        // use binary subtype and store in a binary container
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            default:
+                                return parse_cbor_internal(true, tag_handler);
+                        }
+                        get();
+                        return get_cbor_binary(b) && sax->binary(b);
+                    }
+
+                    default:                 // LCOV_EXCL_LINE
+                        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+                        return false;        // LCOV_EXCL_LINE
+                }
+            }
+
+            case 0xF4: // false
+                return sax->boolean(false);
+
+            case 0xF5: // true
+                return sax->boolean(true);
+
+            case 0xF6: // null
+                return sax->null();
+
+            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
+            {
+                const auto byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+                const auto byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // Code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
+            {
+                float number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
+            {
+                double number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            default: // anything else (0xFF is handled inside the other types)
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+    Additionally, CBOR's strings with indefinite lengths are supported.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_cbor_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            {
+                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    string_t chunk;
+                    if (!get_cbor_string(chunk))
+                    {
+                        return false;
+                    }
+                    result.append(chunk);
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::cbor, concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into the byte array.
+    Additionally, CBOR's byte arrays with indefinite lengths are supported.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_cbor_binary(binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            {
+                return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5F: // Binary data (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    binary_t chunk;
+                    if (!get_cbor_binary(chunk))
+                    {
+                        return false;
+                    }
+                    result.insert(result.end(), chunk.begin(), chunk.end());
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::cbor, concat("expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x", last_token), "binary"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array or detail::unknown_size() for an
+                    array of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether array creation completed
+    */
+    bool get_cbor_array(const std::size_t len,
+                        const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        if (len != detail::unknown_size())
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object or detail::unknown_size() for an
+                    object of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether object creation completed
+    */
+    bool get_cbor_object(const std::size_t len,
+                         const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        if (len != 0)
+        {
+            string_t key;
+            if (len != detail::unknown_size())
+            {
+                for (std::size_t i = 0; i < len; ++i)
+                {
+                    get();
+                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                while (get() != 0xFF)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    /*!
+    @return whether a valid MessagePack value was passed to the SAX parser
+    */
+    bool parse_msgpack_internal()
+    {
+        switch (get())
+        {
+            // EOF
+            case char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::msgpack, "value");
+
+            // positive fixint
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+            case 0x18:
+            case 0x19:
+            case 0x1A:
+            case 0x1B:
+            case 0x1C:
+            case 0x1D:
+            case 0x1E:
+            case 0x1F:
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+            case 0x38:
+            case 0x39:
+            case 0x3A:
+            case 0x3B:
+            case 0x3C:
+            case 0x3D:
+            case 0x3E:
+            case 0x3F:
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58:
+            case 0x59:
+            case 0x5A:
+            case 0x5B:
+            case 0x5C:
+            case 0x5D:
+            case 0x5E:
+            case 0x5F:
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78:
+            case 0x79:
+            case 0x7A:
+            case 0x7B:
+            case 0x7C:
+            case 0x7D:
+            case 0x7E:
+            case 0x7F:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            // fixmap
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+                return get_msgpack_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixarray
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+            case 0x98:
+            case 0x99:
+            case 0x9A:
+            case 0x9B:
+            case 0x9C:
+            case 0x9D:
+            case 0x9E:
+            case 0x9F:
+                return get_msgpack_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            case 0xD9: // str 8
+            case 0xDA: // str 16
+            case 0xDB: // str 32
+            {
+                string_t s;
+                return get_msgpack_string(s) && sax->string(s);
+            }
+
+            case 0xC0: // nil
+                return sax->null();
+
+            case 0xC2: // false
+                return sax->boolean(false);
+
+            case 0xC3: // true
+                return sax->boolean(true);
+
+            case 0xC4: // bin 8
+            case 0xC5: // bin 16
+            case 0xC6: // bin 32
+            case 0xC7: // ext 8
+            case 0xC8: // ext 16
+            case 0xC9: // ext 32
+            case 0xD4: // fixext 1
+            case 0xD5: // fixext 2
+            case 0xD6: // fixext 4
+            case 0xD7: // fixext 8
+            case 0xD8: // fixext 16
+            {
+                binary_t b;
+                return get_msgpack_binary(b) && sax->binary(b);
+            }
+
+            case 0xCA: // float 32
+            {
+                float number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCB: // float 64
+            {
+                double number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCC: // uint 8
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCD: // uint 16
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCE: // uint 32
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCF: // uint 64
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xD0: // int 8
+            {
+                std::int8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD1: // int 16
+            {
+                std::int16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD2: // int 32
+            {
+                std::int32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD3: // int 64
+            {
+                std::int64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xDC: // array 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDD: // array 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(conditional_static_cast<std::size_t>(len));
+            }
+
+            case 0xDE: // map 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xDF: // map 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(conditional_static_cast<std::size_t>(len));
+            }
+
+            // negative fixint
+            case 0xE0:
+            case 0xE1:
+            case 0xE2:
+            case 0xE3:
+            case 0xE4:
+            case 0xE5:
+            case 0xE6:
+            case 0xE7:
+            case 0xE8:
+            case 0xE9:
+            case 0xEA:
+            case 0xEB:
+            case 0xEC:
+            case 0xED:
+            case 0xEE:
+            case 0xEF:
+            case 0xF0:
+            case 0xF1:
+            case 0xF2:
+            case 0xF3:
+            case 0xF4:
+            case 0xF5:
+            case 0xF6:
+            case 0xF7:
+            case 0xF8:
+            case 0xF9:
+            case 0xFA:
+            case 0xFB:
+            case 0xFC:
+            case 0xFD:
+            case 0xFE:
+            case 0xFF:
+                return sax->number_integer(static_cast<std::int8_t>(current));
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format_t::msgpack, concat("invalid byte: 0x", last_token), "value"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_msgpack_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            {
+                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0xD9: // str 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDA: // str 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDB: // str 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::msgpack, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into a byte array.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_msgpack_binary(binary_t& result)
+    {
+        // helper function to set the subtype
+        auto assign_and_return_true = [&result](std::int8_t subtype)
+        {
+            result.set_subtype(static_cast<std::uint8_t>(subtype));
+            return true;
+        };
+
+        switch (current)
+        {
+            case 0xC4: // bin 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC5: // bin 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC6: // bin 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC7: // ext 8
+            {
+                std::uint8_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC8: // ext 16
+            {
+                std::uint16_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC9: // ext 32
+            {
+                std::uint32_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD4: // fixext 1
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 1, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD5: // fixext 2
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 2, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD6: // fixext 4
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 4, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD7: // fixext 8
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 8, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD8: // fixext 16
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 16, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            default:           // LCOV_EXCL_LINE
+                return false;  // LCOV_EXCL_LINE
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array
+    @return whether array creation completed
+    */
+    bool get_msgpack_array(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object
+    @return whether object creation completed
+    */
+    bool get_msgpack_object(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+            key.clear();
+        }
+
+        return sax->end_object();
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether a valid UBJSON value was passed to the SAX parser
+    */
+    bool parse_ubjson_internal(const bool get_char = true)
+    {
+        return get_ubjson_value(get_char ? get_ignore_noop() : current);
+    }
+
+    /*!
+    @brief reads a UBJSON string
+
+    This function is either called after reading the 'S' byte explicitly
+    indicating a string, or in case of an object key where the 'S' byte can be
+    left out.
+
+    @param[out] result   created string
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether string creation completed
+    */
+    bool get_ubjson_string(string_t& result, const bool get_char = true)
+    {
+        if (get_char)
+        {
+            get();  // TODO(niels): may we ignore N here?
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            case 'U':
+            {
+                std::uint8_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'i':
+            {
+                std::int8_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'I':
+            {
+                std::int16_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'l':
+            {
+                std::int32_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'L':
+            {
+                std::int64_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            default:
+                break;
+        }
+        auto last_token = get_token_string();
+        std::string message;
+
+        if (input_format != input_format_t::bjdata)
+        {
+            message = "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token;
+        }
+        else
+        {
+            message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token;
+        }
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr));
+    }
+
+    /*!
+    @param[out] dim  an integer vector storing the ND array dimensions
+    @return whether reading ND array size vector is successful
+    */
+    bool get_ubjson_ndarray_size(std::vector<size_t>& dim)
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        size_t dimlen = 0;
+        bool no_ndarray = true;
+
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type, no_ndarray)))
+        {
+            return false;
+        }
+
+        if (size_and_type.first != npos)
+        {
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, size_and_type.second)))
+                        {
+                            return false;
+                        }
+                        dim.push_back(dimlen);
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray)))
+                    {
+                        return false;
+                    }
+                    dim.push_back(dimlen);
+                }
+            }
+        }
+        else
+        {
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, current)))
+                {
+                    return false;
+                }
+                dim.push_back(dimlen);
+                get_ignore_noop();
+            }
+        }
+        return true;
+    }
+
+    /*!
+    @param[out] result  determined size
+    @param[in,out] is_ndarray  for input, `true` means already inside an ndarray vector
+                               or ndarray dimension is not allowed; `false` means ndarray
+                               is allowed; for output, `true` means an ndarray is found;
+                               is_ndarray can only return `true` when its initial value
+                               is `false`
+    @param[in] prefix  type marker if already read, otherwise set to 0
+
+    @return whether size determination completed
+    */
+    bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0)
+    {
+        if (prefix == 0)
+        {
+            prefix = get_ignore_noop();
+        }
+
+        switch (prefix)
+        {
+            case 'U':
+            {
+                std::uint8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
+                return true;
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                if (!value_in_range_of<std::size_t>(number))
+                {
+                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
+                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = conditional_static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (!value_in_range_of<std::size_t>(number))
+                {
+                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
+                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
+                }
+                result = detail::conditional_static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case '[':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                if (is_ndarray) // ndarray dimensional vector can only contain integers and cannot embed another array
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message(input_format, "ndarray dimensional vector is not allowed", "size"), nullptr));
+                }
+                std::vector<size_t> dim;
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim)))
+                {
+                    return false;
+                }
+                if (dim.size() == 1 || (dim.size() == 2 && dim.at(0) == 1)) // return normal array size if 1D row vector
+                {
+                    result = dim.at(dim.size() - 1);
+                    return true;
+                }
+                if (!dim.empty())  // if ndarray, convert to an object in JData annotated array format
+                {
+                    for (auto i : dim) // test if any dimension in an ndarray is 0, if so, return a 1D empty container
+                    {
+                        if ( i == 0 )
+                        {
+                            result = 0;
+                            return true;
+                        }
+                    }
+
+                    string_t key = "_ArraySize_";
+                    if (JSON_HEDLEY_UNLIKELY(!sax->start_object(3) || !sax->key(key) || !sax->start_array(dim.size())))
+                    {
+                        return false;
+                    }
+                    result = 1;
+                    for (auto i : dim)
+                    {
+                        // Pre-multiplication overflow check: if i > 0 and result > SIZE_MAX/i, then result*i would overflow.
+                        // This check must happen before multiplication since overflow detection after the fact is unreliable
+                        // as modular arithmetic can produce any value, not just 0 or SIZE_MAX.
+                        if (JSON_HEDLEY_UNLIKELY(i > 0 && result > (std::numeric_limits<std::size_t>::max)() / i))
+                        {
+                            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr));
+                        }
+                        result *= i;
+                        // Additional post-multiplication check to catch any edge cases the pre-check might miss
+                        if (result == 0 || result == npos)
+                        {
+                            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(static_cast<number_unsigned_t>(i))))
+                        {
+                            return false;
+                        }
+                    }
+                    is_ndarray = true;
+                    return sax->end_array();
+                }
+                result = 0;
+                return true;
+            }
+
+            default:
+                break;
+        }
+        auto last_token = get_token_string();
+        std::string message;
+
+        if (input_format != input_format_t::bjdata)
+        {
+            message = "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token;
+        }
+        else
+        {
+            message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token;
+        }
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr));
+    }
+
+    /*!
+    @brief determine the type and size for a container
+
+    In the optimized UBJSON format, a type and a size can be provided to allow
+    for a more compact representation.
+
+    @param[out] result  pair of the size and the type
+    @param[in] inside_ndarray  whether the parser is parsing an ND array dimensional vector
+
+    @return whether pair creation completed
+    */
+    bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result, bool inside_ndarray = false)
+    {
+        result.first = npos; // size
+        result.second = 0; // type
+        bool is_ndarray = false;
+
+        get_ignore_noop();
+
+        if (current == '$')
+        {
+            result.second = get();  // must not ignore 'N', because 'N' maybe the type
+            if (input_format == input_format_t::bjdata
+                    && JSON_HEDLEY_UNLIKELY(std::binary_search(bjd_optimized_type_markers.begin(), bjd_optimized_type_markers.end(), result.second)))
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr));
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type")))
+            {
+                return false;
+            }
+
+            get_ignore_noop();
+            if (JSON_HEDLEY_UNLIKELY(current != '#'))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
+                {
+                    return false;
+                }
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr));
+            }
+
+            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
+            if (input_format == input_format_t::bjdata && is_ndarray)
+            {
+                if (inside_ndarray)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
+                                            exception_message(input_format, "ndarray can not be recursive", "size"), nullptr));
+                }
+                result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON and BJData markers should be ASCII letters
+            }
+            return is_error;
+        }
+
+        if (current == '#')
+        {
+            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
+            if (input_format == input_format_t::bjdata && is_ndarray)
+            {
+                return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
+                                        exception_message(input_format, "ndarray requires both type and size", "size"), nullptr));
+            }
+            return is_error;
+        }
+
+        return true;
+    }
+
+    /*!
+    @param prefix  the previously read or set type prefix
+    @return whether value creation completed
+    */
+    bool get_ubjson_value(const char_int_type prefix)
+    {
+        switch (prefix)
+        {
+            case char_traits<char_type>::eof():  // EOF
+                return unexpect_eof(input_format, "value");
+
+            case 'T':  // true
+                return sax->boolean(true);
+            case 'F':  // false
+                return sax->boolean(false);
+
+            case 'Z':  // null
+                return sax->null();
+
+            case 'B':  // byte
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint8_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'U':
+            {
+                std::uint8_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'h':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                const auto byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+                {
+                    return false;
+                }
+                const auto byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // Code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte2 << 8u) + byte1);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 'd':
+            {
+                float number{};
+                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'D':
+            {
+                double number{};
+                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'H':
+            {
+                return get_ubjson_high_precision_number();
+            }
+
+            case 'C':  // char
+            {
+                get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char")))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(current > 127))
+                {
+                    auto last_token = get_token_string();
+                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                            exception_message(input_format, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr));
+                }
+                string_t s(1, static_cast<typename string_t::value_type>(current));
+                return sax->string(s);
+            }
+
+            case 'S':  // string
+            {
+                string_t s;
+                return get_ubjson_string(s) && sax->string(s);
+            }
+
+            case '[':  // array
+                return get_ubjson_array();
+
+            case '{':  // object
+                return get_ubjson_object();
+
+            default: // anything else
+                break;
+        }
+        auto last_token = get_token_string();
+        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format, "invalid byte: 0x" + last_token, "value"), nullptr));
+    }
+
+    /*!
+    @return whether array creation completed
+    */
+    bool get_ubjson_array()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        // if bit-8 of size_and_type.second is set to 1, encode bjdata ndarray as an object in JData annotated array format (https://github.com/NeuroJSON/jdata):
+        // {"_ArrayType_" : "typeid", "_ArraySize_" : [n1, n2, ...], "_ArrayData_" : [v1, v2, ...]}
+
+        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
+        {
+            size_and_type.second &= ~(static_cast<char_int_type>(1) << 8);  // use bit 8 to indicate ndarray, here we remove the bit to restore the type marker
+            auto it = std::lower_bound(bjd_types_map.begin(), bjd_types_map.end(), size_and_type.second, [](const bjd_type & p, char_int_type t)
+            {
+                return p.first < t;
+            });
+            string_t key = "_ArrayType_";
+            if (JSON_HEDLEY_UNLIKELY(it == bjd_types_map.end() || it->first != size_and_type.second))
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, "invalid byte: 0x" + last_token, "type"), nullptr));
+            }
+
+            string_t type = it->second; // sax->string() takes a reference
+            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->string(type)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second == 'C' || size_and_type.second == 'B')
+            {
+                size_and_type.second = 'U';
+            }
+
+            key = "_ArrayData_";
+            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->start_array(size_and_type.first) ))
+            {
+                return false;
+            }
+
+            for (std::size_t i = 0; i < size_and_type.first; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                {
+                    return false;
+                }
+            }
+
+            return (sax->end_array() && sax->end_object());
+        }
+
+        // If BJData type marker is 'B' decode as binary
+        if (input_format == input_format_t::bjdata && size_and_type.first != npos && size_and_type.second == 'B')
+        {
+            binary_t result;
+            return get_binary(input_format, size_and_type.first, result) && sax->binary(result);
+        }
+
+        if (size_and_type.first != npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
+            {
+                return false;
+            }
+
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @return whether object creation completed
+    */
+    bool get_ubjson_object()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        // do not accept ND-array size in objects in BJData
+        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format, "BJData object does not support ND-array size in optimized format", "object"), nullptr));
+        }
+
+        string_t key;
+        if (size_and_type.first != npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
+            {
+                return false;
+            }
+
+            while (current != '}')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    // Note, no reader for UBJSON binary types is implemented because they do
+    // not exist
+
+    bool get_ubjson_high_precision_number()
+    {
+        // get the size of the following number string
+        std::size_t size{};
+        bool no_ndarray = true;
+        auto res = get_ubjson_size_value(size, no_ndarray);
+        if (JSON_HEDLEY_UNLIKELY(!res))
+        {
+            return res;
+        }
+
+        // get number string
+        std::vector<char> number_vector;
+        for (std::size_t i = 0; i < size; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+            {
+                return false;
+            }
+            number_vector.push_back(static_cast<char>(current));
+        }
+
+        // parse number string
+        using ia_type = decltype(detail::input_adapter(number_vector));
+        auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);
+        const auto result_number = number_lexer.scan();
+        const auto number_string = number_lexer.get_token_string();
+        const auto result_remainder = number_lexer.scan();
+
+        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
+
+        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
+        {
+            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
+                                    exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
+        }
+
+        switch (result_number)
+        {
+            case token_type::value_integer:
+                return sax->number_integer(number_lexer.get_number_integer());
+            case token_type::value_unsigned:
+                return sax->number_unsigned(number_lexer.get_number_unsigned());
+            case token_type::value_float:
+                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
+            case token_type::uninitialized:
+            case token_type::literal_true:
+            case token_type::literal_false:
+            case token_type::literal_null:
+            case token_type::value_string:
+            case token_type::begin_array:
+            case token_type::begin_object:
+            case token_type::end_array:
+            case token_type::end_object:
+            case token_type::name_separator:
+            case token_type::value_separator:
+            case token_type::parse_error:
+            case token_type::end_of_input:
+            case token_type::literal_or_value:
+            default:
+                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
+                                        exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
+        }
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*!
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a -'ve valued
+    `char_traits<char_type>::eof()` in that case.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++chars_read;
+        return current = ia.get_character();
+    }
+
+    /*!
+    @brief get_to read into a primitive type
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns false instead
+
+    @return bool, whether the read was successful
+    */
+    template<class T>
+    bool get_to(T& dest, const input_format_t format, const char* context)
+    {
+        auto new_chars_read = ia.get_elements(&dest);
+        chars_read += new_chars_read;
+        if (JSON_HEDLEY_UNLIKELY(new_chars_read < sizeof(T)))
+        {
+            // in case of failure, advance position by 1 to report the failing location
+            ++chars_read;
+            sax->parse_error(chars_read, "<end of file>", parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr));
+            return false;
+        }
+        return true;
+    }
+
+    /*!
+    @return character read from the input after ignoring all 'N' entries
+    */
+    char_int_type get_ignore_noop()
+    {
+        do
+        {
+            get();
+        }
+        while (current == 'N');
+
+        return current;
+    }
+
+    template<class NumberType>
+    static void byte_swap(NumberType& number)
+    {
+        constexpr std::size_t sz = sizeof(number);
+#ifdef __cpp_lib_byteswap
+        if constexpr (sz == 1)
+        {
+            return;
+        }
+        else if constexpr(std::is_integral_v<NumberType>)
+        {
+            number = std::byteswap(number);
+            return;
+        }
+        else
+        {
+#endif
+            auto* ptr = reinterpret_cast<std::uint8_t*>(&number);
+            for (std::size_t i = 0; i < sz / 2; ++i)
+            {
+                std::swap(ptr[i], ptr[sz - i - 1]);
+            }
+#ifdef __cpp_lib_byteswap
+        }
+#endif
+    }
+
+    /*
+    @brief read a number from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format   the current format (for diagnostics)
+    @param[out] result  number of type @a NumberType
+
+    @return whether conversion completed
+
+    @note This function needs to respect the system's endianness, because
+          bytes in CBOR, MessagePack, and UBJSON are stored in network order
+          (big endian) and therefore need reordering on little endian systems.
+          On the other hand, BSON and BJData use little endian and should reorder
+          on big endian systems.
+    */
+    template<typename NumberType, bool InputIsLittleEndian = false>
+    bool get_number(const input_format_t format, NumberType& result)
+    {
+        // read in the original format
+
+        if (JSON_HEDLEY_UNLIKELY(!get_to(result, format, "number")))
+        {
+            return false;
+        }
+        if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata))
+        {
+            byte_swap(result);
+        }
+        return true;
+    }
+
+    /*!
+    @brief create a string by reading characters from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of characters to read
+    @param[out] result string created by reading @a len bytes
+
+    @return whether string creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of string memory.
+    */
+    template<typename NumberType>
+    bool get_string(const input_format_t format,
+                    const NumberType len,
+                    string_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<typename string_t::value_type>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @brief create a byte array by reading bytes from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of bytes to read
+    @param[out] result byte array created by reading @a len bytes
+
+    @return whether byte array creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of memory.
+    */
+    template<typename NumberType>
+    bool get_binary(const input_format_t format,
+                    const NumberType len,
+                    binary_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<std::uint8_t>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @param[in] format   the current format (for diagnostics)
+    @param[in] context  further context information (for diagnostics)
+    @return whether the last read character is not EOF
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool unexpect_eof(const input_format_t format, const char* context) const
+    {
+        if (JSON_HEDLEY_UNLIKELY(current == char_traits<char_type>::eof()))
+        {
+            return sax->parse_error(chars_read, "<end of file>",
+                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr));
+        }
+        return true;
+    }
+
+    /*!
+    @return a string representation of the last read byte
+    */
+    std::string get_token_string() const
+    {
+        std::array<char, 3> cr{{}};
+        static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        return std::string{cr.data()};
+    }
+
+    /*!
+    @param[in] format   the current format
+    @param[in] detail   a detailed error message
+    @param[in] context  further context information
+    @return a message string to use in the parse_error exceptions
+    */
+    std::string exception_message(const input_format_t format,
+                                  const std::string& detail,
+                                  const std::string& context) const
+    {
+        std::string error_msg = "syntax error while parsing ";
+
+        switch (format)
+        {
+            case input_format_t::cbor:
+                error_msg += "CBOR";
+                break;
+
+            case input_format_t::msgpack:
+                error_msg += "MessagePack";
+                break;
+
+            case input_format_t::ubjson:
+                error_msg += "UBJSON";
+                break;
+
+            case input_format_t::bson:
+                error_msg += "BSON";
+                break;
+
+            case input_format_t::bjdata:
+                error_msg += "BJData";
+                break;
+
+            case input_format_t::json: // LCOV_EXCL_LINE
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+        return concat(error_msg, ' ', context, ": ", detail);
+    }
+
+  private:
+    static JSON_INLINE_VARIABLE constexpr std::size_t npos = detail::unknown_size();
+
+    /// input adapter
+    InputAdapterType ia;
+
+    /// the current character
+    char_int_type current = char_traits<char_type>::eof();
+
+    /// the number of characters read
+    std::size_t chars_read = 0;
+
+    /// whether we can assume little endianness
+    const bool is_little_endian = little_endianness();
+
+    /// input format
+    const input_format_t input_format = input_format_t::json;
+
+    /// the SAX parser
+    json_sax_t* sax = nullptr;
+
+    // excluded markers in bjdata optimized type
+#define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ \
+    make_array<char_int_type>('F', 'H', 'N', 'S', 'T', 'Z', '[', '{')
+
+#define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ \
+    make_array<bjd_type>(                      \
+    bjd_type{'B', "byte"},                     \
+    bjd_type{'C', "char"},                     \
+    bjd_type{'D', "double"},                   \
+    bjd_type{'I', "int16"},                    \
+    bjd_type{'L', "int64"},                    \
+    bjd_type{'M', "uint64"},                   \
+    bjd_type{'U', "uint8"},                    \
+    bjd_type{'d', "single"},                   \
+    bjd_type{'i', "int8"},                     \
+    bjd_type{'l', "int32"},                    \
+    bjd_type{'m', "uint32"},                   \
+    bjd_type{'u', "uint16"})
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // lookup tables
+    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
+    const decltype(JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_) bjd_optimized_type_markers =
+        JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_;
+
+    using bjd_type = std::pair<char_int_type, string_t>;
+    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
+    const decltype(JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_) bjd_types_map =
+        JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_;
+
+#undef JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_
+#undef JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_
+};
+
+#ifndef JSON_HAS_CPP_17
+    template<typename BasicJsonType, typename InputAdapterType, typename SAX>
+    constexpr std::size_t binary_reader<BasicJsonType, InputAdapterType, SAX>::npos;
+#endif
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/input/parser.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cmath> // isfinite
+#include <cstdint> // uint8_t
+#include <functional> // function
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+////////////
+// parser //
+////////////
+
+enum class parse_event_t : std::uint8_t
+{
+    /// the parser read `{` and started to process a JSON object
+    object_start,
+    /// the parser read `}` and finished processing a JSON object
+    object_end,
+    /// the parser read `[` and started to process a JSON array
+    array_start,
+    /// the parser read `]` and finished processing a JSON array
+    array_end,
+    /// the parser read a key of a value in an object
+    key,
+    /// the parser finished reading a JSON value
+    value
+};
+
+template<typename BasicJsonType>
+using parser_callback_t =
+    std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;
+
+/*!
+@brief syntax analysis
+
+This class implements a recursive descent parser.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class parser
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
+    using token_type = typename lexer_t::token_type;
+
+  public:
+    /// a parser reading from an input adapter
+    explicit parser(InputAdapterType&& adapter,
+                    parser_callback_t<BasicJsonType> cb = nullptr,
+                    const bool allow_exceptions_ = true,
+                    const bool skip_comments = false)
+        : callback(std::move(cb))
+        , m_lexer(std::move(adapter), skip_comments)
+        , allow_exceptions(allow_exceptions_)
+    {
+        // read first token
+        get_token();
+    }
+
+    /*!
+    @brief public parser interface
+
+    @param[in] strict      whether to expect the last token to be EOF
+    @param[in,out] result  parsed JSON value
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+    */
+    void parse(const bool strict, BasicJsonType& result)
+    {
+        if (callback)
+        {
+            json_sax_dom_callback_parser<BasicJsonType, InputAdapterType> sdp(result, callback, allow_exceptions, &m_lexer);
+            sax_parse_internal(&sdp);
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value"), nullptr));
+            }
+
+            // in case of an error, return a discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+
+            // set top-level value to null if it was discarded by the callback
+            // function
+            if (result.is_discarded())
+            {
+                result = nullptr;
+            }
+        }
+        else
+        {
+            json_sax_dom_parser<BasicJsonType, InputAdapterType> sdp(result, allow_exceptions, &m_lexer);
+            sax_parse_internal(&sdp);
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
+            }
+
+            // in case of an error, return a discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+        }
+
+        result.assert_invariant();
+    }
+
+    /*!
+    @brief public accept interface
+
+    @param[in] strict  whether to expect the last token to be EOF
+    @return whether the input is a proper JSON text
+    */
+    bool accept(const bool strict = true)
+    {
+        json_sax_acceptor<BasicJsonType> sax_acceptor;
+        return sax_parse(&sax_acceptor, strict);
+    }
+
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse(SAX* sax, const bool strict = true)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+        const bool result = sax_parse_internal(sax);
+
+        // strict mode: next byte must be EOF
+        if (result && strict && (get_token() != token_type::end_of_input))
+        {
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
+        }
+
+        return result;
+    }
+
+  private:
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse_internal(SAX* sax)
+    {
+        // stack to remember the hierarchy of structured values we are parsing
+        // true = array; false = object
+        std::vector<bool> states;
+        // value to avoid a goto (see comment where set to true)
+        bool skip_to_state_evaluation = false;
+
+        while (true)
+        {
+            if (!skip_to_state_evaluation)
+            {
+                // invariant: get_token() was called before each iteration
+                switch (last_token)
+                {
+                    case token_type::begin_object:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
+                        {
+                            return false;
+                        }
+
+                        // closing } -> we are done
+                        if (get_token() == token_type::end_object)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // parse key
+                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        // parse separator (:)
+                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
+                        }
+
+                        // remember we are now inside an object
+                        states.push_back(false);
+
+                        // parse values
+                        get_token();
+                        continue;
+                    }
+
+                    case token_type::begin_array:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
+                        {
+                            return false;
+                        }
+
+                        // closing ] -> we are done
+                        if (get_token() == token_type::end_array)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // remember we are now inside an array
+                        states.push_back(true);
+
+                        // parse values (no need to call get_token)
+                        continue;
+                    }
+
+                    case token_type::value_float:
+                    {
+                        const auto res = m_lexer.get_number_float();
+
+                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
+                        }
+
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        break;
+                    }
+
+                    case token_type::literal_false:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_null:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_true:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_integer:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_string:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_unsigned:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::parse_error:
+                    {
+                        // using "uninitialized" to avoid an "expected" message
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr));
+                    }
+                    case token_type::end_of_input:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
+                        }
+
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
+                    }
+                    case token_type::uninitialized:
+                    case token_type::end_array:
+                    case token_type::end_object:
+                    case token_type::name_separator:
+                    case token_type::value_separator:
+                    case token_type::literal_or_value:
+                    default: // the last token was unexpected
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
+                    }
+                }
+            }
+            else
+            {
+                skip_to_state_evaluation = false;
+            }
+
+            // we reached this line after we successfully parsed a value
+            if (states.empty())
+            {
+                // empty stack: we reached the end of the hierarchy: done
+                return true;
+            }
+
+            if (states.back())  // array
+            {
+                // comma -> next value
+                if (get_token() == token_type::value_separator)
+                {
+                    // parse a new value
+                    get_token();
+                    continue;
+                }
+
+                // closing ]
+                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                    {
+                        return false;
+                    }
+
+                    // We are done with this array. Before we can parse a
+                    // new value, we need to evaluate the new state first.
+                    // By setting skip_to_state_evaluation to false, we
+                    // are effectively jumping to the beginning of this if.
+                    JSON_ASSERT(!states.empty());
+                    states.pop_back();
+                    skip_to_state_evaluation = true;
+                    continue;
+                }
+
+                return sax->parse_error(m_lexer.get_position(),
+                                        m_lexer.get_token_string(),
+                                        parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr));
+            }
+
+            // states.back() is false -> object
+
+            // comma -> next value
+            if (get_token() == token_type::value_separator)
+            {
+                // parse key
+                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
+                {
+                    return sax->parse_error(m_lexer.get_position(),
+                                            m_lexer.get_token_string(),
+                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
+                }
+
+                if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                {
+                    return false;
+                }
+
+                // parse separator (:)
+                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                {
+                    return sax->parse_error(m_lexer.get_position(),
+                                            m_lexer.get_token_string(),
+                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
+                }
+
+                // parse values
+                get_token();
+                continue;
+            }
+
+            // closing }
+            if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                {
+                    return false;
+                }
+
+                // We are done with this object. Before we can parse a
+                // new value, we need to evaluate the new state first.
+                // By setting skip_to_state_evaluation to false, we
+                // are effectively jumping to the beginning of this if.
+                JSON_ASSERT(!states.empty());
+                states.pop_back();
+                skip_to_state_evaluation = true;
+                continue;
+            }
+
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr));
+        }
+    }
+
+    /// get next token from lexer
+    token_type get_token()
+    {
+        return last_token = m_lexer.scan();
+    }
+
+    std::string exception_message(const token_type expected, const std::string& context)
+    {
+        std::string error_msg = "syntax error ";
+
+        if (!context.empty())
+        {
+            error_msg += concat("while parsing ", context, ' ');
+        }
+
+        error_msg += "- ";
+
+        if (last_token == token_type::parse_error)
+        {
+            error_msg += concat(m_lexer.get_error_message(), "; last read: '",
+                                m_lexer.get_token_string(), '\'');
+        }
+        else
+        {
+            error_msg += concat("unexpected ", lexer_t::token_type_name(last_token));
+        }
+
+        if (expected != token_type::uninitialized)
+        {
+            error_msg += concat("; expected ", lexer_t::token_type_name(expected));
+        }
+
+        return error_msg;
+    }
+
+  private:
+    /// callback function
+    const parser_callback_t<BasicJsonType> callback = nullptr;
+    /// the type of the last read token
+    token_type last_token = token_type::uninitialized;
+    /// the lexer
+    lexer_t m_lexer;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // ptrdiff_t
+#include <limits>  // numeric_limits
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*
+@brief an iterator for primitive JSON types
+
+This class models an iterator for primitive JSON types (boolean, number,
+string). Its only purpose is to allow the iterator/const_iterator classes
+to "iterate" over primitive values. Internally, the iterator is modeled by
+a `difference_type` variable. Value begin_value (`0`) models the begin and
+end_value (`1`) models past the end.
+*/
+class primitive_iterator_t
+{
+  private:
+    using difference_type = std::ptrdiff_t;
+    static constexpr difference_type begin_value = 0;
+    static constexpr difference_type end_value = begin_value + 1;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// iterator as signed integer type
+    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
+
+  public:
+    constexpr difference_type get_value() const noexcept
+    {
+        return m_it;
+    }
+
+    /// set iterator to a defined beginning
+    void set_begin() noexcept
+    {
+        m_it = begin_value;
+    }
+
+    /// set iterator to a defined past the end
+    void set_end() noexcept
+    {
+        m_it = end_value;
+    }
+
+    /// return whether the iterator can be dereferenced
+    constexpr bool is_begin() const noexcept
+    {
+        return m_it == begin_value;
+    }
+
+    /// return whether the iterator is at end
+    constexpr bool is_end() const noexcept
+    {
+        return m_it == end_value;
+    }
+
+    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it == rhs.m_it;
+    }
+
+    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it < rhs.m_it;
+    }
+
+    primitive_iterator_t operator+(difference_type n) noexcept
+    {
+        auto result = *this;
+        result += n;
+        return result;
+    }
+
+    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it - rhs.m_it;
+    }
+
+    primitive_iterator_t& operator++() noexcept
+    {
+        ++m_it;
+        return *this;
+    }
+
+    primitive_iterator_t operator++(int)& noexcept // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        ++m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator--() noexcept
+    {
+        --m_it;
+        return *this;
+    }
+
+    primitive_iterator_t operator--(int)& noexcept // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        --m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator+=(difference_type n) noexcept
+    {
+        m_it += n;
+        return *this;
+    }
+
+    primitive_iterator_t& operator-=(difference_type n) noexcept
+    {
+        m_it -= n;
+        return *this;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief an iterator value
+
+@note This structure could easily be a union, but MSVC currently does not allow
+unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
+*/
+template<typename BasicJsonType> struct internal_iterator
+{
+    /// iterator for JSON objects
+    typename BasicJsonType::object_t::iterator object_iterator {};
+    /// iterator for JSON arrays
+    typename BasicJsonType::array_t::iterator array_iterator {};
+    /// generic iterator for all other types
+    primitive_iterator_t primitive_iterator {};
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/iter_impl.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
+#include <type_traits> // conditional, is_const, remove_const
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// forward declare to be able to friend it later on
+template<typename IteratorType> class iteration_proxy;
+template<typename IteratorType> class iteration_proxy_value;
+
+/*!
+@brief a template for a bidirectional iterator for the @ref basic_json class
+This class implements a both iterators (iterator and const_iterator) for the
+@ref basic_json class.
+@note An iterator is called *initialized* when a pointer to a JSON value has
+      been set (e.g., by a constructor or a copy assignment). If the iterator is
+      default-constructed, it is *uninitialized* and most methods are undefined.
+      **The library uses assertions to detect calls on uninitialized iterators.**
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
+       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
+*/
+template<typename BasicJsonType>
+class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+{
+    /// the iterator with BasicJsonType of different const-ness
+    using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
+    /// allow basic_json to access private members
+    friend other_iter_impl;
+    friend BasicJsonType;
+    friend iteration_proxy<iter_impl>;
+    friend iteration_proxy_value<iter_impl>;
+
+    using object_t = typename BasicJsonType::object_t;
+    using array_t = typename BasicJsonType::array_t;
+    // make sure BasicJsonType is basic_json or const basic_json
+    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
+                  "iter_impl only accepts (const) basic_json");
+    // superficial check for the LegacyBidirectionalIterator named requirement
+    static_assert(std::is_base_of<std::bidirectional_iterator_tag, std::bidirectional_iterator_tag>::value
+                  &&  std::is_base_of<std::bidirectional_iterator_tag, typename std::iterator_traits<typename array_t::iterator>::iterator_category>::value,
+                  "basic_json iterator assumes array and object type iterators satisfy the LegacyBidirectionalIterator named requirement.");
+
+  public:
+    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
+    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
+    /// A user-defined iterator should provide publicly accessible typedefs named
+    /// iterator_category, value_type, difference_type, pointer, and reference.
+    /// Note that value_type is required to be non-const, even for constant iterators.
+    using iterator_category = std::bidirectional_iterator_tag;
+
+    /// the type of the values when the iterator is dereferenced
+    using value_type = typename BasicJsonType::value_type;
+    /// a type to represent differences between iterators
+    using difference_type = typename BasicJsonType::difference_type;
+    /// defines a pointer to the type iterated over (value_type)
+    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
+          typename BasicJsonType::const_pointer,
+          typename BasicJsonType::pointer>::type;
+    /// defines a reference to the type iterated over (value_type)
+    using reference =
+        typename std::conditional<std::is_const<BasicJsonType>::value,
+        typename BasicJsonType::const_reference,
+        typename BasicJsonType::reference>::type;
+
+    iter_impl() = default;
+    ~iter_impl() = default;
+    iter_impl(iter_impl&&) noexcept = default;
+    iter_impl& operator=(iter_impl&&) noexcept = default;
+
+    /*!
+    @brief constructor for a given JSON instance
+    @param[in] object  pointer to a JSON object for this iterator
+    @pre object != nullptr
+    @post The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    explicit iter_impl(pointer object) noexcept : m_object(object)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = typename object_t::iterator();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = typename array_t::iterator();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator = primitive_iterator_t();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @note The conventional copy constructor and copy assignment are implicitly
+          defined. Combined with the following converting constructor and
+          assignment, they support: (1) copy from iterator to iterator, (2)
+          copy from const iterator to const iterator, and (3) conversion from
+          iterator to const iterator. However conversion from const iterator
+          to iterator is not defined.
+    */
+
+    /*!
+    @brief const copy constructor
+    @param[in] other const iterator to copy from
+    @note This copy constructor had to be defined explicitly to circumvent a bug
+          occurring on msvc v19.0 compiler (VS 2015) debug build. For more
+          information refer to: https://github.com/nlohmann/json/issues/1608
+    */
+    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
+    {
+        if (&other != this)
+        {
+            m_object = other.m_object;
+            m_it = other.m_it;
+        }
+        return *this;
+    }
+
+    /*!
+    @brief converting constructor
+    @param[in] other  non-const iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other  non-const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
+    {
+        m_object = other.m_object;
+        m_it = other.m_it;
+        return *this;
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief set the iterator to the first value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_begin() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_data.m_value.object->begin();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_data.m_value.array->begin();
+                break;
+            }
+
+            case value_t::null:
+            {
+                // set to end so begin()==end() is true: null is empty
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator.set_begin();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @brief set the iterator past the last value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_end() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_data.m_value.object->end();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_data.m_value.array->end();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+        }
+    }
+
+  public:
+    /*!
+    @brief return a reference to the value pointed to by the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator*() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
+                return m_it.object_iterator->second;
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
+                return *m_it.array_iterator;
+            }
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief dereference the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    pointer operator->() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
+                return &(m_it.object_iterator->second);
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
+                return &*m_it.array_iterator;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief post-increment (it++)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        ++(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-increment (++it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator++()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, 1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, 1);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                ++m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief post-decrement (it--)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator--(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        --(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-decrement (--it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator--()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, -1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, -1);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                --m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief comparison: equal
+    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
+    */
+    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
+    bool operator==(const IterImpl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
+        }
+
+        // value-initialized forward iterators can be compared, and must compare equal to other value-initialized iterators of the same type #4493
+        if (m_object == nullptr)
+        {
+            return true;
+        }
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                return (m_it.object_iterator == other.m_it.object_iterator);
+
+            case value_t::array:
+                return (m_it.array_iterator == other.m_it.array_iterator);
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief comparison: not equal
+    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
+    */
+    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
+    bool operator!=(const IterImpl& other) const
+    {
+        return !operator==(other);
+    }
+
+    /*!
+    @brief comparison: smaller
+    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
+    */
+    bool operator<(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
+        }
+
+        // value-initialized forward iterators can be compared, and must compare equal to other value-initialized iterators of the same type #4493
+        if (m_object == nullptr)
+        {
+            // the iterators are both value-initialized and are to be considered equal, but this function checks for smaller, so we return false
+            return false;
+        }
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", m_object));
+
+            case value_t::array:
+                return (m_it.array_iterator < other.m_it.array_iterator);
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
+    */
+    bool operator<=(const iter_impl& other) const
+    {
+        return !other.operator < (*this);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
+    */
+    bool operator>(const iter_impl& other) const
+    {
+        return !operator<=(other);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @pre (1) The iterator is initialized; i.e. `m_object != nullptr`, or (2) both iterators are value-initialized.
+    */
+    bool operator>=(const iter_impl& other) const
+    {
+        return !operator<(other);
+    }
+
+    /*!
+    @brief add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator+=(difference_type i)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, i);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator += i;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator-=(difference_type i)
+    {
+        return operator+=(-i);
+    }
+
+    /*!
+    @brief add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator+(difference_type i) const
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief addition of distance and iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    friend iter_impl operator+(difference_type i, const iter_impl& it)
+    {
+        auto result = it;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator-(difference_type i) const
+    {
+        auto result = *this;
+        result -= i;
+        return result;
+    }
+
+    /*!
+    @brief return difference
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    difference_type operator-(const iter_impl& other) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
+
+            case value_t::array:
+                return m_it.array_iterator - other.m_it.array_iterator;
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return m_it.primitive_iterator - other.m_it.primitive_iterator;
+        }
+    }
+
+    /*!
+    @brief access to successor
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator[](difference_type n) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", m_object));
+
+            case value_t::array:
+                return *std::next(m_it.array_iterator, n);
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief return the key of an object iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    const typename object_t::key_type& key() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
+        {
+            return m_it.object_iterator->first;
+        }
+
+        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
+    }
+
+    /*!
+    @brief return the value of an iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference value() const
+    {
+        return operator*();
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// associated JSON instance
+    pointer m_object = nullptr;
+    /// the actual iterator of the associated instance
+    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // ptrdiff_t
+#include <iterator> // reverse_iterator
+#include <utility> // declval
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+//////////////////////
+// reverse_iterator //
+//////////////////////
+
+/*!
+@brief a template for a reverse iterator class
+
+@tparam Base the base iterator type to reverse. Valid types are @ref
+iterator (to create @ref reverse_iterator) and @ref const_iterator (to
+create @ref const_reverse_iterator).
+
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
+  It is possible to write to the pointed-to element (only if @a Base is
+  @ref iterator).
+
+@since version 1.0.0
+*/
+template<typename Base>
+class json_reverse_iterator : public std::reverse_iterator<Base>
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    /// shortcut to the reverse iterator adapter
+    using base_iterator = std::reverse_iterator<Base>;
+    /// the reference type for the pointed-to element
+    using reference = typename Base::reference;
+
+    /// create reverse iterator from iterator
+    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
+        : base_iterator(it) {}
+
+    /// create reverse iterator from base class
+    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
+
+    /// post-increment (it++)
+    json_reverse_iterator operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
+    }
+
+    /// pre-increment (++it)
+    json_reverse_iterator& operator++()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
+    }
+
+    /// post-decrement (it--)
+    json_reverse_iterator operator--(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
+    }
+
+    /// pre-decrement (--it)
+    json_reverse_iterator& operator--()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
+    }
+
+    /// add to iterator
+    json_reverse_iterator& operator+=(difference_type i)
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
+    }
+
+    /// add to iterator
+    json_reverse_iterator operator+(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
+    }
+
+    /// subtract from iterator
+    json_reverse_iterator operator-(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
+    }
+
+    /// return difference
+    difference_type operator-(const json_reverse_iterator& other) const
+    {
+        return base_iterator(*this) - base_iterator(other);
+    }
+
+    /// access to successor
+    reference operator[](difference_type n) const
+    {
+        return *(this->operator+(n));
+    }
+
+    /// return the key of an object iterator
+    auto key() const -> decltype(std::declval<Base>().key())
+    {
+        auto it = --this->base();
+        return it.key();
+    }
+
+    /// return the value of an iterator
+    reference value() const
+    {
+        auto it = --this->base();
+        return it.operator * ();
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/json_custom_base_class.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <type_traits> // conditional, is_same
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief Default base class of the @ref basic_json class.
+
+So that the correct implementations of the copy / move ctors / assign operators
+of @ref basic_json do not require complex case distinctions
+(no base class / custom base class used as customization point),
+@ref basic_json always has a base class.
+By default, this class is used because it is empty and thus has no effect
+on the behavior of @ref basic_json.
+*/
+struct json_default_base {};
+
+template<class T>
+using json_base_class = typename std::conditional <
+                        std::is_same<T, void>::value,
+                        json_default_base,
+                        T
+                        >::type;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/json_pointer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // all_of
+#include <cctype> // isdigit
+#include <cerrno> // errno, ERANGE
+#include <cstdlib> // strtoull
+#ifndef JSON_NO_IO
+    #include <iosfwd> // ostream
+#endif  // JSON_NO_IO
+#include <limits> // max
+#include <numeric> // accumulate
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/string_escape.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+/// @sa https://json.nlohmann.me/api/json_pointer/
+template<typename RefStringType>
+class json_pointer
+{
+    // allow basic_json to access private members
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    friend class basic_json;
+
+    template<typename>
+    friend class json_pointer;
+
+    template<typename T>
+    struct string_t_helper
+    {
+        using type = T;
+    };
+
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    struct string_t_helper<NLOHMANN_BASIC_JSON_TPL>
+    {
+        using type = StringType;
+    };
+
+  public:
+    // for backwards compatibility accept BasicJsonType
+    using string_t = typename string_t_helper<RefStringType>::type;
+
+    /// @brief create JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/
+    explicit json_pointer(const string_t& s = "")
+        : reference_tokens(split(s))
+    {}
+
+    /// @brief return a string representation of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
+    string_t to_string() const
+    {
+        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
+                               string_t{},
+                               [](const string_t& a, const string_t& b)
+        {
+            return detail::concat(a, '/', detail::escape(b));
+        });
+    }
+
+    /// @brief return a string representation of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
+    operator string_t() const
+    {
+        return to_string();
+    }
+
+#ifndef JSON_NO_IO
+    /// @brief write string representation of the JSON pointer to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr)
+    {
+        o << ptr.to_string();
+        return o;
+    }
+#endif
+
+    /// @brief append another JSON pointer at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(const json_pointer& ptr)
+    {
+        reference_tokens.insert(reference_tokens.end(),
+                                ptr.reference_tokens.begin(),
+                                ptr.reference_tokens.end());
+        return *this;
+    }
+
+    /// @brief append an unescaped reference token at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(string_t token)
+    {
+        push_back(std::move(token));
+        return *this;
+    }
+
+    /// @brief append an array index at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(std::size_t array_idx)
+    {
+        return *this /= std::to_string(array_idx);
+    }
+
+    /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs,
+                                  const json_pointer& rhs)
+    {
+        return json_pointer(lhs) /= rhs;
+    }
+
+    /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs, string_t token) // NOLINT(performance-unnecessary-value-param)
+    {
+        return json_pointer(lhs) /= std::move(token);
+    }
+
+    /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
+    {
+        return json_pointer(lhs) /= array_idx;
+    }
+
+    /// @brief returns the parent of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/
+    json_pointer parent_pointer() const
+    {
+        if (empty())
+        {
+            return *this;
+        }
+
+        json_pointer res = *this;
+        res.pop_back();
+        return res;
+    }
+
+    /// @brief remove last reference token
+    /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/
+    void pop_back()
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        reference_tokens.pop_back();
+    }
+
+    /// @brief return last reference token
+    /// @sa https://json.nlohmann.me/api/json_pointer/back/
+    const string_t& back() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        return reference_tokens.back();
+    }
+
+    /// @brief append an unescaped token at the end of the reference pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
+    void push_back(const string_t& token)
+    {
+        reference_tokens.push_back(token);
+    }
+
+    /// @brief append an unescaped token at the end of the reference pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
+    void push_back(string_t&& token)
+    {
+        reference_tokens.push_back(std::move(token));
+    }
+
+    /// @brief return whether pointer points to the root document
+    /// @sa https://json.nlohmann.me/api/json_pointer/empty/
+    bool empty() const noexcept
+    {
+        return reference_tokens.empty();
+    }
+
+  private:
+    /*!
+    @param[in] s  reference token to be converted into an array index
+
+    @return integer representation of @a s
+
+    @throw parse_error.106  if an array index begins with '0'
+    @throw parse_error.109  if an array index begins not with a digit
+    @throw out_of_range.404 if string @a s could not be converted to an integer
+    @throw out_of_range.410 if an array index exceeds size_type
+    */
+    template<typename BasicJsonType>
+    static typename BasicJsonType::size_type array_index(const string_t& s)
+    {
+        using size_type = typename BasicJsonType::size_type;
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
+        {
+            JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr));
+        }
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
+        {
+            JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr));
+        }
+
+        const char* p = s.c_str();
+        char* p_end = nullptr; // NOLINT(misc-const-correctness)
+        errno = 0; // strtoull doesn't reset errno
+        const unsigned long long res = std::strtoull(p, &p_end, 10); // NOLINT(runtime/int)
+        if (p == p_end // invalid input or empty string
+                || errno == ERANGE // out of range
+                || JSON_HEDLEY_UNLIKELY(static_cast<std::size_t>(p_end - p) != s.size())) // incomplete read
+        {
+            JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr));
+        }
+
+        // only triggered on special platforms (like 32bit), see also
+        // https://github.com/nlohmann/json/pull/2203
+        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))  // NOLINT(runtime/int)
+        {
+            JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr));   // LCOV_EXCL_LINE
+        }
+
+        return static_cast<size_type>(res);
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    json_pointer top() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        json_pointer result = *this;
+        result.reference_tokens = {reference_tokens[0]};
+        return result;
+    }
+
+  private:
+    /*!
+    @brief create and return a reference to the pointed to value
+
+    @complexity Linear in the number of reference tokens.
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.313 if value cannot be unflattened
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_and_create(BasicJsonType& j) const
+    {
+        auto* result = &j;
+
+        // in case no reference tokens exist, return a reference to the JSON value
+        // j which will be overwritten by a primitive value
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (result->type())
+            {
+                case detail::value_t::null:
+                {
+                    if (reference_token == "0")
+                    {
+                        // start a new array if the reference token is 0
+                        result = &result->operator[](0);
+                    }
+                    else
+                    {
+                        // start a new object otherwise
+                        result = &result->operator[](reference_token);
+                    }
+                    break;
+                }
+
+                case detail::value_t::object:
+                {
+                    // create an entry in the object
+                    result = &result->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    // create an entry in the array
+                    result = &result->operator[](array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                /*
+                The following code is only reached if there exists a reference
+                token _and_ the current value is primitive. In this case, we have
+                an error situation, because primitive values may only occur as
+                a single value; that is, with an empty list of reference tokens.
+                */
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));
+            }
+        }
+
+        return *result;
+    }
+
+    /*!
+    @brief return a reference to the pointed to value
+
+    @note This version does not throw if a value is not present, but tries to
+          create nested values instead. For instance, calling this function
+          with pointer `"/this/that"` on a null value is equivalent to calling
+          `operator[]("this").operator[]("that")` on that value, effectively
+          changing the null value to an object.
+
+    @param[in] ptr  a JSON value
+
+    @return reference to the JSON value pointed to by the JSON pointer
+
+    @complexity Linear in the length of the JSON pointer.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            // convert null values to arrays or objects before continuing
+            if (ptr->is_null())
+            {
+                // check if the reference token is a number
+                const bool nums =
+                    std::all_of(reference_token.begin(), reference_token.end(),
+                                [](const unsigned char x)
+                {
+                    return std::isdigit(x);
+                });
+
+                // change value to an array for numbers or "-" or to object otherwise
+                *ptr = (nums || reference_token == "-")
+                       ? detail::value_t::array
+                       : detail::value_t::object;
+            }
+
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // explicitly treat "-" as index beyond the end
+                        ptr = &ptr->operator[](ptr->m_data.m_value.array->size());
+                    }
+                    else
+                    {
+                        // convert array index to number; unchecked access
+                        ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
+                    }
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_checked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
+                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
+                                ") is out of range"), ptr));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @brief return a const reference to the pointed to value
+
+    @param[in] ptr  a JSON value
+
+    @return const reference to the JSON value pointed to by the JSON
+    pointer
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" cannot be used for const access
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr));
+                    }
+
+                    // use unchecked array access
+                    ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
+                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
+                                ") is out of range"), ptr));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    */
+    template<typename BasicJsonType>
+    bool contains(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    if (!ptr->contains(reference_token))
+                    {
+                        // we did not find the key in the object
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
+                    {
+                        // invalid char
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
+                        {
+                            // the first char should be between '1' and '9'
+                            return false;
+                        }
+                        for (std::size_t i = 1; i < reference_token.size(); i++)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
+                            {
+                                // other char should be between '0' and '9'
+                                return false;
+                            }
+                        }
+                    }
+
+                    const auto idx = array_index<BasicJsonType>(reference_token);
+                    if (idx >= ptr->size())
+                    {
+                        // index out of range
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](idx);
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                {
+                    // we do not expect primitive values if there is still a
+                    // reference token to process
+                    return false;
+                }
+            }
+        }
+
+        // no reference token left means we found a primitive value
+        return true;
+    }
+
+    /*!
+    @brief split the string input to reference tokens
+
+    @note This function is only called by the json_pointer constructor.
+          All exceptions below are documented there.
+
+    @throw parse_error.107  if the pointer is not empty or begins with '/'
+    @throw parse_error.108  if character '~' is not followed by '0' or '1'
+    */
+    static std::vector<string_t> split(const string_t& reference_string)
+    {
+        std::vector<string_t> result;
+
+        // special case: empty reference string -> no reference tokens
+        if (reference_string.empty())
+        {
+            return result;
+        }
+
+        // check if a nonempty reference string begins with slash
+        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
+        {
+            JSON_THROW(detail::parse_error::create(107, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr));
+        }
+
+        // extract the reference tokens:
+        // - slash: position of the last read slash (or end of string)
+        // - start: position after the previous slash
+        for (
+            // search for the first slash after the first character
+            std::size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == 0 (if slash == string_t::npos)
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == string_t::npos)
+            start = (slash == string_t::npos) ? 0 : slash + 1,
+            // find next slash
+            slash = reference_string.find_first_of('/', start))
+        {
+            // use the text between the beginning of the reference token
+            // (start) and the last slash (slash).
+            auto reference_token = reference_string.substr(start, slash - start);
+
+            // check reference tokens are properly escaped
+            for (std::size_t pos = reference_token.find_first_of('~');
+                    pos != string_t::npos;
+                    pos = reference_token.find_first_of('~', pos + 1))
+            {
+                JSON_ASSERT(reference_token[pos] == '~');
+
+                // ~ must be followed by 0 or 1
+                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
+                                         (reference_token[pos + 1] != '0' &&
+                                          reference_token[pos + 1] != '1')))
+                {
+                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", nullptr));
+                }
+            }
+
+            // finally, store the reference token
+            detail::unescape(reference_token);
+            result.push_back(reference_token);
+        }
+
+        return result;
+    }
+
+  private:
+    /*!
+    @param[in] reference_string  the reference string to the current value
+    @param[in] value             the value to consider
+    @param[in,out] result        the result object to insert values to
+
+    @note Empty objects or arrays are flattened to `null`.
+    */
+    template<typename BasicJsonType>
+    static void flatten(const string_t& reference_string,
+                        const BasicJsonType& value,
+                        BasicJsonType& result)
+    {
+        switch (value.type())
+        {
+            case detail::value_t::array:
+            {
+                if (value.m_data.m_value.array->empty())
+                {
+                    // flatten empty array as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate array and use index as a reference string
+                    for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i)
+                    {
+                        flatten(detail::concat<string_t>(reference_string, '/', std::to_string(i)),
+                                value.m_data.m_value.array->operator[](i), result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::object:
+            {
+                if (value.m_data.m_value.object->empty())
+                {
+                    // flatten empty object as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate object and use keys as reference string
+                    for (const auto& element : *value.m_data.m_value.object)
+                    {
+                        flatten(detail::concat<string_t>(reference_string, '/', detail::escape(element.first)), element.second, result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::null:
+            case detail::value_t::string:
+            case detail::value_t::boolean:
+            case detail::value_t::number_integer:
+            case detail::value_t::number_unsigned:
+            case detail::value_t::number_float:
+            case detail::value_t::binary:
+            case detail::value_t::discarded:
+            default:
+            {
+                // add a primitive value with its reference string
+                result[reference_string] = value;
+                break;
+            }
+        }
+    }
+
+    /*!
+    @param[in] value  flattened JSON
+
+    @return unflattened JSON
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+    @throw type_error.313  if value cannot be unflattened
+    */
+    template<typename BasicJsonType>
+    static BasicJsonType
+    unflatten(const BasicJsonType& value)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
+        {
+            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", &value));
+        }
+
+        BasicJsonType result;
+
+        // iterate the JSON object values
+        for (const auto& element : *value.m_data.m_value.object)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
+            {
+                JSON_THROW(detail::type_error::create(315, "values in object must be primitive", &element.second));
+            }
+
+            // Assign the value to the reference pointed to by JSON pointer. Note
+            // that if the JSON pointer is "" (i.e., points to the whole value),
+            // function get_and_create returns a reference to the result itself.
+            // An assignment will then create a primitive value.
+            json_pointer(element.first).get_and_create(result) = element.second;
+        }
+
+        return result;
+    }
+
+    // can't use the conversion operator because of ambiguity
+    json_pointer<string_t> convert() const&
+    {
+        json_pointer<string_t> result;
+        result.reference_tokens = reference_tokens;
+        return result;
+    }
+
+    json_pointer<string_t> convert()&&
+    {
+        json_pointer<string_t> result;
+        result.reference_tokens = std::move(reference_tokens);
+        return result;
+    }
+
+  public:
+#if JSON_HAS_THREE_WAY_COMPARISON
+    /// @brief compares two JSON pointers for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeRhs>
+    bool operator==(const json_pointer<RefStringTypeRhs>& rhs) const noexcept
+    {
+        return reference_tokens == rhs.reference_tokens;
+    }
+
+    /// @brief compares JSON pointer and string for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
+    bool operator==(const string_t& rhs) const
+    {
+        return *this == json_pointer(rhs);
+    }
+
+    /// @brief 3-way compares two JSON pointers
+    template<typename RefStringTypeRhs>
+    std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept // *NOPAD*
+    {
+        return  reference_tokens <=> rhs.reference_tokens; // *NOPAD*
+    }
+#else
+    /// @brief compares two JSON pointers for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+
+    /// @brief compares JSON pointer and string for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeLhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                           const StringType& rhs);
+
+    /// @brief compares string and JSON pointer for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeRhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const StringType& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs);
+
+    /// @brief compares two JSON pointers for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+
+    /// @brief compares JSON pointer and string for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeLhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                           const StringType& rhs);
+
+    /// @brief compares string and JSON pointer for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeRhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const StringType& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs);
+
+    /// @brief compares two JSON pointer for less-than
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
+                          const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+#endif
+
+  private:
+    /// the reference tokens
+    std::vector<string_t> reference_tokens;
+};
+
+#if !JSON_HAS_THREE_WAY_COMPARISON
+// functions cannot be defined inside the class due to ODR violations
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return lhs.reference_tokens == rhs.reference_tokens;
+}
+
+template<typename RefStringTypeLhs,
+         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
+inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                       const StringType& rhs)
+{
+    return lhs == json_pointer<RefStringTypeLhs>(rhs);
+}
+
+template<typename RefStringTypeRhs,
+         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
+inline bool operator==(const StringType& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs)
+{
+    return json_pointer<RefStringTypeRhs>(lhs) == rhs;
+}
+
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeLhs,
+         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
+inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                       const StringType& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeRhs,
+         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
+inline bool operator!=(const StringType& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
+                      const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return lhs.reference_tokens < rhs.reference_tokens;
+}
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/json_ref.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <initializer_list>
+#include <utility>
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename BasicJsonType>
+class json_ref
+{
+  public:
+    using value_type = BasicJsonType;
+
+    json_ref(value_type&& value)
+        : owned_value(std::move(value))
+    {}
+
+    json_ref(const value_type& value)
+        : value_ref(&value)
+    {}
+
+    json_ref(std::initializer_list<json_ref> init)
+        : owned_value(init)
+    {}
+
+    template <
+        class... Args,
+        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
+    json_ref(Args && ... args)
+        : owned_value(std::forward<Args>(args)...)
+    {}
+
+    // class should be movable only
+    json_ref(json_ref&&) noexcept = default;
+    json_ref(const json_ref&) = delete;
+    json_ref& operator=(const json_ref&) = delete;
+    json_ref& operator=(json_ref&&) = delete;
+    ~json_ref() = default;
+
+    value_type moved_or_copied() const
+    {
+        if (value_ref == nullptr)
+        {
+            return std::move(owned_value);
+        }
+        return *value_ref;
+    }
+
+    value_type const& operator*() const
+    {
+        return value_ref ? *value_ref : owned_value;
+    }
+
+    value_type const* operator->() const
+    {
+        return &** this;
+    }
+
+  private:
+    mutable value_type owned_value = nullptr;
+    value_type const* value_ref = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/string_escape.hpp>
+
+// #include <nlohmann/detail/string_utils.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // reverse
+#include <array> // array
+#include <map> // map
+#include <cmath> // isnan, isinf
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstring> // memcpy
+#include <limits> // numeric_limits
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // copy
+#include <cstddef> // size_t
+#include <iterator> // back_inserter
+#include <memory> // shared_ptr, make_shared
+#include <string> // basic_string
+#include <vector> // vector
+
+#ifndef JSON_NO_IO
+    #include <ios>      // streamsize
+    #include <ostream>  // basic_ostream
+#endif  // JSON_NO_IO
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// abstract output adapter interface
+template<typename CharType> struct output_adapter_protocol
+{
+    virtual void write_character(CharType c) = 0;
+    virtual void write_characters(const CharType* s, std::size_t length) = 0;
+    virtual ~output_adapter_protocol() = default;
+
+    output_adapter_protocol() = default;
+    output_adapter_protocol(const output_adapter_protocol&) = default;
+    output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
+    output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
+    output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
+};
+
+/// a type to simplify interfaces
+template<typename CharType>
+using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
+
+/// output adapter for byte vectors
+template<typename CharType, typename AllocatorType = std::allocator<CharType>>
+class output_vector_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
+        : v(vec)
+    {}
+
+    void write_character(CharType c) override
+    {
+        v.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        v.insert(v.end(), s, s + length);
+    }
+
+  private:
+    std::vector<CharType, AllocatorType>& v;
+};
+
+#ifndef JSON_NO_IO
+/// output adapter for output streams
+template<typename CharType>
+class output_stream_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
+        : stream(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        stream.put(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        stream.write(s, static_cast<std::streamsize>(length));
+    }
+
+  private:
+    std::basic_ostream<CharType>& stream;
+};
+#endif  // JSON_NO_IO
+
+/// output adapter for basic_string
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_string_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_string_adapter(StringType& s) noexcept
+        : str(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        str.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        str.append(s, length);
+    }
+
+  private:
+    StringType& str;
+};
+
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_adapter
+{
+  public:
+    template<typename AllocatorType = std::allocator<CharType>>
+    output_adapter(std::vector<CharType, AllocatorType>& vec)
+        : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
+
+#ifndef JSON_NO_IO
+    output_adapter(std::basic_ostream<CharType>& s)
+        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
+#endif  // JSON_NO_IO
+
+    output_adapter(StringType& s)
+        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
+
+    operator output_adapter_t<CharType>()
+    {
+        return oa;
+    }
+
+  private:
+    output_adapter_t<CharType> oa = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// how to encode BJData
+enum class bjdata_version_t
+{
+    draft2,
+    draft3,
+};
+
+///////////////////
+// binary writer //
+///////////////////
+
+/*!
+@brief serialization to CBOR and MessagePack values
+*/
+template<typename BasicJsonType, typename CharType>
+class binary_writer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+  public:
+    /*!
+    @brief create a binary writer
+
+    @param[in] adapter  output adapter to write to
+    */
+    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
+    {
+        JSON_ASSERT(oa);
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+            {
+                write_bson_object(*j.m_data.m_value.object);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::array:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                JSON_THROW(type_error::create(317, concat("to serialize to BSON, top-level type must be object, but is ", j.type_name()), &j));
+            }
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_cbor(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                oa->write_character(to_char_type(0xF6));
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                oa->write_character(j.m_data.m_value.boolean
+                                    ? to_char_type(0xF5)
+                                    : to_char_type(0xF4));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers. Therefore, we used the
+                    // code from the value_t::number_unsigned case here.
+                    if (j.m_data.m_value.number_integer <= 0x17)
+                    {
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x18));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x19));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x1A));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x1B));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    // The conversions below encode the sign in the first
+                    // byte, and the value is converted to a positive number.
+                    const auto positive_number = -1 - j.m_data.m_value.number_integer;
+                    if (j.m_data.m_value.number_integer >= -24)
+                    {
+                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x38));
+                        write_number(static_cast<std::uint8_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x39));
+                        write_number(static_cast<std::uint16_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x3A));
+                        write_number(static_cast<std::uint32_t>(positive_number));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x3B));
+                        write_number(static_cast<std::uint64_t>(positive_number));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x18));
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x19));
+                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x1A));
+                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_unsigned));
+                }
+                else
+                {
+                    oa->write_character(to_char_type(0x1B));
+                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                if (std::isnan(j.m_data.m_value.number_float))
+                {
+                    // NaN is 0xf97e00 in CBOR
+                    oa->write_character(to_char_type(0xF9));
+                    oa->write_character(to_char_type(0x7E));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else if (std::isinf(j.m_data.m_value.number_float))
+                {
+                    // Infinity is 0xf97c00, -Infinity is 0xf9fc00
+                    oa->write_character(to_char_type(0xf9));
+                    oa->write_character(j.m_data.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else
+                {
+                    write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::cbor);
+                }
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_data.m_value.string->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x60 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x78));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x79));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_data.m_value.array->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x80 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x98));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x99));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_cbor(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (j.m_data.m_value.binary->has_subtype())
+                {
+                    if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xd8));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xd9));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xda));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xdb));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                }
+
+                // step 1: write control byte and the binary array size
+                const auto N = j.m_data.m_value.binary->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x40 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x58));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x59));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_data.m_value.object->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0xA0 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB8));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB9));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBA));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBB));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_cbor(el.first);
+                    write_cbor(el.second);
+                }
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_msgpack(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null: // nil
+            {
+                oa->write_character(to_char_type(0xC0));
+                break;
+            }
+
+            case value_t::boolean: // true and false
+            {
+                oa->write_character(j.m_data.m_value.boolean
+                                    ? to_char_type(0xC3)
+                                    : to_char_type(0xC2));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers. Therefore, we used
+                    // the code from the value_t::number_unsigned case here.
+                    if (j.m_data.m_value.number_unsigned < 128)
+                    {
+                        // positive fixnum
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        // uint 8
+                        oa->write_character(to_char_type(0xCC));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        // uint 16
+                        oa->write_character(to_char_type(0xCD));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        // uint 32
+                        oa->write_character(to_char_type(0xCE));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        // uint 64
+                        oa->write_character(to_char_type(0xCF));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    if (j.m_data.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                    {
+                        // int 8
+                        oa->write_character(to_char_type(0xD0));
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                    {
+                        // int 16
+                        oa->write_character(to_char_type(0xD1));
+                        write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                    {
+                        // int 32
+                        oa->write_character(to_char_type(0xD2));
+                        write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                    {
+                        // int 64
+                        oa->write_character(to_char_type(0xD3));
+                        write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned < 128)
+                {
+                    // positive fixnum
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // uint 8
+                    oa->write_character(to_char_type(0xCC));
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // uint 16
+                    oa->write_character(to_char_type(0xCD));
+                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // uint 32
+                    oa->write_character(to_char_type(0xCE));
+                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    // uint 64
+                    oa->write_character(to_char_type(0xCF));
+                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::msgpack);
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_data.m_value.string->size();
+                if (N <= 31)
+                {
+                    // fixstr
+                    write_number(static_cast<std::uint8_t>(0xA0 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // str 8
+                    oa->write_character(to_char_type(0xD9));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // str 16
+                    oa->write_character(to_char_type(0xDA));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // str 32
+                    oa->write_character(to_char_type(0xDB));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_data.m_value.array->size();
+                if (N <= 15)
+                {
+                    // fixarray
+                    write_number(static_cast<std::uint8_t>(0x90 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // array 16
+                    oa->write_character(to_char_type(0xDC));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // array 32
+                    oa->write_character(to_char_type(0xDD));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_msgpack(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                // step 0: determine if the binary type has a set subtype to
+                // determine whether to use the ext or fixext types
+                const bool use_ext = j.m_data.m_value.binary->has_subtype();
+
+                // step 1: write control byte and the byte string length
+                const auto N = j.m_data.m_value.binary->size();
+                if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    std::uint8_t output_type{};
+                    bool fixed = true;
+                    if (use_ext)
+                    {
+                        switch (N)
+                        {
+                            case 1:
+                                output_type = 0xD4; // fixext 1
+                                break;
+                            case 2:
+                                output_type = 0xD5; // fixext 2
+                                break;
+                            case 4:
+                                output_type = 0xD6; // fixext 4
+                                break;
+                            case 8:
+                                output_type = 0xD7; // fixext 8
+                                break;
+                            case 16:
+                                output_type = 0xD8; // fixext 16
+                                break;
+                            default:
+                                output_type = 0xC7; // ext 8
+                                fixed = false;
+                                break;
+                        }
+
+                    }
+                    else
+                    {
+                        output_type = 0xC4; // bin 8
+                        fixed = false;
+                    }
+
+                    oa->write_character(to_char_type(output_type));
+                    if (!fixed)
+                    {
+                        write_number(static_cast<std::uint8_t>(N));
+                    }
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    const std::uint8_t output_type = use_ext
+                                                     ? 0xC8 // ext 16
+                                                     : 0xC5; // bin 16
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    const std::uint8_t output_type = use_ext
+                                                     ? 0xC9 // ext 32
+                                                     : 0xC6; // bin 32
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 1.5: if this is an ext type, write the subtype
+                if (use_ext)
+                {
+                    write_number(static_cast<std::int8_t>(j.m_data.m_value.binary->subtype()));
+                }
+
+                // step 2: write the byte string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_data.m_value.object->size();
+                if (N <= 15)
+                {
+                    // fixmap
+                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // map 16
+                    oa->write_character(to_char_type(0xDE));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // map 32
+                    oa->write_character(to_char_type(0xDF));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_msgpack(el.first);
+                    write_msgpack(el.second);
+                }
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @param[in] use_count   whether to use '#' prefixes (optimized format)
+    @param[in] use_type    whether to use '$' prefixes (optimized format)
+    @param[in] add_prefix  whether prefixes need to be used for this value
+    @param[in] use_bjdata  whether write in BJData format, default is false
+    @param[in] bjdata_version  which BJData version to use, default is draft2
+    */
+    void write_ubjson(const BasicJsonType& j, const bool use_count,
+                      const bool use_type, const bool add_prefix = true,
+                      const bool use_bjdata = false, const bjdata_version_t bjdata_version = bjdata_version_t::draft2)
+    {
+        const bool bjdata_draft3 = use_bjdata && bjdata_version == bjdata_version_t::draft3;
+
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('Z'));
+                }
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(j.m_data.m_value.boolean
+                                        ? to_char_type('T')
+                                        : to_char_type('F'));
+                }
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_integer, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_unsigned, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_float, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::string:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('S'));
+                }
+                write_number_with_ubjson_prefix(j.m_data.m_value.string->size(), true, use_bjdata);
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_data.m_value.array->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
+                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
+                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v, use_bjdata) == first_prefix;
+                    });
+
+                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
+
+                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.array->size(), true, use_bjdata);
+                }
+
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_ubjson(el, use_count, use_type, prefix_required, use_bjdata, bjdata_version);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                if (use_type && (bjdata_draft3 || !j.m_data.m_value.binary->empty()))
+                {
+                    JSON_ASSERT(use_count);
+                    oa->write_character(to_char_type('$'));
+                    oa->write_character(bjdata_draft3 ? 'B' : 'U');
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.binary->size(), true, use_bjdata);
+                }
+
+                if (use_type)
+                {
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                        j.m_data.m_value.binary->size());
+                }
+                else
+                {
+                    for (size_t i = 0; i < j.m_data.m_value.binary->size(); ++i)
+                    {
+                        oa->write_character(to_char_type(bjdata_draft3 ? 'B' : 'U'));
+                        oa->write_character(j.m_data.m_value.binary->data()[i]);
+                    }
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                if (use_bjdata && j.m_data.m_value.object->size() == 3 && j.m_data.m_value.object->find("_ArrayType_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArraySize_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArrayData_") != j.m_data.m_value.object->end())
+                {
+                    if (!write_bjdata_ndarray(*j.m_data.m_value.object, use_count, use_type, bjdata_version))  // decode bjdata ndarray in the JData format (https://github.com/NeuroJSON/jdata)
+                    {
+                        break;
+                    }
+                }
+
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('{'));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_data.m_value.object->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
+                    const bool same_prefix = std::all_of(j.begin(), j.end(),
+                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v, use_bjdata) == first_prefix;
+                    });
+
+                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
+
+                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.object->size(), true, use_bjdata);
+                }
+
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata);
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(el.first.c_str()),
+                        el.first.size());
+                    write_ubjson(el.second, use_count, use_type, prefix_required, use_bjdata, bjdata_version);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type('}'));
+                }
+
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @return The size of a BSON document entry header, including the id marker
+            and the entry name size (and its null-terminator).
+    */
+    static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
+    {
+        const auto it = name.find(static_cast<typename string_t::value_type>(0));
+        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
+        {
+            JSON_THROW(out_of_range::create(409, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j));
+        }
+
+        static_cast<void>(j);
+        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
+    }
+
+    /*!
+    @brief Writes the given @a element_type and @a name to the output adapter
+    */
+    void write_bson_entry_header(const string_t& name,
+                                 const std::uint8_t element_type)
+    {
+        oa->write_character(to_char_type(element_type)); // boolean
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(name.c_str()),
+            name.size() + 1u);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and boolean value @a value
+    */
+    void write_bson_boolean(const string_t& name,
+                            const bool value)
+    {
+        write_bson_entry_header(name, 0x08);
+        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and double value @a value
+    */
+    void write_bson_double(const string_t& name,
+                           const double value)
+    {
+        write_bson_entry_header(name, 0x01);
+        write_number<double>(value, true);
+    }
+
+    /*!
+    @return The size of the BSON-encoded string in @a value
+    */
+    static std::size_t calc_bson_string_size(const string_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and string value @a value
+    */
+    void write_bson_string(const string_t& name,
+                           const string_t& value)
+    {
+        write_bson_entry_header(name, 0x02);
+
+        write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul), true);
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(value.c_str()),
+            value.size() + 1);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and null value
+    */
+    void write_bson_null(const string_t& name)
+    {
+        write_bson_entry_header(name, 0x0A);
+    }
+
+    /*!
+    @return The size of the BSON-encoded integer @a value
+    */
+    static std::size_t calc_bson_integer_size(const std::int64_t value)
+    {
+        return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and integer @a value
+    */
+    void write_bson_integer(const string_t& name,
+                            const std::int64_t value)
+    {
+        if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            write_bson_entry_header(name, 0x10); // int32
+            write_number<std::int32_t>(static_cast<std::int32_t>(value), true);
+        }
+        else
+        {
+            write_bson_entry_header(name, 0x12); // int64
+            write_number<std::int64_t>(static_cast<std::int64_t>(value), true);
+        }
+    }
+
+    /*!
+    @return The size of the BSON-encoded unsigned integer in @a j
+    */
+    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
+    {
+        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and unsigned @a value
+    */
+    void write_bson_unsigned(const string_t& name,
+                             const BasicJsonType& j)
+    {
+        if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x10 /* int32 */);
+            write_number<std::int32_t>(static_cast<std::int32_t>(j.m_data.m_value.number_unsigned), true);
+        }
+        else if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x12 /* int64 */);
+            write_number<std::int64_t>(static_cast<std::int64_t>(j.m_data.m_value.number_unsigned), true);
+        }
+        else
+        {
+            write_bson_entry_header(name, 0x11 /* uint64 */);
+            write_number<std::uint64_t>(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned), true);
+        }
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and object @a value
+    */
+    void write_bson_object_entry(const string_t& name,
+                                 const typename BasicJsonType::object_t& value)
+    {
+        write_bson_entry_header(name, 0x03); // object
+        write_bson_object(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded array @a value
+    */
+    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
+    {
+        std::size_t array_index = 0ul;
+
+        const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
+        {
+            return result + calc_bson_element_size(std::to_string(array_index++), el);
+        });
+
+        return sizeof(std::int32_t) + embedded_document_size + 1ul;
+    }
+
+    /*!
+    @return The size of the BSON-encoded binary array @a value
+    */
+    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and array @a value
+    */
+    void write_bson_array(const string_t& name,
+                          const typename BasicJsonType::array_t& value)
+    {
+        write_bson_entry_header(name, 0x04); // array
+        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_array_size(value)), true);
+
+        std::size_t array_index = 0ul;
+
+        for (const auto& el : value)
+        {
+            write_bson_element(std::to_string(array_index++), el);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and binary value @a value
+    */
+    void write_bson_binary(const string_t& name,
+                           const binary_t& value)
+    {
+        write_bson_entry_header(name, 0x05);
+
+        write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true);
+        write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
+
+        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
+    }
+
+    /*!
+    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
+    @return The calculated size for the BSON document entry for @a j with the given @a name.
+    */
+    static std::size_t calc_bson_element_size(const string_t& name,
+            const BasicJsonType& j)
+    {
+        const auto header_size = calc_bson_entry_header_size(name, j);
+        switch (j.type())
+        {
+            case value_t::object:
+                return header_size + calc_bson_object_size(*j.m_data.m_value.object);
+
+            case value_t::array:
+                return header_size + calc_bson_array_size(*j.m_data.m_value.array);
+
+            case value_t::binary:
+                return header_size + calc_bson_binary_size(*j.m_data.m_value.binary);
+
+            case value_t::boolean:
+                return header_size + 1ul;
+
+            case value_t::number_float:
+                return header_size + 8ul;
+
+            case value_t::number_integer:
+                return header_size + calc_bson_integer_size(j.m_data.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return header_size + calc_bson_unsigned_size(j.m_data.m_value.number_unsigned);
+
+            case value_t::string:
+                return header_size + calc_bson_string_size(*j.m_data.m_value.string);
+
+            case value_t::null:
+                return header_size + 0ul;
+
+            // LCOV_EXCL_START
+            case value_t::discarded:
+            default:
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+                return 0ul;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Serializes the JSON value @a j to BSON and associates it with the
+           key @a name.
+    @param name The name to associate with the JSON entity @a j within the
+                current BSON document
+    */
+    void write_bson_element(const string_t& name,
+                            const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+                return write_bson_object_entry(name, *j.m_data.m_value.object);
+
+            case value_t::array:
+                return write_bson_array(name, *j.m_data.m_value.array);
+
+            case value_t::binary:
+                return write_bson_binary(name, *j.m_data.m_value.binary);
+
+            case value_t::boolean:
+                return write_bson_boolean(name, j.m_data.m_value.boolean);
+
+            case value_t::number_float:
+                return write_bson_double(name, j.m_data.m_value.number_float);
+
+            case value_t::number_integer:
+                return write_bson_integer(name, j.m_data.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return write_bson_unsigned(name, j);
+
+            case value_t::string:
+                return write_bson_string(name, *j.m_data.m_value.string);
+
+            case value_t::null:
+                return write_bson_null(name);
+
+            // LCOV_EXCL_START
+            case value_t::discarded:
+            default:
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+                return;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Calculates the size of the BSON serialization of the given
+           JSON-object @a j.
+    @param[in] value  JSON value to serialize
+    @pre       value.type() == value_t::object
+    */
+    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
+    {
+        const std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
+                                          [](size_t result, const typename BasicJsonType::object_t::value_type & el)
+        {
+            return result += calc_bson_element_size(el.first, el.second);
+        });
+
+        return sizeof(std::int32_t) + document_size + 1ul;
+    }
+
+    /*!
+    @param[in] value  JSON value to serialize
+    @pre       value.type() == value_t::object
+    */
+    void write_bson_object(const typename BasicJsonType::object_t& value)
+    {
+        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_object_size(value)), true);
+
+        for (const auto& el : value)
+        {
+            write_bson_element(el.first, el.second);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xFA);  // Single-Precision Float
+    }
+
+    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xFB);  // Double-Precision Float
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xCA);  // float 32
+    }
+
+    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xCB);  // float 64
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    // UBJSON: write number (floating point)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_floating_point<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if (add_prefix)
+        {
+            oa->write_character(get_ubjson_float_prefix(n));
+        }
+        write_number(n, use_bjdata);
+    }
+
+    // UBJSON: write number (unsigned integer)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_unsigned<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if (n <= (std::numeric_limits<std::uint8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
+            }
+            write_number(static_cast<std::uint16_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
+            }
+            write_number(static_cast<std::uint32_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= (std::numeric_limits<uint64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('M'));  // uint64 - bjdata only
+            }
+            write_number(static_cast<std::uint64_t>(n), use_bjdata);
+        }
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+    }
+
+    // UBJSON: write number (signed integer)
+    template < typename NumberType, typename std::enable_if <
+                   std::is_signed<NumberType>::value&&
+                   !std::is_floating_point<NumberType>::value, int >::type = 0 >
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::int8_t>(n), use_bjdata);
+        }
+        else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::max)())))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
+            }
+            write_number(static_cast<uint16_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::max)())))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
+            }
+            write_number(static_cast<uint32_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n), use_bjdata);
+        }
+        // LCOV_EXCL_START
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+        // LCOV_EXCL_STOP
+    }
+
+    /*!
+    @brief determine the type prefix of container values
+    */
+    CharType ubjson_prefix(const BasicJsonType& j, const bool use_bjdata) const noexcept
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+                return 'Z';
+
+            case value_t::boolean:
+                return j.m_data.m_value.boolean ? 'T' : 'F';
+
+            case value_t::number_integer:
+            {
+                if ((std::numeric_limits<std::int8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                {
+                    return 'i';
+                }
+                if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    return 'U';
+                }
+                if ((std::numeric_limits<std::int16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                {
+                    return 'I';
+                }
+                if (use_bjdata && ((std::numeric_limits<std::uint16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)()))
+                {
+                    return 'u';
+                }
+                if ((std::numeric_limits<std::int32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                {
+                    return 'l';
+                }
+                if (use_bjdata && ((std::numeric_limits<std::uint32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)()))
+                {
+                    return 'm';
+                }
+                if ((std::numeric_limits<std::int64_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                {
+                    return 'L';
+                }
+                // anything else is treated as a high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+                {
+                    return 'i';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
+                {
+                    return 'U';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+                {
+                    return 'I';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint16_t>::max)()))
+                {
+                    return 'u';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+                {
+                    return 'l';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)()))
+                {
+                    return 'm';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+                {
+                    return 'L';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    return 'M';
+                }
+                // anything else is treated as a high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_float:
+                return get_ubjson_float_prefix(j.m_data.m_value.number_float);
+
+            case value_t::string:
+                return 'S';
+
+            case value_t::array: // fallthrough
+            case value_t::binary:
+                return '[';
+
+            case value_t::object:
+                return '{';
+
+            case value_t::discarded:
+            default:  // discarded values
+                return 'N';
+        }
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
+    {
+        return 'd';  // float 32
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
+    {
+        return 'D';  // float 64
+    }
+
+    /*!
+    @return false if the object is successfully converted to a bjdata ndarray, true if the type or size is invalid
+    */
+    bool write_bjdata_ndarray(const typename BasicJsonType::object_t& value, const bool use_count, const bool use_type, const bjdata_version_t bjdata_version)
+    {
+        std::map<string_t, CharType> bjdtype = {{"uint8", 'U'},  {"int8", 'i'},  {"uint16", 'u'}, {"int16", 'I'},
+            {"uint32", 'm'}, {"int32", 'l'}, {"uint64", 'M'}, {"int64", 'L'}, {"single", 'd'}, {"double", 'D'},
+            {"char", 'C'}, {"byte", 'B'}
+        };
+
+        string_t key = "_ArrayType_";
+        auto it = bjdtype.find(static_cast<string_t>(value.at(key)));
+        if (it == bjdtype.end())
+        {
+            return true;
+        }
+        CharType dtype = it->second;
+
+        key = "_ArraySize_";
+        std::size_t len = (value.at(key).empty() ? 0 : 1);
+        for (const auto& el : value.at(key))
+        {
+            len *= static_cast<std::size_t>(el.m_data.m_value.number_unsigned);
+        }
+
+        key = "_ArrayData_";
+        if (value.at(key).size() != len)
+        {
+            return true;
+        }
+
+        oa->write_character('[');
+        oa->write_character('$');
+        oa->write_character(dtype);
+        oa->write_character('#');
+
+        key = "_ArraySize_";
+        write_ubjson(value.at(key), use_count, use_type, true,  true, bjdata_version);
+
+        key = "_ArrayData_";
+        if (dtype == 'U' || dtype == 'C' || dtype == 'B')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint8_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'i')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int8_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'u')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint16_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'I')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int16_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'm')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint32_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'l')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int32_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'M')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint64_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'L')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int64_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'd')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<float>(el.m_data.m_value.number_float), true);
+            }
+        }
+        else if (dtype == 'D')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<double>(el.m_data.m_value.number_float), true);
+            }
+        }
+        return false;
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*
+    @brief write a number to output input
+    @param[in] n number of type @a NumberType
+    @param[in] OutputIsLittleEndian Set to true if output data is
+                                 required to be little endian
+    @tparam NumberType the type of the number
+
+    @note This function needs to respect the system's endianness, because bytes
+          in CBOR, MessagePack, and UBJSON are stored in network order (big
+          endian) and therefore need reordering on little endian systems.
+          On the other hand, BSON and BJData use little endian and should reorder
+          on big endian systems.
+    */
+    template<typename NumberType>
+    void write_number(const NumberType n, const bool OutputIsLittleEndian = false)
+    {
+        // step 1: write the number to an array of length NumberType
+        std::array<CharType, sizeof(NumberType)> vec{};
+        std::memcpy(vec.data(), &n, sizeof(NumberType));
+
+        // step 2: write the array to output (with possible reordering)
+        if (is_little_endian != OutputIsLittleEndian)
+        {
+            // reverse byte order prior to conversion if necessary
+            std::reverse(vec.begin(), vec.end());
+        }
+
+        oa->write_characters(vec.data(), sizeof(NumberType));
+    }
+
+    void write_compact_float(const number_float_t n, detail::input_format_t format)
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
+                static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
+                static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(static_cast<float>(n))
+                                : get_msgpack_float_prefix(static_cast<float>(n)));
+            write_number(static_cast<float>(n));
+        }
+        else
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(n)
+                                : get_msgpack_float_prefix(n));
+            write_number(n);
+        }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+  public:
+    // The following to_char_type functions are implement the conversion
+    // between uint8_t and CharType. In case CharType is not unsigned,
+    // such a conversion is required to allow values greater than 128.
+    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return *reinterpret_cast<char*>(&x);
+    }
+
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
+    static CharType to_char_type(std::uint8_t x) noexcept
+    {
+        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
+        static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
+        CharType result;
+        std::memcpy(&result, &x, sizeof(x));
+        return result;
+    }
+
+    template<typename C = CharType,
+             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return x;
+    }
+
+    template < typename InputCharType, typename C = CharType,
+               enable_if_t <
+                   std::is_signed<C>::value &&
+                   std::is_signed<char>::value &&
+                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
+                   > * = nullptr >
+    static constexpr CharType to_char_type(InputCharType x) noexcept
+    {
+        return x;
+    }
+
+  private:
+    /// whether we can assume little endianness
+    const bool is_little_endian = little_endianness();
+
+    /// the output
+    output_adapter_t<CharType> oa = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/output/serializer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2008 - 2009 Björn Hoehrmann <bjoern@hoehrmann.de>
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // reverse, remove, fill, find, none_of
+#include <array> // array
+#include <clocale> // localeconv, lconv
+#include <cmath> // labs, isfinite, isnan, signbit
+#include <cstddef> // size_t, ptrdiff_t
+#include <cstdint> // uint8_t
+#include <cstdio> // snprintf
+#include <limits> // numeric_limits
+#include <string> // string, char_traits
+#include <iomanip> // setfill, setw
+#include <type_traits> // is_same
+#include <utility> // move
+
+// #include <nlohmann/detail/conversions/to_chars.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2009 Florian Loitsch <https://florian.loitsch.com/>
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cmath>   // signbit, isfinite
+#include <cstdint> // intN_t, uintN_t
+#include <cstring> // memcpy, memmove
+#include <limits> // numeric_limits
+#include <type_traits> // conditional
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief implements the Grisu2 algorithm for binary to decimal floating-point
+conversion.
+
+This implementation is a slightly modified version of the reference
+implementation which may be obtained from
+http://florian.loitsch.com/publications (bench.tar.gz).
+
+The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
+
+For a detailed description of the algorithm see:
+
+[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
+    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
+    Language Design and Implementation, PLDI 2010
+[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
+    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
+    Design and Implementation, PLDI 1996
+*/
+namespace dtoa_impl
+{
+
+template<typename Target, typename Source>
+Target reinterpret_bits(const Source source)
+{
+    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
+
+    Target target;
+    std::memcpy(&target, &source, sizeof(Source));
+    return target;
+}
+
+struct diyfp // f * 2^e
+{
+    static constexpr int kPrecision = 64; // = q
+
+    std::uint64_t f = 0;
+    int e = 0;
+
+    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
+
+    /*!
+    @brief returns x - y
+    @pre x.e == y.e and x.f >= y.f
+    */
+    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
+    {
+        JSON_ASSERT(x.e == y.e);
+        JSON_ASSERT(x.f >= y.f);
+
+        return {x.f - y.f, x.e};
+    }
+
+    /*!
+    @brief returns x * y
+    @note The result is rounded. (Only the upper q bits are returned.)
+    */
+    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
+    {
+        static_assert(kPrecision == 64, "internal error");
+
+        // Computes:
+        //  f = round((x.f * y.f) / 2^q)
+        //  e = x.e + y.e + q
+
+        // Emulate the 64-bit * 64-bit multiplication:
+        //
+        // p = u * v
+        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
+        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
+        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
+        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
+        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
+        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
+        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
+        //
+        // (Since Q might be larger than 2^32 - 1)
+        //
+        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
+        //
+        // (Q_hi + H does not overflow a 64-bit int)
+        //
+        //   = p_lo + 2^64 p_hi
+
+        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
+        const std::uint64_t u_hi = x.f >> 32u;
+        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
+        const std::uint64_t v_hi = y.f >> 32u;
+
+        const std::uint64_t p0 = u_lo * v_lo;
+        const std::uint64_t p1 = u_lo * v_hi;
+        const std::uint64_t p2 = u_hi * v_lo;
+        const std::uint64_t p3 = u_hi * v_hi;
+
+        const std::uint64_t p0_hi = p0 >> 32u;
+        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
+        const std::uint64_t p1_hi = p1 >> 32u;
+        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
+        const std::uint64_t p2_hi = p2 >> 32u;
+
+        std::uint64_t Q = p0_hi + p1_lo + p2_lo;
+
+        // The full product might now be computed as
+        //
+        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
+        // p_lo = p0_lo + (Q << 32)
+        //
+        // But in this particular case here, the full p_lo is not required.
+        // Effectively, we only need to add the highest bit in p_lo to p_hi (and
+        // Q_hi + 1 does not overflow).
+
+        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
+
+        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
+
+        return {h, x.e + y.e + 64};
+    }
+
+    /*!
+    @brief normalize x such that the significand is >= 2^(q-1)
+    @pre x.f != 0
+    */
+    static diyfp normalize(diyfp x) noexcept
+    {
+        JSON_ASSERT(x.f != 0);
+
+        while ((x.f >> 63u) == 0)
+        {
+            x.f <<= 1u;
+            x.e--;
+        }
+
+        return x;
+    }
+
+    /*!
+    @brief normalize x such that the result has the exponent E
+    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
+    */
+    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
+    {
+        const int delta = x.e - target_exponent;
+
+        JSON_ASSERT(delta >= 0);
+        JSON_ASSERT(((x.f << delta) >> delta) == x.f);
+
+        return {x.f << delta, target_exponent};
+    }
+};
+
+struct boundaries
+{
+    diyfp w;
+    diyfp minus;
+    diyfp plus;
+};
+
+/*!
+Compute the (normalized) diyfp representing the input number 'value' and its
+boundaries.
+
+@pre value must be finite and positive
+*/
+template<typename FloatType>
+boundaries compute_boundaries(FloatType value)
+{
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // Convert the IEEE representation into a diyfp.
+    //
+    // If v is denormal:
+    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
+    // If v is normalized:
+    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
+
+    static_assert(std::numeric_limits<FloatType>::is_iec559,
+                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
+
+    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
+    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
+    constexpr int      kMinExp    = 1 - kBias;
+    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
+
+    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
+
+    const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
+    const std::uint64_t E = bits >> (kPrecision - 1);
+    const std::uint64_t F = bits & (kHiddenBit - 1);
+
+    const bool is_denormal = E == 0;
+    const diyfp v = is_denormal
+                    ? diyfp(F, kMinExp)
+                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
+
+    // Compute the boundaries m- and m+ of the floating-point value
+    // v = f * 2^e.
+    //
+    // Determine v- and v+, the floating-point predecessor and successor of v,
+    // respectively.
+    //
+    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
+    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
+    //
+    //      v+ = v + 2^e
+    //
+    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
+    // between m- and m+ round to v, regardless of how the input rounding
+    // algorithm breaks ties.
+    //
+    //      ---+-------------+-------------+-------------+-------------+---  (A)
+    //         v-            m-            v             m+            v+
+    //
+    //      -----------------+------+------+-------------+-------------+---  (B)
+    //                       v-     m-     v             m+            v+
+
+    const bool lower_boundary_is_closer = F == 0 && E > 1;
+    const diyfp m_plus = diyfp((2 * v.f) + 1, v.e - 1);
+    const diyfp m_minus = lower_boundary_is_closer
+                          ? diyfp((4 * v.f) - 1, v.e - 2)  // (B)
+                          : diyfp((2 * v.f) - 1, v.e - 1); // (A)
+
+    // Determine the normalized w+ = m+.
+    const diyfp w_plus = diyfp::normalize(m_plus);
+
+    // Determine w- = m- such that e_(w-) = e_(w+).
+    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
+
+    return {diyfp::normalize(v), w_minus, w_plus};
+}
+
+// Given normalized diyfp w, Grisu needs to find a (normalized) cached
+// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
+// within a certain range [alpha, gamma] (Definition 3.2 from [1])
+//
+//      alpha <= e = e_c + e_w + q <= gamma
+//
+// or
+//
+//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
+//                          <= f_c * f_w * 2^gamma
+//
+// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
+//
+//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
+//
+// or
+//
+//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
+//
+// The choice of (alpha,gamma) determines the size of the table and the form of
+// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
+// in practice:
+//
+// The idea is to cut the number c * w = f * 2^e into two parts, which can be
+// processed independently: An integral part p1, and a fractional part p2:
+//
+//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
+//              = (f div 2^-e) + (f mod 2^-e) * 2^e
+//              = p1 + p2 * 2^e
+//
+// The conversion of p1 into decimal form requires a series of divisions and
+// modulos by (a power of) 10. These operations are faster for 32-bit than for
+// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
+// achieved by choosing
+//
+//      -e >= 32   or   e <= -32 := gamma
+//
+// In order to convert the fractional part
+//
+//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
+//
+// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
+// d[-i] are extracted in order:
+//
+//      (10 * p2) div 2^-e = d[-1]
+//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
+//
+// The multiplication by 10 must not overflow. It is sufficient to choose
+//
+//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
+//
+// Since p2 = f mod 2^-e < 2^-e,
+//
+//      -e <= 60   or   e >= -60 := alpha
+
+constexpr int kAlpha = -60;
+constexpr int kGamma = -32;
+
+struct cached_power // c = f * 2^e ~= 10^k
+{
+    std::uint64_t f;
+    int e;
+    int k;
+};
+
+/*!
+For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
+power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
+satisfies (Definition 3.2 from [1])
+
+     alpha <= e_c + e + q <= gamma.
+*/
+inline cached_power get_cached_power_for_binary_exponent(int e)
+{
+    // Now
+    //
+    //      alpha <= e_c + e + q <= gamma                                    (1)
+    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
+    //
+    // and since the c's are normalized, 2^(q-1) <= f_c,
+    //
+    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
+    //      ==> 2^(alpha - e - 1) <= c
+    //
+    // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
+    //
+    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
+    //        = ceil( (alpha - e - 1) * log_10(2) )
+    //
+    // From the paper:
+    // "In theory the result of the procedure could be wrong since c is rounded,
+    //  and the computation itself is approximated [...]. In practice, however,
+    //  this simple function is sufficient."
+    //
+    // For IEEE double precision floating-point numbers converted into
+    // normalized diyfp's w = f * 2^e, with q = 64,
+    //
+    //      e >= -1022      (min IEEE exponent)
+    //           -52        (p - 1)
+    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
+    //           -11        (normalize the diyfp)
+    //         = -1137
+    //
+    // and
+    //
+    //      e <= +1023      (max IEEE exponent)
+    //           -52        (p - 1)
+    //           -11        (normalize the diyfp)
+    //         = 960
+    //
+    // This binary exponent range [-1137,960] results in a decimal exponent
+    // range [-307,324]. One does not need to store a cached power for each
+    // k in this range. For each such k it suffices to find a cached power
+    // such that the exponent of the product lies in [alpha,gamma].
+    // This implies that the difference of the decimal exponents of adjacent
+    // table entries must be less than or equal to
+    //
+    //      floor( (gamma - alpha) * log_10(2) ) = 8.
+    //
+    // (A smaller distance gamma-alpha would require a larger table.)
+
+    // NB:
+    // Actually, this function returns c, such that -60 <= e_c + e + 64 <= -34.
+
+    constexpr int kCachedPowersMinDecExp = -300;
+    constexpr int kCachedPowersDecStep = 8;
+
+    static constexpr std::array<cached_power, 79> kCachedPowers =
+    {
+        {
+            { 0xAB70FE17C79AC6CA, -1060, -300 },
+            { 0xFF77B1FCBEBCDC4F, -1034, -292 },
+            { 0xBE5691EF416BD60C, -1007, -284 },
+            { 0x8DD01FAD907FFC3C,  -980, -276 },
+            { 0xD3515C2831559A83,  -954, -268 },
+            { 0x9D71AC8FADA6C9B5,  -927, -260 },
+            { 0xEA9C227723EE8BCB,  -901, -252 },
+            { 0xAECC49914078536D,  -874, -244 },
+            { 0x823C12795DB6CE57,  -847, -236 },
+            { 0xC21094364DFB5637,  -821, -228 },
+            { 0x9096EA6F3848984F,  -794, -220 },
+            { 0xD77485CB25823AC7,  -768, -212 },
+            { 0xA086CFCD97BF97F4,  -741, -204 },
+            { 0xEF340A98172AACE5,  -715, -196 },
+            { 0xB23867FB2A35B28E,  -688, -188 },
+            { 0x84C8D4DFD2C63F3B,  -661, -180 },
+            { 0xC5DD44271AD3CDBA,  -635, -172 },
+            { 0x936B9FCEBB25C996,  -608, -164 },
+            { 0xDBAC6C247D62A584,  -582, -156 },
+            { 0xA3AB66580D5FDAF6,  -555, -148 },
+            { 0xF3E2F893DEC3F126,  -529, -140 },
+            { 0xB5B5ADA8AAFF80B8,  -502, -132 },
+            { 0x87625F056C7C4A8B,  -475, -124 },
+            { 0xC9BCFF6034C13053,  -449, -116 },
+            { 0x964E858C91BA2655,  -422, -108 },
+            { 0xDFF9772470297EBD,  -396, -100 },
+            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
+            { 0xF8A95FCF88747D94,  -343,  -84 },
+            { 0xB94470938FA89BCF,  -316,  -76 },
+            { 0x8A08F0F8BF0F156B,  -289,  -68 },
+            { 0xCDB02555653131B6,  -263,  -60 },
+            { 0x993FE2C6D07B7FAC,  -236,  -52 },
+            { 0xE45C10C42A2B3B06,  -210,  -44 },
+            { 0xAA242499697392D3,  -183,  -36 },
+            { 0xFD87B5F28300CA0E,  -157,  -28 },
+            { 0xBCE5086492111AEB,  -130,  -20 },
+            { 0x8CBCCC096F5088CC,  -103,  -12 },
+            { 0xD1B71758E219652C,   -77,   -4 },
+            { 0x9C40000000000000,   -50,    4 },
+            { 0xE8D4A51000000000,   -24,   12 },
+            { 0xAD78EBC5AC620000,     3,   20 },
+            { 0x813F3978F8940984,    30,   28 },
+            { 0xC097CE7BC90715B3,    56,   36 },
+            { 0x8F7E32CE7BEA5C70,    83,   44 },
+            { 0xD5D238A4ABE98068,   109,   52 },
+            { 0x9F4F2726179A2245,   136,   60 },
+            { 0xED63A231D4C4FB27,   162,   68 },
+            { 0xB0DE65388CC8ADA8,   189,   76 },
+            { 0x83C7088E1AAB65DB,   216,   84 },
+            { 0xC45D1DF942711D9A,   242,   92 },
+            { 0x924D692CA61BE758,   269,  100 },
+            { 0xDA01EE641A708DEA,   295,  108 },
+            { 0xA26DA3999AEF774A,   322,  116 },
+            { 0xF209787BB47D6B85,   348,  124 },
+            { 0xB454E4A179DD1877,   375,  132 },
+            { 0x865B86925B9BC5C2,   402,  140 },
+            { 0xC83553C5C8965D3D,   428,  148 },
+            { 0x952AB45CFA97A0B3,   455,  156 },
+            { 0xDE469FBD99A05FE3,   481,  164 },
+            { 0xA59BC234DB398C25,   508,  172 },
+            { 0xF6C69A72A3989F5C,   534,  180 },
+            { 0xB7DCBF5354E9BECE,   561,  188 },
+            { 0x88FCF317F22241E2,   588,  196 },
+            { 0xCC20CE9BD35C78A5,   614,  204 },
+            { 0x98165AF37B2153DF,   641,  212 },
+            { 0xE2A0B5DC971F303A,   667,  220 },
+            { 0xA8D9D1535CE3B396,   694,  228 },
+            { 0xFB9B7CD9A4A7443C,   720,  236 },
+            { 0xBB764C4CA7A44410,   747,  244 },
+            { 0x8BAB8EEFB6409C1A,   774,  252 },
+            { 0xD01FEF10A657842C,   800,  260 },
+            { 0x9B10A4E5E9913129,   827,  268 },
+            { 0xE7109BFBA19C0C9D,   853,  276 },
+            { 0xAC2820D9623BF429,   880,  284 },
+            { 0x80444B5E7AA7CF85,   907,  292 },
+            { 0xBF21E44003ACDD2D,   933,  300 },
+            { 0x8E679C2F5E44FF8F,   960,  308 },
+            { 0xD433179D9C8CB841,   986,  316 },
+            { 0x9E19DB92B4E31BA9,  1013,  324 },
+        }
+    };
+
+    // This computation gives exactly the same results for k as
+    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
+    // for |e| <= 1500, but doesn't require floating-point operations.
+    // NB: log_10(2) ~= 78913 / 2^18
+    JSON_ASSERT(e >= -1500);
+    JSON_ASSERT(e <=  1500);
+    const int f = kAlpha - e - 1;
+    const int k = ((f * 78913) / (1 << 18)) + static_cast<int>(f > 0);
+
+    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
+    JSON_ASSERT(index >= 0);
+    JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
+
+    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
+    JSON_ASSERT(kAlpha <= cached.e + e + 64);
+    JSON_ASSERT(kGamma >= cached.e + e + 64);
+
+    return cached;
+}
+
+/*!
+For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
+For n == 0, returns 1 and sets pow10 := 1.
+*/
+inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
+{
+    // LCOV_EXCL_START
+    if (n >= 1000000000)
+    {
+        pow10 = 1000000000;
+        return 10;
+    }
+    // LCOV_EXCL_STOP
+    if (n >= 100000000)
+    {
+        pow10 = 100000000;
+        return  9;
+    }
+    if (n >= 10000000)
+    {
+        pow10 = 10000000;
+        return  8;
+    }
+    if (n >= 1000000)
+    {
+        pow10 = 1000000;
+        return  7;
+    }
+    if (n >= 100000)
+    {
+        pow10 = 100000;
+        return  6;
+    }
+    if (n >= 10000)
+    {
+        pow10 = 10000;
+        return  5;
+    }
+    if (n >= 1000)
+    {
+        pow10 = 1000;
+        return  4;
+    }
+    if (n >= 100)
+    {
+        pow10 = 100;
+        return  3;
+    }
+    if (n >= 10)
+    {
+        pow10 = 10;
+        return  2;
+    }
+
+    pow10 = 1;
+    return 1;
+}
+
+inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
+                         std::uint64_t rest, std::uint64_t ten_k)
+{
+    JSON_ASSERT(len >= 1);
+    JSON_ASSERT(dist <= delta);
+    JSON_ASSERT(rest <= delta);
+    JSON_ASSERT(ten_k > 0);
+
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    //                                  ten_k
+    //                                <------>
+    //                                       <---- rest ---->
+    // --------------[------------------+----+--------------]--------------
+    //                                  w    V
+    //                                       = buf * 10^k
+    //
+    // ten_k represents a unit-in-the-last-place in the decimal representation
+    // stored in buf.
+    // Decrement buf by ten_k while this takes buf closer to w.
+
+    // The tests are written in this order to avoid overflow in unsigned
+    // integer arithmetic.
+
+    while (rest < dist
+            && delta - rest >= ten_k
+            && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
+    {
+        JSON_ASSERT(buf[len - 1] != '0');
+        buf[len - 1]--;
+        rest += ten_k;
+    }
+}
+
+/*!
+Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
+M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
+*/
+inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
+                             diyfp M_minus, diyfp w, diyfp M_plus)
+{
+    static_assert(kAlpha >= -60, "internal error");
+    static_assert(kGamma <= -32, "internal error");
+
+    // Generates the digits (and the exponent) of a decimal floating-point
+    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
+    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
+    //
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    // Grisu2 generates the digits of M+ from left to right and stops as soon as
+    // V is in [M-,M+].
+
+    JSON_ASSERT(M_plus.e >= kAlpha);
+    JSON_ASSERT(M_plus.e <= kGamma);
+
+    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
+    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
+
+    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
+    //
+    //      M+ = f * 2^e
+    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
+    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
+    //         = p1 + p2 * 2^e
+
+    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
+
+    auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
+    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
+
+    // 1)
+    //
+    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
+
+    JSON_ASSERT(p1 > 0);
+
+    std::uint32_t pow10{};
+    const int k = find_largest_pow10(p1, pow10);
+
+    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
+    //
+    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
+    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
+    //
+    //      M+ = p1                                             + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
+    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
+    //
+    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
+    //
+    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
+    //
+    // but stop as soon as
+    //
+    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
+
+    int n = k;
+    while (n > 0)
+    {
+        // Invariants:
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        //
+        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
+        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
+        //
+        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
+        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
+        //
+        p1 = r;
+        n--;
+        //
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
+        //      pow10 = 10^n
+        //
+
+        // Now check if enough digits have been generated.
+        // Compute
+        //
+        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
+        //
+        // Note:
+        // Since rest and delta share the same exponent e, it suffices to
+        // compare the significands.
+        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
+        if (rest <= delta)
+        {
+            // V = buffer * 10^n, with M- <= V <= M+.
+
+            decimal_exponent += n;
+
+            // We may now just stop. But instead, it looks as if the buffer
+            // could be decremented to bring V closer to w.
+            //
+            // pow10 = 10^n is now 1 ulp in the decimal representation V.
+            // The rounding procedure works with diyfp's with an implicit
+            // exponent of e.
+            //
+            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
+            //
+            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
+            grisu2_round(buffer, length, dist, delta, rest, ten_n);
+
+            return;
+        }
+
+        pow10 /= 10;
+        //
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        // Invariants restored.
+    }
+
+    // 2)
+    //
+    // The digits of the integral part have been generated:
+    //
+    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
+    //         = buffer            + p2 * 2^e
+    //
+    // Now generate the digits of the fractional part p2 * 2^e.
+    //
+    // Note:
+    // No decimal point is generated: the exponent is adjusted instead.
+    //
+    // p2 actually represents the fraction
+    //
+    //      p2 * 2^e
+    //          = p2 / 2^-e
+    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
+    //
+    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
+    //
+    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
+    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
+    //
+    // using
+    //
+    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
+    //                = (                   d) * 2^-e + (                   r)
+    //
+    // or
+    //      10^m * p2 * 2^e = d + r * 2^e
+    //
+    // i.e.
+    //
+    //      M+ = buffer + p2 * 2^e
+    //         = buffer + 10^-m * (d + r * 2^e)
+    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
+    //
+    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
+
+    JSON_ASSERT(p2 > delta);
+
+    int m = 0;
+    for (;;)
+    {
+        // Invariant:
+        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
+        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
+        //
+        JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
+        p2 *= 10;
+        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
+        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
+        //
+        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
+        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        p2 = r;
+        m++;
+        //
+        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
+        // Invariant restored.
+
+        // Check if enough digits have been generated.
+        //
+        //      10^-m * p2 * 2^e <= delta * 2^e
+        //              p2 * 2^e <= 10^m * delta * 2^e
+        //                    p2 <= 10^m * delta
+        delta *= 10;
+        dist  *= 10;
+        if (p2 <= delta)
+        {
+            break;
+        }
+    }
+
+    // V = buffer * 10^-m, with M- <= V <= M+.
+
+    decimal_exponent -= m;
+
+    // 1 ulp in the decimal representation is now 10^-m.
+    // Since delta and dist are now scaled by 10^m, we need to do the
+    // same with ulp in order to keep the units in sync.
+    //
+    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
+    //
+    const std::uint64_t ten_m = one.f;
+    grisu2_round(buffer, length, dist, delta, p2, ten_m);
+
+    // By construction this algorithm generates the shortest possible decimal
+    // number (Loitsch, Theorem 6.2) which rounds back to w.
+    // For an input number of precision p, at least
+    //
+    //      N = 1 + ceil(p * log_10(2))
+    //
+    // decimal digits are sufficient to identify all binary floating-point
+    // numbers (Matula, "In-and-Out conversions").
+    // This implies that the algorithm does not produce more than N decimal
+    // digits.
+    //
+    //      N = 17 for p = 53 (IEEE double precision)
+    //      N = 9  for p = 24 (IEEE single precision)
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline void grisu2(char* buf, int& len, int& decimal_exponent,
+                   diyfp m_minus, diyfp v, diyfp m_plus)
+{
+    JSON_ASSERT(m_plus.e == m_minus.e);
+    JSON_ASSERT(m_plus.e == v.e);
+
+    //  --------(-----------------------+-----------------------)--------    (A)
+    //          m-                      v                       m+
+    //
+    //  --------------------(-----------+-----------------------)--------    (B)
+    //                      m-          v                       m+
+    //
+    // First scale v (and m- and m+) such that the exponent is in the range
+    // [alpha, gamma].
+
+    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
+
+    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
+
+    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
+    const diyfp w       = diyfp::mul(v,       c_minus_k);
+    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
+    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
+
+    //  ----(---+---)---------------(---+---)---------------(---+---)----
+    //          w-                      w                       w+
+    //          = c*m-                  = c*v                   = c*m+
+    //
+    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
+    // w+ are now off by a small amount.
+    // In fact:
+    //
+    //      w - v * 10^k < 1 ulp
+    //
+    // To account for this inaccuracy, add resp. subtract 1 ulp.
+    //
+    //  --------+---[---------------(---+---)---------------]---+--------
+    //          w-  M-                  w                   M+  w+
+    //
+    // Now any number in [M-, M+] (bounds included) will round to w when input,
+    // regardless of how the input rounding algorithm breaks ties.
+    //
+    // And digit_gen generates the shortest possible such number in [M-, M+].
+    // Note that this does not mean that Grisu2 always generates the shortest
+    // possible number in the interval (m-, m+).
+    const diyfp M_minus(w_minus.f + 1, w_minus.e);
+    const diyfp M_plus (w_plus.f  - 1, w_plus.e );
+
+    decimal_exponent = -cached.k; // = -(-k) = k
+
+    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1)
+void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
+{
+    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
+                  "internal error: not enough precision");
+
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
+    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
+    // decimal representations are not exactly "short".
+    //
+    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
+    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
+    // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
+    // does.
+    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
+    // representation using the corresponding std::from_chars function recovers value exactly". That
+    // indicates that single precision floating-point numbers should be recovered using
+    // 'std::strtof'.
+    //
+    // NB: If the neighbors are computed for single-precision numbers, there is a single float
+    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
+    //     value is off by 1 ulp.
+#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
+    const boundaries w = compute_boundaries(static_cast<double>(value));
+#else
+    const boundaries w = compute_boundaries(value);
+#endif
+
+    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
+}
+
+/*!
+@brief appends a decimal representation of e to buf
+@return a pointer to the element following the exponent.
+@pre -1000 < e < 1000
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* append_exponent(char* buf, int e)
+{
+    JSON_ASSERT(e > -1000);
+    JSON_ASSERT(e <  1000);
+
+    if (e < 0)
+    {
+        e = -e;
+        *buf++ = '-';
+    }
+    else
+    {
+        *buf++ = '+';
+    }
+
+    auto k = static_cast<std::uint32_t>(e);
+    if (k < 10)
+    {
+        // Always print at least two digits in the exponent.
+        // This is for compatibility with printf("%g").
+        *buf++ = '0';
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else if (k < 100)
+    {
+        *buf++ = static_cast<char>('0' + (k / 10));
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else
+    {
+        *buf++ = static_cast<char>('0' + (k / 100));
+        k %= 100;
+        *buf++ = static_cast<char>('0' + (k / 10));
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+
+    return buf;
+}
+
+/*!
+@brief prettify v = buf * 10^decimal_exponent
+
+If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
+notation. Otherwise it will be printed in exponential notation.
+
+@pre min_exp < 0
+@pre max_exp > 0
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* format_buffer(char* buf, int len, int decimal_exponent,
+                           int min_exp, int max_exp)
+{
+    JSON_ASSERT(min_exp < 0);
+    JSON_ASSERT(max_exp > 0);
+
+    const int k = len;
+    const int n = len + decimal_exponent;
+
+    // v = buf * 10^(n-k)
+    // k is the length of the buffer (number of decimal digits)
+    // n is the position of the decimal point relative to the start of the buffer.
+
+    if (k <= n && n <= max_exp)
+    {
+        // digits[000]
+        // len <= max_exp + 2
+
+        std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
+        // Make it look like a floating-point number (#362, #378)
+        buf[n + 0] = '.';
+        buf[n + 1] = '0';
+        return buf + (static_cast<size_t>(n) + 2);
+    }
+
+    if (0 < n && n <= max_exp)
+    {
+        // dig.its
+        // len <= max_digits10 + 1
+
+        JSON_ASSERT(k > n);
+
+        std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
+        buf[n] = '.';
+        return buf + (static_cast<size_t>(k) + 1U);
+    }
+
+    if (min_exp < n && n <= 0)
+    {
+        // 0.[000]digits
+        // len <= 2 + (-min_exp - 1) + max_digits10
+
+        std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
+        buf[0] = '0';
+        buf[1] = '.';
+        std::memset(buf + 2, '0', static_cast<size_t>(-n));
+        return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
+    }
+
+    if (k == 1)
+    {
+        // dE+123
+        // len <= 1 + 5
+
+        buf += 1;
+    }
+    else
+    {
+        // d.igitsE+123
+        // len <= max_digits10 + 1 + 5
+
+        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
+        buf[1] = '.';
+        buf += 1 + static_cast<size_t>(k);
+    }
+
+    *buf++ = 'e';
+    return append_exponent(buf, n - 1);
+}
+
+}  // namespace dtoa_impl
+
+/*!
+@brief generates a decimal representation of the floating-point number value in [first, last).
+
+The format of the resulting decimal representation is similar to printf's %g
+format. Returns an iterator pointing past-the-end of the decimal representation.
+
+@note The input number must be finite, i.e. NaN's and Inf's are not supported.
+@note The buffer must be large enough.
+@note The result is NOT null-terminated.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1, 2)
+JSON_HEDLEY_RETURNS_NON_NULL
+char* to_chars(char* first, const char* last, FloatType value)
+{
+    static_cast<void>(last); // maybe unused - fix warning
+    JSON_ASSERT(std::isfinite(value));
+
+    // Use signbit(value) instead of (value < 0) since signbit works for -0.
+    if (std::signbit(value))
+    {
+        value = -value;
+        *first++ = '-';
+    }
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+    if (value == 0) // +-0
+    {
+        *first++ = '0';
+        // Make it look like a floating-point number (#362, #378)
+        *first++ = '.';
+        *first++ = '0';
+        return first;
+    }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
+
+    // Compute v = buffer * 10^decimal_exponent.
+    // The decimal digits are stored in the buffer, which needs to be interpreted
+    // as an unsigned decimal integer.
+    // len is the length of the buffer, i.e., the number of decimal digits.
+    int len = 0;
+    int decimal_exponent = 0;
+    dtoa_impl::grisu2(first, len, decimal_exponent, value);
+
+    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
+
+    // Format the buffer like printf("%.*g", prec, value)
+    constexpr int kMinExp = -4;
+    // Use digits10 here to increase compatibility with version 2.
+    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
+
+    JSON_ASSERT(last - first >= kMaxExp + 2);
+    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
+
+    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////////////
+// serialization //
+///////////////////
+
+/// how to treat decoding errors
+enum class error_handler_t
+{
+    strict,  ///< throw a type_error exception in case of invalid UTF-8
+    replace, ///< replace invalid UTF-8 sequences with U+FFFD
+    ignore   ///< ignore invalid UTF-8 sequences
+};
+
+template<typename BasicJsonType>
+class serializer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using binary_char_t = typename BasicJsonType::binary_t::value_type;
+    static constexpr std::uint8_t UTF8_ACCEPT = 0;
+    static constexpr std::uint8_t UTF8_REJECT = 1;
+
+  public:
+    /*!
+    @param[in] s  output stream to serialize to
+    @param[in] ichar  indentation character to use
+    @param[in] error_handler_  how to react on decoding errors
+    */
+    serializer(output_adapter_t<char> s, const char ichar,
+               error_handler_t error_handler_ = error_handler_t::strict)
+        : o(std::move(s))
+        , loc(std::localeconv())
+        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
+        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
+        , indent_char(ichar)
+        , indent_string(512, indent_char)
+        , error_handler(error_handler_)
+    {}
+
+    // deleted because of pointer members
+    serializer(const serializer&) = delete;
+    serializer& operator=(const serializer&) = delete;
+    serializer(serializer&&) = delete;
+    serializer& operator=(serializer&&) = delete;
+    ~serializer() = default;
+
+    /*!
+    @brief internal implementation of the serialization function
+
+    This function is called by the public member function dump and organizes
+    the serialization internally. The indentation level is propagated as
+    additional parameter. In case of arrays and objects, the function is
+    called recursively.
+
+    - strings and object keys are escaped using `escape_string()`
+    - integer numbers are converted implicitly via `operator<<`
+    - floating-point numbers are converted to a string using `"%g"` format
+    - binary values are serialized as objects containing the subtype and the
+      byte array
+
+    @param[in] val               value to serialize
+    @param[in] pretty_print      whether the output shall be pretty-printed
+    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
+    in the output are escaped with `\uXXXX` sequences, and the result consists
+    of ASCII characters only.
+    @param[in] indent_step       the indent level
+    @param[in] current_indent    the current indent level (only used internally)
+    */
+    void dump(const BasicJsonType& val,
+              const bool pretty_print,
+              const bool ensure_ascii,
+              const unsigned int indent_step,
+              const unsigned int current_indent = 0)
+    {
+        switch (val.m_data.m_type)
+        {
+            case value_t::object:
+            {
+                if (val.m_data.m_value.object->empty())
+                {
+                    o->write_characters("{}", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    auto i = val.m_data.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\": ", 3);
+                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\": ", 3);
+                    dump(i->second, true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_character('{');
+
+                    // first n-1 elements
+                    auto i = val.m_data.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\":", 2);
+                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\":", 2);
+                    dump(i->second, false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character('}');
+                }
+
+                return;
+            }
+
+            case value_t::array:
+            {
+                if (val.m_data.m_value.array->empty())
+                {
+                    o->write_characters("[]", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("[\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    for (auto i = val.m_data.m_value.array->cbegin();
+                            i != val.m_data.m_value.array->cend() - 1; ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        dump(*i, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_data.m_value.array->empty());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    dump(val.m_data.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character(']');
+                }
+                else
+                {
+                    o->write_character('[');
+
+                    // first n-1 elements
+                    for (auto i = val.m_data.m_value.array->cbegin();
+                            i != val.m_data.m_value.array->cend() - 1; ++i)
+                    {
+                        dump(*i, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_data.m_value.array->empty());
+                    dump(val.m_data.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character(']');
+                }
+
+                return;
+            }
+
+            case value_t::string:
+            {
+                o->write_character('\"');
+                dump_escaped(*val.m_data.m_value.string, ensure_ascii);
+                o->write_character('\"');
+                return;
+            }
+
+            case value_t::binary:
+            {
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"bytes\": [", 10);
+
+                    if (!val.m_data.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_data.m_value.binary->cbegin();
+                                i != val.m_data.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_characters(", ", 2);
+                        }
+                        dump_integer(val.m_data.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\n", 3);
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"subtype\": ", 11);
+                    if (val.m_data.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_data.m_value.binary->subtype());
+                    }
+                    else
+                    {
+                        o->write_characters("null", 4);
+                    }
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_characters("{\"bytes\":[", 10);
+
+                    if (!val.m_data.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_data.m_value.binary->cbegin();
+                                i != val.m_data.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_character(',');
+                        }
+                        dump_integer(val.m_data.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\"subtype\":", 12);
+                    if (val.m_data.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_data.m_value.binary->subtype());
+                        o->write_character('}');
+                    }
+                    else
+                    {
+                        o->write_characters("null}", 5);
+                    }
+                }
+                return;
+            }
+
+            case value_t::boolean:
+            {
+                if (val.m_data.m_value.boolean)
+                {
+                    o->write_characters("true", 4);
+                }
+                else
+                {
+                    o->write_characters("false", 5);
+                }
+                return;
+            }
+
+            case value_t::number_integer:
+            {
+                dump_integer(val.m_data.m_value.number_integer);
+                return;
+            }
+
+            case value_t::number_unsigned:
+            {
+                dump_integer(val.m_data.m_value.number_unsigned);
+                return;
+            }
+
+            case value_t::number_float:
+            {
+                dump_float(val.m_data.m_value.number_float);
+                return;
+            }
+
+            case value_t::discarded:
+            {
+                o->write_characters("<discarded>", 11);
+                return;
+            }
+
+            case value_t::null:
+            {
+                o->write_characters("null", 4);
+                return;
+            }
+
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief dump escaped string
+
+    Escape a string by replacing certain special characters by a sequence of an
+    escape character (backslash) and another character and other control
+    characters by a sequence of "\u" followed by a four-digit hex
+    representation. The escaped string is written to output stream @a o.
+
+    @param[in] s  the string to escape
+    @param[in] ensure_ascii  whether to escape non-ASCII characters with
+                             \uXXXX sequences
+
+    @complexity Linear in the length of string @a s.
+    */
+    void dump_escaped(const string_t& s, const bool ensure_ascii)
+    {
+        std::uint32_t codepoint{};
+        std::uint8_t state = UTF8_ACCEPT;
+        std::size_t bytes = 0;  // number of bytes written to string_buffer
+
+        // number of bytes written at the point of the last valid byte
+        std::size_t bytes_after_last_accept = 0;
+        std::size_t undumped_chars = 0;
+
+        for (std::size_t i = 0; i < s.size(); ++i)
+        {
+            const auto byte = static_cast<std::uint8_t>(s[i]);
+
+            switch (decode(state, codepoint, byte))
+            {
+                case UTF8_ACCEPT:  // decode found a new code point
+                {
+                    switch (codepoint)
+                    {
+                        case 0x08: // backspace
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'b';
+                            break;
+                        }
+
+                        case 0x09: // horizontal tab
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 't';
+                            break;
+                        }
+
+                        case 0x0A: // newline
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'n';
+                            break;
+                        }
+
+                        case 0x0C: // formfeed
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'f';
+                            break;
+                        }
+
+                        case 0x0D: // carriage return
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'r';
+                            break;
+                        }
+
+                        case 0x22: // quotation mark
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\"';
+                            break;
+                        }
+
+                        case 0x5C: // reverse solidus
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\\';
+                            break;
+                        }
+
+                        default:
+                        {
+                            // escape control characters (0x00..0x1F) or, if
+                            // ensure_ascii parameter is used, non-ASCII characters
+                            if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
+                            {
+                                if (codepoint <= 0xFFFF)
+                                {
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                                      static_cast<std::uint16_t>(codepoint)));
+                                    bytes += 6;
+                                }
+                                else
+                                {
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
+                                    bytes += 12;
+                                }
+                            }
+                            else
+                            {
+                                // copy byte to buffer (all previous bytes
+                                // been copied have in default case above)
+                                string_buffer[bytes++] = s[i];
+                            }
+                            break;
+                        }
+                    }
+
+                    // write buffer and reset index; there must be 13 bytes
+                    // left, as this is the maximal number of bytes to be
+                    // written ("\uxxxx\uxxxx\0") for one code point
+                    if (string_buffer.size() - bytes < 13)
+                    {
+                        o->write_characters(string_buffer.data(), bytes);
+                        bytes = 0;
+                    }
+
+                    // remember the byte position of this accept
+                    bytes_after_last_accept = bytes;
+                    undumped_chars = 0;
+                    break;
+                }
+
+                case UTF8_REJECT:  // decode found invalid UTF-8 byte
+                {
+                    switch (error_handler)
+                    {
+                        case error_handler_t::strict:
+                        {
+                            JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", hex_bytes(byte | 0)), nullptr));
+                        }
+
+                        case error_handler_t::ignore:
+                        case error_handler_t::replace:
+                        {
+                            // in case we saw this character the first time, we
+                            // would like to read it again, because the byte
+                            // may be OK for itself, but just not OK for the
+                            // previous sequence
+                            if (undumped_chars > 0)
+                            {
+                                --i;
+                            }
+
+                            // reset length buffer to the last accepted index;
+                            // thus removing/ignoring the invalid characters
+                            bytes = bytes_after_last_accept;
+
+                            if (error_handler == error_handler_t::replace)
+                            {
+                                // add a replacement character
+                                if (ensure_ascii)
+                                {
+                                    string_buffer[bytes++] = '\\';
+                                    string_buffer[bytes++] = 'u';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'd';
+                                }
+                                else
+                                {
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
+                                }
+
+                                // write buffer and reset index; there must be 13 bytes
+                                // left, as this is the maximal number of bytes to be
+                                // written ("\uxxxx\uxxxx\0") for one code point
+                                if (string_buffer.size() - bytes < 13)
+                                {
+                                    o->write_characters(string_buffer.data(), bytes);
+                                    bytes = 0;
+                                }
+
+                                bytes_after_last_accept = bytes;
+                            }
+
+                            undumped_chars = 0;
+
+                            // continue processing the string
+                            state = UTF8_ACCEPT;
+                            break;
+                        }
+
+                        default:            // LCOV_EXCL_LINE
+                            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+
+                default:  // decode found yet incomplete multibyte code point
+                {
+                    if (!ensure_ascii)
+                    {
+                        // code point will not be escaped - copy byte to buffer
+                        string_buffer[bytes++] = s[i];
+                    }
+                    ++undumped_chars;
+                    break;
+                }
+            }
+        }
+
+        // we finished processing the string
+        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
+        {
+            // write buffer
+            if (bytes > 0)
+            {
+                o->write_characters(string_buffer.data(), bytes);
+            }
+        }
+        else
+        {
+            // we finish reading, but do not accept: string was incomplete
+            switch (error_handler)
+            {
+                case error_handler_t::strict:
+                {
+                    JSON_THROW(type_error::create(316, concat("incomplete UTF-8 string; last byte: 0x", hex_bytes(static_cast<std::uint8_t>(s.back() | 0))), nullptr));
+                }
+
+                case error_handler_t::ignore:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    break;
+                }
+
+                case error_handler_t::replace:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    // add a replacement character
+                    if (ensure_ascii)
+                    {
+                        o->write_characters("\\ufffd", 6);
+                    }
+                    else
+                    {
+                        o->write_characters("\xEF\xBF\xBD", 3);
+                    }
+                    break;
+                }
+
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            }
+        }
+    }
+
+  private:
+    /*!
+    @brief count digits
+
+    Count the number of decimal (base 10) digits for an input unsigned integer.
+
+    @param[in] x  unsigned integer number to count its digits
+    @return    number of decimal digits
+    */
+    unsigned int count_digits(number_unsigned_t x) noexcept
+    {
+        unsigned int n_digits = 1;
+        for (;;)
+        {
+            if (x < 10)
+            {
+                return n_digits;
+            }
+            if (x < 100)
+            {
+                return n_digits + 1;
+            }
+            if (x < 1000)
+            {
+                return n_digits + 2;
+            }
+            if (x < 10000)
+            {
+                return n_digits + 3;
+            }
+            x = x / 10000u;
+            n_digits += 4;
+        }
+    }
+
+    /*!
+     * @brief convert a byte to a uppercase hex representation
+     * @param[in] byte byte to represent
+     * @return representation ("00".."FF")
+     */
+    static std::string hex_bytes(std::uint8_t byte)
+    {
+        std::string result = "FF";
+        constexpr const char* nibble_to_hex = "0123456789ABCDEF";
+        result[0] = nibble_to_hex[byte / 16];
+        result[1] = nibble_to_hex[byte % 16];
+        return result;
+    }
+
+    // templates to avoid warnings about useless casts
+    template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
+    bool is_negative_number(NumberType x)
+    {
+        return x < 0;
+    }
+
+    template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >
+    bool is_negative_number(NumberType /*unused*/)
+    {
+        return false;
+    }
+
+    /*!
+    @brief dump an integer
+
+    Dump a given integer to output stream @a o. Works internally with
+    @a number_buffer.
+
+    @param[in] x  integer number (signed or unsigned) to dump
+    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
+    */
+    template < typename NumberType, detail::enable_if_t <
+                   std::is_integral<NumberType>::value ||
+                   std::is_same<NumberType, number_unsigned_t>::value ||
+                   std::is_same<NumberType, number_integer_t>::value ||
+                   std::is_same<NumberType, binary_char_t>::value,
+                   int > = 0 >
+    void dump_integer(NumberType x)
+    {
+        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
+        {
+            {
+                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
+                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
+                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
+                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
+                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
+                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
+                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
+                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
+                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
+                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
+            }
+        };
+
+        // special case for "0"
+        if (x == 0)
+        {
+            o->write_character('0');
+            return;
+        }
+
+        // use a pointer to fill the buffer
+        auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+
+        number_unsigned_t abs_value;
+
+        unsigned int n_chars{};
+
+        if (is_negative_number(x))
+        {
+            *buffer_ptr = '-';
+            abs_value = remove_sign(static_cast<number_integer_t>(x));
+
+            // account one more byte for the minus sign
+            n_chars = 1 + count_digits(abs_value);
+        }
+        else
+        {
+            abs_value = static_cast<number_unsigned_t>(x);
+            n_chars = count_digits(abs_value);
+        }
+
+        // spare 1 byte for '\0'
+        JSON_ASSERT(n_chars < number_buffer.size() - 1);
+
+        // jump to the end to generate the string from backward,
+        // so we later avoid reversing the result
+        buffer_ptr += static_cast<typename decltype(number_buffer)::difference_type>(n_chars);
+
+        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
+        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
+        while (abs_value >= 100)
+        {
+            const auto digits_index = static_cast<unsigned>((abs_value % 100));
+            abs_value /= 100;
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+
+        if (abs_value >= 10)
+        {
+            const auto digits_index = static_cast<unsigned>(abs_value);
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+        else
+        {
+            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
+        }
+
+        o->write_characters(number_buffer.data(), n_chars);
+    }
+
+    /*!
+    @brief dump a floating-point number
+
+    Dump a given floating-point number to output stream @a o. Works internally
+    with @a number_buffer.
+
+    @param[in] x  floating-point number to dump
+    */
+    void dump_float(number_float_t x)
+    {
+        // NaN / inf
+        if (!std::isfinite(x))
+        {
+            o->write_characters("null", 4);
+            return;
+        }
+
+        // If number_float_t is an IEEE-754 single or double precision number,
+        // use the Grisu2 algorithm to produce short numbers which are
+        // guaranteed to round-trip, using strtof and strtod, resp.
+        //
+        // NB: The test below works if <long double> == <double>.
+        static constexpr bool is_ieee_single_or_double
+            = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
+              (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
+
+        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
+    }
+
+    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
+    {
+        auto* begin = number_buffer.data();
+        auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
+
+        o->write_characters(begin, static_cast<size_t>(end - begin));
+    }
+
+    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
+    {
+        // get the number of digits for a float -> text -> float round-trip
+        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
+
+        // the actual conversion
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
+
+        // negative value indicates an error
+        JSON_ASSERT(len > 0);
+        // check if the buffer was large enough
+        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
+
+        // erase thousands separators
+        if (thousands_sep != '\0')
+        {
+            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081
+            const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
+            std::fill(end, number_buffer.end(), '\0');
+            JSON_ASSERT((end - number_buffer.begin()) <= len);
+            len = (end - number_buffer.begin());
+        }
+
+        // convert decimal point to '.'
+        if (decimal_point != '\0' && decimal_point != '.')
+        {
+            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081
+            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
+            if (dec_pos != number_buffer.end())
+            {
+                *dec_pos = '.';
+            }
+        }
+
+        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
+
+        // determine if we need to append ".0"
+        const bool value_is_int_like =
+            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
+                         [](char c)
+        {
+            return c == '.' || c == 'e';
+        });
+
+        if (value_is_int_like)
+        {
+            o->write_characters(".0", 2);
+        }
+    }
+
+    /*!
+    @brief check whether a string is UTF-8 encoded
+
+    The function checks each byte of a string whether it is UTF-8 encoded. The
+    result of the check is stored in the @a state parameter. The function must
+    be called initially with state 0 (accept). State 1 means the string must
+    be rejected, because the current byte is not allowed. If the string is
+    completely processed, but the state is non-zero, the string ended
+    prematurely; that is, the last byte indicated more bytes should have
+    followed.
+
+    @param[in,out] state  the state of the decoding
+    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
+    @param[in] byte       next byte to decode
+    @return               new state
+
+    @note The function has been edited: a std::array is used.
+
+    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+    */
+    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
+    {
+        static const std::array<std::uint8_t, 400> utf8d =
+        {
+            {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
+                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
+                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
+                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
+                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
+                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
+                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
+                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
+                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
+            }
+        };
+
+        JSON_ASSERT(byte < utf8d.size());
+        const std::uint8_t type = utf8d[byte];
+
+        codep = (state != UTF8_ACCEPT)
+                ? (byte & 0x3fu) | (codep << 6u)
+                : (0xFFu >> type) & (byte);
+
+        const std::size_t index = 256u + (static_cast<size_t>(state) * 16u) + static_cast<size_t>(type);
+        JSON_ASSERT(index < utf8d.size());
+        state = utf8d[index];
+        return state;
+    }
+
+    /*
+     * Overload to make the compiler happy while it is instantiating
+     * dump_integer for number_unsigned_t.
+     * Must never be called.
+     */
+    number_unsigned_t remove_sign(number_unsigned_t x)
+    {
+        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        return x; // LCOV_EXCL_LINE
+    }
+
+    /*
+     * Helper function for dump_integer
+     *
+     * This function takes a negative signed integer and returns its absolute
+     * value as an unsigned integer. The plus/minus shuffling is necessary as we
+     * cannot directly remove the sign of an arbitrary signed integer as the
+     * absolute values of INT_MIN and INT_MAX are usually not the same. See
+     * #1708 for details.
+     */
+    number_unsigned_t remove_sign(number_integer_t x) noexcept
+    {
+        JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
+        return static_cast<number_unsigned_t>(-(x + 1)) + 1;
+    }
+
+  private:
+    /// the output of the serializer
+    output_adapter_t<char> o = nullptr;
+
+    /// a (hopefully) large enough character buffer
+    std::array<char, 64> number_buffer{{}};
+
+    /// the locale
+    const std::lconv* loc = nullptr;
+    /// the locale's thousand separator character
+    const char thousands_sep = '\0';
+    /// the locale's decimal point character
+    const char decimal_point = '\0';
+
+    /// string buffer
+    std::array<char, 512> string_buffer{{}};
+
+    /// the indentation character
+    const char indent_char;
+    /// the indentation string
+    string_t indent_string;
+
+    /// error_handler how to react on decoding errors
+    const error_handler_t error_handler;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/value_t.hpp>
+
+// #include <nlohmann/json_fwd.hpp>
+
+// #include <nlohmann/ordered_map.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <functional> // equal_to, less
+#include <initializer_list> // initializer_list
+#include <iterator> // input_iterator_tag, iterator_traits
+#include <memory> // allocator
+#include <stdexcept> // for out_of_range
+#include <type_traits> // enable_if, is_convertible
+#include <utility> // pair
+#include <vector> // vector
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// ordered_map: a minimal map-like container that preserves insertion order
+/// for use within nlohmann::basic_json<ordered_map>
+template <class Key, class T, class IgnoredLess = std::less<Key>,
+          class Allocator = std::allocator<std::pair<const Key, T>>>
+              struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
+{
+    using key_type = Key;
+    using mapped_type = T;
+    using Container = std::vector<std::pair<const Key, T>, Allocator>;
+    using iterator = typename Container::iterator;
+    using const_iterator = typename Container::const_iterator;
+    using size_type = typename Container::size_type;
+    using value_type = typename Container::value_type;
+#ifdef JSON_HAS_CPP_14
+    using key_compare = std::equal_to<>;
+#else
+    using key_compare = std::equal_to<Key>;
+#endif
+
+    // Explicit constructors instead of `using Container::Container`
+    // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
+    ordered_map() noexcept(noexcept(Container())) : Container{} {}
+    explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container(alloc))) : Container{alloc} {}
+    template <class It>
+    ordered_map(It first, It last, const Allocator& alloc = Allocator())
+        : Container{first, last, alloc} {}
+    ordered_map(std::initializer_list<value_type> init, const Allocator& alloc = Allocator() )
+        : Container{init, alloc} {}
+
+    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return {it, false};
+            }
+        }
+        Container::emplace_back(key, std::forward<T>(t));
+        return {std::prev(this->end()), true};
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    std::pair<iterator, bool> emplace(KeyType && key, T && t)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return {it, false};
+            }
+        }
+        Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
+        return {std::prev(this->end()), true};
+    }
+
+    T& operator[](const key_type& key)
+    {
+        return emplace(key, T{}).first->second;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    T & operator[](KeyType && key)
+    {
+        return emplace(std::forward<KeyType>(key), T{}).first->second;
+    }
+
+    const T& operator[](const key_type& key) const
+    {
+        return at(key);
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    const T & operator[](KeyType && key) const
+    {
+        return at(std::forward<KeyType>(key));
+    }
+
+    T& at(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    T & at(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    const T& at(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    const T & at(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    size_type erase(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator erase(iterator pos)
+    {
+        return erase(pos, std::next(pos));
+    }
+
+    iterator erase(iterator first, iterator last)
+    {
+        if (first == last)
+        {
+            return first;
+        }
+
+        const auto elements_affected = std::distance(first, last);
+        const auto offset = std::distance(Container::begin(), first);
+
+        // This is the start situation. We need to delete elements_affected
+        // elements (3 in this example: e, f, g), and need to return an
+        // iterator past the last deleted element (h in this example).
+        // Note that offset is the distance from the start of the vector
+        // to first. We will need this later.
+
+        // [ a, b, c, d, e, f, g, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // Since we cannot move const Keys, we re-construct them in place.
+        // We start at first and re-construct (viz. copy) the elements from
+        // the back of the vector. Example for the first iteration:
+
+        //               ,--------.
+        //               v        |   destroy e and re-construct with h
+        // [ a, b, c, d, e, f, g, h, i, j ]
+        //               ^        ^
+        //               it       it + elements_affected
+
+        for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
+        {
+            it->~value_type(); // destroy but keep allocation
+            new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
+        }
+
+        // [ a, b, c, d, h, i, j, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // remove the unneeded elements at the end of the vector
+        Container::resize(this->size() - static_cast<size_type>(elements_affected));
+
+        // [ a, b, c, d, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // first is now pointing past the last deleted element, but we cannot
+        // use this iterator, because it may have been invalidated by the
+        // resize call. Instead, we can return begin() + offset.
+        return Container::begin() + offset;
+    }
+
+    size_type count(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    size_type count(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator find(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    const_iterator find(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    std::pair<iterator, bool> insert( value_type&& value )
+    {
+        return emplace(value.first, std::move(value.second));
+    }
+
+    std::pair<iterator, bool> insert( const value_type& value )
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, value.first))
+            {
+                return {it, false};
+            }
+        }
+        Container::push_back(value);
+        return {--this->end(), true};
+    }
+
+    template<typename InputIt>
+    using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
+        std::input_iterator_tag>::value>::type;
+
+    template<typename InputIt, typename = require_input_iter<InputIt>>
+    void insert(InputIt first, InputIt last)
+    {
+        for (auto it = first; it != last; ++it)
+        {
+            insert(*it);
+        }
+    }
+
+private:
+    JSON_NO_UNIQUE_ADDRESS key_compare m_compare = key_compare();
+};
+
+NLOHMANN_JSON_NAMESPACE_END
+
+
+#if defined(JSON_HAS_CPP_17)
+    #if JSON_HAS_STATIC_RTTI
+        #include <any>
+    #endif
+    #include <string_view>
+#endif
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/*!
+@brief a class to store JSON values
+
+@internal
+@invariant The member variables @a m_value and @a m_type have the following
+relationship:
+- If `m_type == value_t::object`, then `m_value.object != nullptr`.
+- If `m_type == value_t::array`, then `m_value.array != nullptr`.
+- If `m_type == value_t::string`, then `m_value.string != nullptr`.
+The invariants are checked by member function assert_invariant().
+
+@note ObjectType trick from https://stackoverflow.com/a/9860911
+@endinternal
+
+@since version 1.0.0
+
+@nosubgrouping
+*/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+    : public ::nlohmann::detail::json_base_class<CustomBaseClass>
+{
+  private:
+    template<detail::value_t> friend struct detail::external_constructor;
+
+    template<typename>
+    friend class ::nlohmann::json_pointer;
+    // can be restored when json_pointer backwards compatibility is removed
+    // friend ::nlohmann::json_pointer<StringType>;
+
+    template<typename BasicJsonType, typename InputType>
+    friend class ::nlohmann::detail::parser;
+    friend ::nlohmann::detail::serializer<basic_json>;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::iter_impl;
+    template<typename BasicJsonType, typename CharType>
+    friend class ::nlohmann::detail::binary_writer;
+    template<typename BasicJsonType, typename InputType, typename SAX>
+    friend class ::nlohmann::detail::binary_reader;
+    template<typename BasicJsonType, typename InputAdapterType>
+    friend class ::nlohmann::detail::json_sax_dom_parser;
+    template<typename BasicJsonType, typename InputAdapterType>
+    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
+    friend class ::nlohmann::detail::exception;
+
+    /// workaround type for MSVC
+    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
+    using json_base_class_t = ::nlohmann::detail::json_base_class<CustomBaseClass>;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // convenience aliases for types residing in namespace detail;
+    using lexer = ::nlohmann::detail::lexer_base<basic_json>;
+
+    template<typename InputAdapterType>
+    static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
+        InputAdapterType adapter,
+        detail::parser_callback_t<basic_json>cb = nullptr,
+        const bool allow_exceptions = true,
+        const bool ignore_comments = false
+                                 )
+    {
+        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
+            std::move(cb), allow_exceptions, ignore_comments);
+    }
+
+  private:
+    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
+    template<typename BasicJsonType>
+    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
+    template<typename BasicJsonType>
+    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
+    template<typename Iterator>
+    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
+    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
+
+    template<typename CharType>
+    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
+
+    template<typename InputType>
+    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
+    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    using serializer = ::nlohmann::detail::serializer<basic_json>;
+
+  public:
+    using value_t = detail::value_t;
+    /// JSON Pointer, see @ref nlohmann::json_pointer
+    using json_pointer = ::nlohmann::json_pointer<StringType>;
+    template<typename T, typename SFINAE>
+    using json_serializer = JSONSerializer<T, SFINAE>;
+    /// how to treat decoding errors
+    using error_handler_t = detail::error_handler_t;
+    /// how to treat CBOR tags
+    using cbor_tag_handler_t = detail::cbor_tag_handler_t;
+    /// how to encode BJData
+    using bjdata_version_t = detail::bjdata_version_t;
+    /// helper type for initializer lists of basic_json values
+    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
+
+    using input_format_t = detail::input_format_t;
+    /// SAX interface type, see @ref nlohmann::json_sax
+    using json_sax_t = json_sax<basic_json>;
+
+    ////////////////
+    // exceptions //
+    ////////////////
+
+    /// @name exceptions
+    /// Classes to implement user-defined exceptions.
+    /// @{
+
+    using exception = detail::exception;
+    using parse_error = detail::parse_error;
+    using invalid_iterator = detail::invalid_iterator;
+    using type_error = detail::type_error;
+    using out_of_range = detail::out_of_range;
+    using other_error = detail::other_error;
+
+    /// @}
+
+    /////////////////////
+    // container types //
+    /////////////////////
+
+    /// @name container types
+    /// The canonic container types to use @ref basic_json like any other STL
+    /// container.
+    /// @{
+
+    /// the type of elements in a basic_json container
+    using value_type = basic_json;
+
+    /// the type of an element reference
+    using reference = value_type&;
+    /// the type of an element const reference
+    using const_reference = const value_type&;
+
+    /// a type to represent differences between iterators
+    using difference_type = std::ptrdiff_t;
+    /// a type to represent container sizes
+    using size_type = std::size_t;
+
+    /// the allocator type
+    using allocator_type = AllocatorType<basic_json>;
+
+    /// the type of an element pointer
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    /// the type of an element const pointer
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+
+    /// an iterator for a basic_json container
+    using iterator = iter_impl<basic_json>;
+    /// a const iterator for a basic_json container
+    using const_iterator = iter_impl<const basic_json>;
+    /// a reverse iterator for a basic_json container
+    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
+    /// a const reverse iterator for a basic_json container
+    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
+
+    /// @}
+
+    /// @brief returns the allocator associated with the container
+    /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
+    static allocator_type get_allocator()
+    {
+        return allocator_type();
+    }
+
+    /// @brief returns version information on the library
+    /// @sa https://json.nlohmann.me/api/basic_json/meta/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json meta()
+    {
+        basic_json result;
+
+        result["copyright"] = "(C) 2013-2025 Niels Lohmann";
+        result["name"] = "JSON for Modern C++";
+        result["url"] = "https://github.com/nlohmann/json";
+        result["version"]["string"] =
+            detail::concat(std::to_string(NLOHMANN_JSON_VERSION_MAJOR), '.',
+                           std::to_string(NLOHMANN_JSON_VERSION_MINOR), '.',
+                           std::to_string(NLOHMANN_JSON_VERSION_PATCH));
+        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
+        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
+        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
+
+#ifdef _WIN32
+        result["platform"] = "win32";
+#elif defined __linux__
+        result["platform"] = "linux";
+#elif defined __APPLE__
+        result["platform"] = "apple";
+#elif defined __unix__
+        result["platform"] = "unix";
+#else
+        result["platform"] = "unknown";
+#endif
+
+#if defined(__ICC) || defined(__INTEL_COMPILER)
+        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
+#elif defined(__clang__)
+        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
+#elif defined(__GNUC__) || defined(__GNUG__)
+        result["compiler"] = {{"family", "gcc"}, {"version", detail::concat(
+                    std::to_string(__GNUC__), '.',
+                    std::to_string(__GNUC_MINOR__), '.',
+                    std::to_string(__GNUC_PATCHLEVEL__))
+            }
+        };
+#elif defined(__HP_cc) || defined(__HP_aCC)
+        result["compiler"] = "hp"
+#elif defined(__IBMCPP__)
+        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
+#elif defined(_MSC_VER)
+        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
+#elif defined(__PGI)
+        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
+#elif defined(__SUNPRO_CC)
+        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
+#else
+        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
+#endif
+
+#if defined(_MSVC_LANG)
+        result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
+#elif defined(__cplusplus)
+        result["compiler"]["c++"] = std::to_string(__cplusplus);
+#else
+        result["compiler"]["c++"] = "unknown";
+#endif
+        return result;
+    }
+
+    ///////////////////////////
+    // JSON value data types //
+    ///////////////////////////
+
+    /// @name JSON value data types
+    /// The data types to store a JSON value. These types are derived from
+    /// the template arguments passed to class @ref basic_json.
+    /// @{
+
+    /// @brief default object key comparator type
+    /// The actual object key comparator type (@ref object_comparator_t) may be
+    /// different.
+    /// @sa https://json.nlohmann.me/api/basic_json/default_object_comparator_t/
+#if defined(JSON_HAS_CPP_14)
+    // use of transparent comparator avoids unnecessary repeated construction of temporaries
+    // in functions involving lookup by key with types other than object_t::key_type (aka. StringType)
+    using default_object_comparator_t = std::less<>;
+#else
+    using default_object_comparator_t = std::less<StringType>;
+#endif
+
+    /// @brief a type for an object
+    /// @sa https://json.nlohmann.me/api/basic_json/object_t/
+    using object_t = ObjectType<StringType,
+          basic_json,
+          default_object_comparator_t,
+          AllocatorType<std::pair<const StringType,
+          basic_json>>>;
+
+    /// @brief a type for an array
+    /// @sa https://json.nlohmann.me/api/basic_json/array_t/
+    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
+
+    /// @brief a type for a string
+    /// @sa https://json.nlohmann.me/api/basic_json/string_t/
+    using string_t = StringType;
+
+    /// @brief a type for a boolean
+    /// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
+    using boolean_t = BooleanType;
+
+    /// @brief a type for a number (integer)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
+    using number_integer_t = NumberIntegerType;
+
+    /// @brief a type for a number (unsigned)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
+    using number_unsigned_t = NumberUnsignedType;
+
+    /// @brief a type for a number (floating-point)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
+    using number_float_t = NumberFloatType;
+
+    /// @brief a type for a packed binary type
+    /// @sa https://json.nlohmann.me/api/basic_json/binary_t/
+    using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
+
+    /// @brief object key comparator type
+    /// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
+    using object_comparator_t = detail::actual_object_comparator_t<basic_json>;
+
+    /// @}
+
+  private:
+
+    /// helper for exception-safe object creation
+    template<typename T, typename... Args>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    static T* create(Args&& ... args)
+    {
+        AllocatorType<T> alloc;
+        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
+
+        auto deleter = [&](T * obj)
+        {
+            AllocatorTraits::deallocate(alloc, obj, 1);
+        };
+        std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
+        AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
+        JSON_ASSERT(obj != nullptr);
+        return obj.release();
+    }
+
+    ////////////////////////
+    // JSON value storage //
+    ////////////////////////
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief a JSON value
+
+    The actual storage for a JSON value of the @ref basic_json class. This
+    union combines the different storage types for the JSON value types
+    defined in @ref value_t.
+
+    JSON type | value_t type    | used type
+    --------- | --------------- | ------------------------
+    object    | object          | pointer to @ref object_t
+    array     | array           | pointer to @ref array_t
+    string    | string          | pointer to @ref string_t
+    boolean   | boolean         | @ref boolean_t
+    number    | number_integer  | @ref number_integer_t
+    number    | number_unsigned | @ref number_unsigned_t
+    number    | number_float    | @ref number_float_t
+    binary    | binary          | pointer to @ref binary_t
+    null      | null            | *no value is stored*
+
+    @note Variable-length types (objects, arrays, and strings) are stored as
+    pointers. The size of the union should not exceed 64 bits if the default
+    value types are used.
+
+    @since version 1.0.0
+    */
+    union json_value
+    {
+        /// object (stored with pointer to save storage)
+        object_t* object;
+        /// array (stored with pointer to save storage)
+        array_t* array;
+        /// string (stored with pointer to save storage)
+        string_t* string;
+        /// binary (stored with pointer to save storage)
+        binary_t* binary;
+        /// boolean
+        boolean_t boolean;
+        /// number (integer)
+        number_integer_t number_integer;
+        /// number (unsigned integer)
+        number_unsigned_t number_unsigned;
+        /// number (floating-point)
+        number_float_t number_float;
+
+        /// default constructor (for null values)
+        json_value() = default;
+        /// constructor for booleans
+        json_value(boolean_t v) noexcept : boolean(v) {}
+        /// constructor for numbers (integer)
+        json_value(number_integer_t v) noexcept : number_integer(v) {}
+        /// constructor for numbers (unsigned)
+        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
+        /// constructor for numbers (floating-point)
+        json_value(number_float_t v) noexcept : number_float(v) {}
+        /// constructor for empty values of a given type
+        json_value(value_t t)
+        {
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    object = create<object_t>();
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    array = create<array_t>();
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    string = create<string_t>("");
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    binary = create<binary_t>();
+                    break;
+                }
+
+                case value_t::boolean:
+                {
+                    boolean = static_cast<boolean_t>(false);
+                    break;
+                }
+
+                case value_t::number_integer:
+                {
+                    number_integer = static_cast<number_integer_t>(0);
+                    break;
+                }
+
+                case value_t::number_unsigned:
+                {
+                    number_unsigned = static_cast<number_unsigned_t>(0);
+                    break;
+                }
+
+                case value_t::number_float:
+                {
+                    number_float = static_cast<number_float_t>(0.0);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    break;
+                }
+
+                case value_t::discarded:
+                default:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
+                    {
+                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.12.0", nullptr)); // LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+            }
+        }
+
+        /// constructor for strings
+        json_value(const string_t& value) : string(create<string_t>(value)) {}
+
+        /// constructor for rvalue strings
+        json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
+
+        /// constructor for objects
+        json_value(const object_t& value) : object(create<object_t>(value)) {}
+
+        /// constructor for rvalue objects
+        json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
+
+        /// constructor for arrays
+        json_value(const array_t& value) : array(create<array_t>(value)) {}
+
+        /// constructor for rvalue arrays
+        json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
+
+        /// constructor for binary arrays
+        json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
+
+        /// constructor for rvalue binary arrays
+        json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
+
+        /// constructor for binary arrays (internal type)
+        json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
+
+        /// constructor for rvalue binary arrays (internal type)
+        json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
+
+        void destroy(value_t t)
+        {
+            if (
+                (t == value_t::object && object == nullptr) ||
+                (t == value_t::array && array == nullptr) ||
+                (t == value_t::string && string == nullptr) ||
+                (t == value_t::binary && binary == nullptr)
+            )
+            {
+                //not initialized (e.g., due to exception in the ctor)
+                return;
+            }
+            if (t == value_t::array || t == value_t::object)
+            {
+                // flatten the current json_value to a heap-allocated stack
+                std::vector<basic_json> stack;
+
+                // move the top-level items to stack
+                if (t == value_t::array)
+                {
+                    stack.reserve(array->size());
+                    std::move(array->begin(), array->end(), std::back_inserter(stack));
+                }
+                else
+                {
+                    stack.reserve(object->size());
+                    for (auto&& it : *object)
+                    {
+                        stack.push_back(std::move(it.second));
+                    }
+                }
+
+                while (!stack.empty())
+                {
+                    // move the last item to a local variable to be processed
+                    basic_json current_item(std::move(stack.back()));
+                    stack.pop_back();
+
+                    // if current_item is array/object, move
+                    // its children to the stack to be processed later
+                    if (current_item.is_array())
+                    {
+                        std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
+
+                        current_item.m_data.m_value.array->clear();
+                    }
+                    else if (current_item.is_object())
+                    {
+                        for (auto&& it : *current_item.m_data.m_value.object)
+                        {
+                            stack.push_back(std::move(it.second));
+                        }
+
+                        current_item.m_data.m_value.object->clear();
+                    }
+
+                    // it's now safe that current_item gets destructed
+                    // since it doesn't have any children
+                }
+            }
+
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    AllocatorType<object_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    AllocatorType<array_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
+                    break;
+                }
+
+                case value_t::null:
+                case value_t::boolean:
+                case value_t::number_integer:
+                case value_t::number_unsigned:
+                case value_t::number_float:
+                case value_t::discarded:
+                default:
+                {
+                    break;
+                }
+            }
+        }
+    };
+
+  private:
+    /*!
+    @brief checks the class invariants
+
+    This function asserts the class invariants. It needs to be called at the
+    end of every constructor to make sure that created objects respect the
+    invariant. Furthermore, it has to be called each time the type of a JSON
+    value is changed, because the invariant expresses a relationship between
+    @a m_type and @a m_value.
+
+    Furthermore, the parent relation is checked for arrays and objects: If
+    @a check_parents true and the value is an array or object, then the
+    container's elements must have the current value as parent.
+
+    @param[in] check_parents  whether the parent relation should be checked.
+               The value is true by default and should only be set to false
+               during destruction of objects when the invariant does not
+               need to hold.
+    */
+    void assert_invariant(bool check_parents = true) const noexcept
+    {
+        JSON_ASSERT(m_data.m_type != value_t::object || m_data.m_value.object != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::array || m_data.m_value.array != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::string || m_data.m_value.string != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::binary || m_data.m_value.binary != nullptr);
+
+#if JSON_DIAGNOSTICS
+        JSON_TRY
+        {
+            // cppcheck-suppress assertWithSideEffect
+            JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
+            {
+                return j.m_parent == this;
+            }));
+        }
+        JSON_CATCH(...) {} // LCOV_EXCL_LINE
+#endif
+        static_cast<void>(check_parents);
+    }
+
+    void set_parents()
+    {
+#if JSON_DIAGNOSTICS
+        switch (m_data.m_type)
+        {
+            case value_t::array:
+            {
+                for (auto& element : *m_data.m_value.array)
+                {
+                    element.m_parent = this;
+                }
+                break;
+            }
+
+            case value_t::object:
+            {
+                for (auto& element : *m_data.m_value.object)
+                {
+                    element.second.m_parent = this;
+                }
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                break;
+        }
+#endif
+    }
+
+    iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
+    {
+#if JSON_DIAGNOSTICS
+        for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)
+        {
+            (it + i)->m_parent = this;
+        }
+#else
+        static_cast<void>(count_set_parents);
+#endif
+        return it;
+    }
+
+    reference set_parent(reference j, std::size_t old_capacity = detail::unknown_size())
+    {
+#if JSON_DIAGNOSTICS
+        if (old_capacity != detail::unknown_size())
+        {
+            // see https://github.com/nlohmann/json/issues/2838
+            JSON_ASSERT(type() == value_t::array);
+            if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
+            {
+                // capacity has changed: update all parents
+                set_parents();
+                return j;
+            }
+        }
+
+        // ordered_json uses a vector internally, so pointers could have
+        // been invalidated; see https://github.com/nlohmann/json/issues/2962
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning(push )
+#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
+#endif
+        if (detail::is_ordered_map<object_t>::value)
+        {
+            set_parents();
+            return j;
+        }
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning( pop )
+#endif
+
+        j.m_parent = this;
+#else
+        static_cast<void>(j);
+        static_cast<void>(old_capacity);
+#endif
+        return j;
+    }
+
+  public:
+    //////////////////////////
+    // JSON parser callback //
+    //////////////////////////
+
+    /// @brief parser event types
+    /// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
+    using parse_event_t = detail::parse_event_t;
+
+    /// @brief per-element parser callback type
+    /// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
+    using parser_callback_t = detail::parser_callback_t<basic_json>;
+
+    //////////////////
+    // constructors //
+    //////////////////
+
+    /// @name constructors and destructors
+    /// Constructors of class @ref basic_json, copy/move constructor, copy
+    /// assignment, static functions creating objects, and the destructor.
+    /// @{
+
+    /// @brief create an empty value with a given type
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(const value_t v)
+        : m_data(v)
+    {
+        assert_invariant();
+    }
+
+    /// @brief create a null object
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-exception-escape)
+        : basic_json(value_t::null)
+    {
+        assert_invariant();
+    }
+
+    /// @brief create a JSON value from compatible types
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename CompatibleType,
+               typename U = detail::uncvref_t<CompatibleType>,
+               detail::enable_if_t <
+                   !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
+    basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
+            JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
+                                       std::forward<CompatibleType>(val))))
+    {
+        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief create a JSON value from an existing one
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
+    basic_json(const BasicJsonType& val)
+#if JSON_DIAGNOSTIC_POSITIONS
+        : start_position(val.start_pos()),
+          end_position(val.end_pos())
+#endif
+    {
+        using other_boolean_t = typename BasicJsonType::boolean_t;
+        using other_number_float_t = typename BasicJsonType::number_float_t;
+        using other_number_integer_t = typename BasicJsonType::number_integer_t;
+        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+        using other_string_t = typename BasicJsonType::string_t;
+        using other_object_t = typename BasicJsonType::object_t;
+        using other_array_t = typename BasicJsonType::array_t;
+        using other_binary_t = typename BasicJsonType::binary_t;
+
+        switch (val.type())
+        {
+            case value_t::boolean:
+                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
+                break;
+            case value_t::number_float:
+                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
+                break;
+            case value_t::number_integer:
+                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
+                break;
+            case value_t::number_unsigned:
+                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
+                break;
+            case value_t::string:
+                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
+                break;
+            case value_t::object:
+                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
+                break;
+            case value_t::array:
+                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
+                break;
+            case value_t::binary:
+                JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
+                break;
+            case value_t::null:
+                *this = nullptr;
+                break;
+            case value_t::discarded:
+                m_data.m_type = value_t::discarded;
+                break;
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+        JSON_ASSERT(m_data.m_type == val.type());
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief create a container (array or object) from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(initializer_list_t init,
+               bool type_deduction = true,
+               value_t manual_type = value_t::array)
+    {
+        // check if each element is an array with two elements whose first
+        // element is a string
+        bool is_an_object = std::all_of(init.begin(), init.end(),
+                                        [](const detail::json_ref<basic_json>& element_ref)
+        {
+            // The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
+            // (many string types can be constructed from 0 via its null-pointer guise, so we get a
+            // broken call to op[key_type], the wrong semantics, and a 4804 warning on Windows)
+            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
+        });
+
+        // adjust type if type deduction is not wanted
+        if (!type_deduction)
+        {
+            // if an array is wanted, do not create an object though possible
+            if (manual_type == value_t::array)
+            {
+                is_an_object = false;
+            }
+
+            // if an object is wanted but impossible, throw an exception
+            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
+            {
+                JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
+            }
+        }
+
+        if (is_an_object)
+        {
+            // the initializer list is a list of pairs -> create an object
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+
+            for (auto& element_ref : init)
+            {
+                auto element = element_ref.moved_or_copied();
+                m_data.m_value.object->emplace(
+                    std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
+                    std::move((*element.m_data.m_value.array)[1]));
+            }
+        }
+        else
+        {
+            // the initializer list describes an array -> create an array
+            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>(init.begin(), init.end());
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief explicitly create a binary array (without subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = init;
+        return res;
+    }
+
+    /// @brief explicitly create a binary array (with subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(init, subtype);
+        return res;
+    }
+
+    /// @brief explicitly create a binary array
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = std::move(init);
+        return res;
+    }
+
+    /// @brief explicitly create a binary array (with subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(std::move(init), subtype);
+        return res;
+    }
+
+    /// @brief explicitly create an array from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/array/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json array(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::array);
+    }
+
+    /// @brief explicitly create an object from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/object/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json object(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::object);
+    }
+
+    /// @brief construct an array with count copies of given value
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(size_type cnt, const basic_json& val):
+        m_data{cnt, val}
+    {
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief construct a JSON container given an iterator range
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < class InputIT, typename std::enable_if <
+                   std::is_same<InputIT, typename basic_json_t::iterator>::value ||
+                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
+    basic_json(InputIT first, InputIT last) // NOLINT(performance-unnecessary-value-param)
+    {
+        JSON_ASSERT(first.m_object != nullptr);
+        JSON_ASSERT(last.m_object != nullptr);
+
+        // make sure the iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", nullptr));
+        }
+
+        // copy type from the first iterator
+        m_data.m_type = first.m_object->m_data.m_type;
+
+        // check if the iterator range is complete for primitive values
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
+                                         || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", first.m_object));
+                }
+                break;
+            }
+
+            case value_t::null:
+            case value_t::object:
+            case value_t::array:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                break;
+        }
+
+        switch (m_data.m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_data.m_value.number_integer = first.m_object->m_data.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value.number_unsigned = first.m_object->m_data.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value.number_float = first.m_object->m_data.m_value.number_float;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value.boolean = first.m_object->m_data.m_value.boolean;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value = *first.m_object->m_data.m_value.string;
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_data.m_value.object = create<object_t>(first.m_it.object_iterator,
+                                        last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value.array = create<array_t>(first.m_it.array_iterator,
+                                                       last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value = *first.m_object->m_data.m_value.binary;
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(invalid_iterator::create(206, detail::concat("cannot construct with iterators from ", first.m_object->type_name()), first.m_object));
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    ///////////////////////////////////////
+    // other constructors and destructor //
+    ///////////////////////////////////////
+
+    template<typename JsonRef,
+             detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
+                                 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
+    basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
+
+    /// @brief copy constructor
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(const basic_json& other)
+        : json_base_class_t(other)
+#if JSON_DIAGNOSTIC_POSITIONS
+        , start_position(other.start_position)
+        , end_position(other.end_position)
+#endif
+    {
+        m_data.m_type = other.m_data.m_type;
+        // check of passed value is valid
+        other.assert_invariant();
+
+        switch (m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_data.m_value = *other.m_data.m_value.object;
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value = *other.m_data.m_value.array;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value = *other.m_data.m_value.string;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value = other.m_data.m_value.boolean;
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                m_data.m_value = other.m_data.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value = other.m_data.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value = other.m_data.m_value.number_float;
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value = *other.m_data.m_value.binary;
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                break;
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief move constructor
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(basic_json&& other) noexcept
+        : json_base_class_t(std::forward<json_base_class_t>(other)),
+          m_data(std::move(other.m_data)) // cppcheck-suppress[accessForwarded] TODO check
+#if JSON_DIAGNOSTIC_POSITIONS
+        , start_position(other.start_position) // cppcheck-suppress[accessForwarded] TODO check
+        , end_position(other.end_position) // cppcheck-suppress[accessForwarded] TODO check
+#endif
+    {
+        // check that the passed value is valid
+        other.assert_invariant(false); // cppcheck-suppress[accessForwarded]
+
+        // invalidate payload
+        other.m_data.m_type = value_t::null;
+        other.m_data.m_value = {};
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        other.start_position = std::string::npos;
+        other.end_position = std::string::npos;
+#endif
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief copy assignment
+    /// @sa https://json.nlohmann.me/api/basic_json/operator=/
+    basic_json& operator=(basic_json other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value&&
+        std::is_nothrow_move_assignable<json_base_class_t>::value
+    )
+    {
+        // check that the passed value is valid
+        other.assert_invariant();
+
+        using std::swap;
+        swap(m_data.m_type, other.m_data.m_type);
+        swap(m_data.m_value, other.m_data.m_value);
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        swap(start_position, other.start_position);
+        swap(end_position, other.end_position);
+#endif
+
+        json_base_class_t::operator=(std::move(other));
+
+        set_parents();
+        assert_invariant();
+        return *this;
+    }
+
+    /// @brief destructor
+    /// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
+    ~basic_json() noexcept
+    {
+        assert_invariant(false);
+    }
+
+    /// @}
+
+  public:
+    ///////////////////////
+    // object inspection //
+    ///////////////////////
+
+    /// @name object inspection
+    /// Functions to inspect the type of a JSON value.
+    /// @{
+
+    /// @brief serialization
+    /// @sa https://json.nlohmann.me/api/basic_json/dump/
+    string_t dump(const int indent = -1,
+                  const char indent_char = ' ',
+                  const bool ensure_ascii = false,
+                  const error_handler_t error_handler = error_handler_t::strict) const
+    {
+        string_t result;
+        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
+
+        if (indent >= 0)
+        {
+            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
+        }
+        else
+        {
+            s.dump(*this, false, ensure_ascii, 0);
+        }
+
+        return result;
+    }
+
+    /// @brief return the type of the JSON value (explicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/type/
+    constexpr value_t type() const noexcept
+    {
+        return m_data.m_type;
+    }
+
+    /// @brief return whether type is primitive
+    /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
+    constexpr bool is_primitive() const noexcept
+    {
+        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
+    }
+
+    /// @brief return whether type is structured
+    /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
+    constexpr bool is_structured() const noexcept
+    {
+        return is_array() || is_object();
+    }
+
+    /// @brief return whether value is null
+    /// @sa https://json.nlohmann.me/api/basic_json/is_null/
+    constexpr bool is_null() const noexcept
+    {
+        return m_data.m_type == value_t::null;
+    }
+
+    /// @brief return whether value is a boolean
+    /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
+    constexpr bool is_boolean() const noexcept
+    {
+        return m_data.m_type == value_t::boolean;
+    }
+
+    /// @brief return whether value is a number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number/
+    constexpr bool is_number() const noexcept
+    {
+        return is_number_integer() || is_number_float();
+    }
+
+    /// @brief return whether value is an integer number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
+    constexpr bool is_number_integer() const noexcept
+    {
+        return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
+    }
+
+    /// @brief return whether value is an unsigned integer number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
+    constexpr bool is_number_unsigned() const noexcept
+    {
+        return m_data.m_type == value_t::number_unsigned;
+    }
+
+    /// @brief return whether value is a floating-point number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
+    constexpr bool is_number_float() const noexcept
+    {
+        return m_data.m_type == value_t::number_float;
+    }
+
+    /// @brief return whether value is an object
+    /// @sa https://json.nlohmann.me/api/basic_json/is_object/
+    constexpr bool is_object() const noexcept
+    {
+        return m_data.m_type == value_t::object;
+    }
+
+    /// @brief return whether value is an array
+    /// @sa https://json.nlohmann.me/api/basic_json/is_array/
+    constexpr bool is_array() const noexcept
+    {
+        return m_data.m_type == value_t::array;
+    }
+
+    /// @brief return whether value is a string
+    /// @sa https://json.nlohmann.me/api/basic_json/is_string/
+    constexpr bool is_string() const noexcept
+    {
+        return m_data.m_type == value_t::string;
+    }
+
+    /// @brief return whether value is a binary array
+    /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
+    constexpr bool is_binary() const noexcept
+    {
+        return m_data.m_type == value_t::binary;
+    }
+
+    /// @brief return whether value is discarded
+    /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
+    constexpr bool is_discarded() const noexcept
+    {
+        return m_data.m_type == value_t::discarded;
+    }
+
+    /// @brief return the type of the JSON value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
+    constexpr operator value_t() const noexcept
+    {
+        return m_data.m_type;
+    }
+
+    /// @}
+
+  private:
+    //////////////////
+    // value access //
+    //////////////////
+
+    /// get a boolean (explicit)
+    boolean_t get_impl(boolean_t* /*unused*/) const
+    {
+        if (JSON_HEDLEY_LIKELY(is_boolean()))
+        {
+            return m_data.m_value.boolean;
+        }
+
+        JSON_THROW(type_error::create(302, detail::concat("type must be boolean, but is ", type_name()), this));
+    }
+
+    /// get a pointer to the value (object)
+    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
+    {
+        return is_object() ? m_data.m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (object)
+    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
+    {
+        return is_object() ? m_data.m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
+    {
+        return is_array() ? m_data.m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
+    {
+        return is_array() ? m_data.m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
+    {
+        return is_string() ? m_data.m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
+    {
+        return is_string() ? m_data.m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
+    {
+        return is_boolean() ? &m_data.m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
+    {
+        return is_boolean() ? &m_data.m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
+    {
+        return m_data.m_type == value_t::number_integer ? &m_data.m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
+    {
+        return m_data.m_type == value_t::number_integer ? &m_data.m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
+    {
+        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
+    {
+        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
+    {
+        return is_number_float() ? &m_data.m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
+    {
+        return is_number_float() ? &m_data.m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
+    {
+        return is_binary() ? m_data.m_value.binary : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
+    {
+        return is_binary() ? m_data.m_value.binary : nullptr;
+    }
+
+    /*!
+    @brief helper function to implement get_ref()
+
+    This function helps to implement get_ref() without code duplication for
+    const and non-const overloads
+
+    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
+
+    @throw type_error.303 if ReferenceType does not match underlying value
+    type of the current JSON
+    */
+    template<typename ReferenceType, typename ThisType>
+    static ReferenceType get_ref_impl(ThisType& obj)
+    {
+        // delegate the call to get_ptr<>()
+        auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
+
+        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
+        {
+            return *ptr;
+        }
+
+        JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
+    }
+
+  public:
+    /// @name value access
+    /// Direct access to the stored value of a JSON value.
+    /// @{
+
+    /// @brief get a pointer value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>()
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /// @brief get a pointer value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
+    template < typename PointerType, typename std::enable_if <
+                   std::is_pointer<PointerType>::value&&
+                   std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
+    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>() const
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+  private:
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType ret;
+    JSONSerializer<ValueType>::from_json(*this, ret);
+    return ret;
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+    - @ref json_serializer<ValueType> does not have a `from_json()` method of
+      the form `ValueType from_json(const basic_json&)`
+
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get__ValueType_const}
+
+    @since version 2.1.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   detail::is_default_constructible<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
+            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
+    {
+        auto ret = ValueType();
+        JSONSerializer<ValueType>::from_json(*this, ret);
+        return ret;
+    }
+
+    /*!
+    @brief get a value (explicit); special case
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    return JSONSerializer<ValueType>::from_json(*this);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json and
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `ValueType from_json(const basic_json&)`
+
+    @note If @ref json_serializer<ValueType> has both overloads of
+    `from_json()`, this one is chosen.
+
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @since version 2.1.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
+            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
+    {
+        return JSONSerializer<ValueType>::from_json(*this);
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads converts the current @ref basic_json in a different
+    @ref basic_json type
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this, converted into @a BasicJsonType
+
+    @complexity Depending on the implementation of the called `from_json()`
+                method.
+
+    @since version 3.2.0
+    */
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value,
+                   int > = 0 >
+    BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads avoids a lot of template boilerplate, it can be seen as the
+    identity method
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this
+
+    @complexity Constant.
+
+    @since version 2.1.0
+    */
+    template<typename BasicJsonType,
+             detail::enable_if_t<
+                 std::is_same<BasicJsonType, basic_json_t>::value,
+                 int> = 0>
+    basic_json get_impl(detail::priority_tag<3> /*unused*/) const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+    @copydoc get()
+    */
+    template<typename PointerType,
+             detail::enable_if_t<
+                 std::is_pointer<PointerType>::value,
+                 int> = 0>
+    constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
+    -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+  public:
+    /*!
+    @brief get a (pointer) value (explicit)
+
+    Performs explicit type conversion between the JSON value and a compatible value if required.
+
+    - If the requested type is a pointer to the internally stored JSON value that pointer is returned.
+    No copies are made.
+
+    - If the requested type is the current @ref basic_json, or a different @ref basic_json convertible
+    from the current @ref basic_json.
+
+    - Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`
+    method.
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @tparam ValueType if necessary
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required
+
+    @since version 2.1.0
+    */
+    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
+#if defined(JSON_HAS_CPP_14)
+    constexpr
+#endif
+    auto get() const noexcept(
+    noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
+    -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
+    {
+        // we cannot static_assert on ValueTypeCV being non-const, because
+        // there is support for get<const basic_json_t>(), which is why we
+        // still need the uncvref
+        static_assert(!std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        return get_impl<ValueType>(detail::priority_tag<4> {});
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+
+    Explicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning The pointer becomes invalid if the underlying JSON object
+    changes.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get__PointerType}
+
+    @sa see @ref get_ptr() for explicit pointer-member access
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /// @brief get a value (explicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_to/
+    template < typename ValueType,
+               detail::enable_if_t <
+                   !detail::is_basic_json<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType & get_to(ValueType& v) const noexcept(noexcept(
+            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<ValueType>::from_json(*this, v);
+        return v;
+    }
+
+    // specialization to allow calling get_to with a basic_json value
+    // see https://github.com/nlohmann/json/issues/2175
+    template<typename ValueType,
+             detail::enable_if_t <
+                 detail::is_basic_json<ValueType>::value,
+                 int> = 0>
+    ValueType & get_to(ValueType& v) const
+    {
+        v = *this;
+        return v;
+    }
+
+    template <
+        typename T, std::size_t N,
+        typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+        detail::enable_if_t <
+            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
+    Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+    noexcept(noexcept(JSONSerializer<Array>::from_json(
+                          std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<Array>::from_json(*this, v);
+        return v;
+    }
+
+    /// @brief get a reference value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
+    template<typename ReferenceType, typename std::enable_if<
+                 std::is_reference<ReferenceType>::value, int>::type = 0>
+    ReferenceType get_ref()
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /// @brief get a reference value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
+    template < typename ReferenceType, typename std::enable_if <
+                   std::is_reference<ReferenceType>::value&&
+                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
+    ReferenceType get_ref() const
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a value (implicit)
+
+    Implicit type conversion between the JSON value and a compatible value.
+    The call is realized by calling @ref get() const.
+
+    @tparam ValueType non-pointer type compatible to the JSON value, for
+    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+    `std::vector` types for JSON arrays. The character type of @ref string_t
+    as well as an initializer list of this type is excluded to avoid
+    ambiguities as these types implicitly convert to `std::string`.
+
+    @return copy of the JSON value, converted to type @a ValueType
+
+    @throw type_error.302 in case passed type @a ValueType is incompatible
+    to the JSON value type (e.g., the JSON value is of type boolean, but a
+    string is requested); see example below
+
+    @complexity Linear in the size of the JSON value.
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,operator__ValueType}
+
+    @since version 1.0.0
+    */
+    template < typename ValueType, typename std::enable_if <
+                   detail::conjunction <
+                       detail::negation<std::is_pointer<ValueType>>,
+                       detail::negation<std::is_same<ValueType, std::nullptr_t>>,
+                       detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
+                                        detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
+                                        detail::negation<detail::is_basic_json<ValueType>>,
+                                        detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
+#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
+                                                detail::negation<std::is_same<ValueType, std::string_view>>,
+#endif
+#if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
+                                                detail::negation<std::is_same<ValueType, std::any>>,
+#endif
+                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
+                                                >::value, int >::type = 0 >
+                                        JSON_EXPLICIT operator ValueType() const
+    {
+        // delegate the call to get<>() const
+        return get<ValueType>();
+    }
+
+    /// @brief get a binary value
+    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
+    binary_t& get_binary()
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
+        }
+
+        return *get_ptr<binary_t*>();
+    }
+
+    /// @brief get a binary value
+    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
+    const binary_t& get_binary() const
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
+        }
+
+        return *get_ptr<const binary_t*>();
+    }
+
+    /// @}
+
+    ////////////////////
+    // element access //
+    ////////////////////
+
+    /// @name element access
+    /// Access to the JSON value.
+    /// @{
+
+    /// @brief access specified array element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(size_type idx)
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return set_parent(m_data.m_value.array->at(idx));
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create a better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            } // cppcheck-suppress[missingReturn]
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+    }
+
+    /// @brief access specified array element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(size_type idx) const
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_data.m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create a better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            } // cppcheck-suppress[missingReturn]
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(const typename object_t::key_type& key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(key);
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
+        }
+        return set_parent(it->second);
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    reference at(KeyType && key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
+        }
+        return set_parent(it->second);
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(const typename object_t::key_type& key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(key);
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
+        }
+        return it->second;
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    const_reference at(KeyType && key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
+        }
+        return it->second;
+    }
+
+    /// @brief access specified array element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](size_type idx)
+    {
+        // implicitly convert a null value to an empty array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // fill up the array with null values if given idx is outside the range
+            if (idx >= m_data.m_value.array->size())
+            {
+#if JSON_DIAGNOSTICS
+                // remember array size & capacity before resizing
+                const auto old_size = m_data.m_value.array->size();
+                const auto old_capacity = m_data.m_value.array->capacity();
+#endif
+                m_data.m_value.array->resize(idx + 1);
+
+#if JSON_DIAGNOSTICS
+                if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
+                {
+                    // capacity has changed: update all parents
+                    set_parents();
+                }
+                else
+                {
+                    // set parent for values added above
+                    set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
+                }
+#endif
+                assert_invariant();
+            }
+
+            return m_data.m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
+    }
+
+    /// @brief access specified array element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](size_type idx) const
+    {
+        // const operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            return m_data.m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](typename object_t::key_type key) // NOLINT(performance-unnecessary-value-param)
+    {
+        // implicitly convert a null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
+            return set_parent(result.first->second);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](const typename object_t::key_type& key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto it = m_data.m_value.object->find(key);
+            JSON_ASSERT(it != m_data.m_value.object->end());
+            return it->second;
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    // these two functions resolve a (const) char * ambiguity affecting Clang and MSVC
+    // (they seemingly cannot be constrained to resolve the ambiguity)
+    template<typename T>
+    reference operator[](T* key)
+    {
+        return operator[](typename object_t::key_type(key));
+    }
+
+    template<typename T>
+    const_reference operator[](T* key) const
+    {
+        return operator[](typename object_t::key_type(key));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    reference operator[](KeyType && key)
+    {
+        // implicitly convert a null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto result = m_data.m_value.object->emplace(std::forward<KeyType>(key), nullptr);
+            return set_parent(result.first->second);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    const_reference operator[](KeyType && key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+            JSON_ASSERT(it != m_data.m_value.object->end());
+            return it->second;
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+  private:
+    template<typename KeyType>
+    using is_comparable_with_object_key = detail::is_comparable <
+        object_comparator_t, const typename object_t::key_type&, KeyType >;
+
+    template<typename ValueType>
+    using value_return_type = std::conditional <
+        detail::is_c_string_uncvref<ValueType>::value,
+        string_t, typename std::decay<ValueType>::type >;
+
+  public:
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, detail::enable_if_t <
+                   !detail::is_transparent<object_comparator_t>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // If 'key' is found, return its value. Otherwise, return `default_value'.
+            const auto it = find(key);
+            if (it != end())
+            {
+                return it->template get<ValueType>();
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   !detail::is_transparent<object_comparator_t>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(const typename object_t::key_type& key, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // If 'key' is found, return its value. Otherwise, return `default_value'.
+            const auto it = find(key);
+            if (it != end())
+            {
+                return it->template get<ReturnType>();
+            }
+
+            return std::forward<ValueType>(default_value);
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class KeyType, detail::enable_if_t <
+                   detail::is_transparent<object_comparator_t>::value
+                   && !detail::is_json_pointer<KeyType>::value
+                   && is_comparable_with_object_key<KeyType>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(KeyType && key, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // If 'key' is found, return its value. Otherwise, return `default_value'.
+            const auto it = find(std::forward<KeyType>(key));
+            if (it != end())
+            {
+                return it->template get<ValueType>();
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class KeyType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_transparent<object_comparator_t>::value
+                   && !detail::is_json_pointer<KeyType>::value
+                   && is_comparable_with_object_key<KeyType>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(KeyType && key, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // If 'key' is found, return its value. Otherwise, return `default_value'.
+            const auto it = find(std::forward<KeyType>(key));
+            if (it != end())
+            {
+                return it->template get<ReturnType>();
+            }
+
+            return std::forward<ValueType>(default_value);
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, detail::enable_if_t <
+                   detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // If the pointer resolves to a value, return it. Otherwise, return
+            // 'default_value'.
+            JSON_TRY
+            {
+                return ptr.get_checked(this).template get<ValueType>();
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return default_value;
+            }
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(const json_pointer& ptr, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // If the pointer resolves to a value, return it. Otherwise, return
+            // 'default_value'.
+            JSON_TRY
+            {
+                return ptr.get_checked(this).template get<ReturnType>();
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return std::forward<ValueType>(default_value);
+            }
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    template < class ValueType, class BasicJsonType, detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const
+    {
+        return value(ptr.convert(), default_value);
+    }
+
+    template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const
+    {
+        return value(ptr.convert(), std::forward<ValueType>(default_value));
+    }
+
+    /// @brief access the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/front/
+    reference front()
+    {
+        return *begin();
+    }
+
+    /// @brief access the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/front/
+    const_reference front() const
+    {
+        return *cbegin();
+    }
+
+    /// @brief access the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/back/
+    reference back()
+    {
+        auto tmp = end();
+        --tmp;
+        return *tmp;
+    }
+
+    /// @brief access the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/back/
+    const_reference back() const
+    {
+        auto tmp = cend();
+        --tmp;
+        return *tmp;
+    }
+
+    /// @brief remove element given an iterator
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template < class IteratorType, detail::enable_if_t <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
+    IteratorType erase(IteratorType pos) // NOLINT(performance-unnecessary-value-param)
+    {
+        // make sure the iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        IteratorType result = end();
+
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
+                {
+                    JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
+                    m_data.m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
+                    m_data.m_value.binary = nullptr;
+                }
+
+                m_data.m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return result;
+    }
+
+    /// @brief remove elements given an iterator range
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template < class IteratorType, detail::enable_if_t <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
+    IteratorType erase(IteratorType first, IteratorType last) // NOLINT(performance-unnecessary-value-param)
+    {
+        // make sure the iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", this));
+        }
+
+        IteratorType result = end();
+
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
+                                       || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", this));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
+                    m_data.m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
+                    m_data.m_value.binary = nullptr;
+                }
+
+                m_data.m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_data.m_value.object->erase(first.m_it.object_iterator,
+                                              last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_data.m_value.array->erase(first.m_it.array_iterator,
+                                             last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return result;
+    }
+
+  private:
+    template < typename KeyType, detail::enable_if_t <
+                   detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    size_type erase_internal(KeyType && key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return m_data.m_value.object->erase(std::forward<KeyType>(key));
+    }
+
+    template < typename KeyType, detail::enable_if_t <
+                   !detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    size_type erase_internal(KeyType && key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        const auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it != m_data.m_value.object->end())
+        {
+            m_data.m_value.object->erase(it);
+            return 1;
+        }
+        return 0;
+    }
+
+  public:
+
+    /// @brief remove element from a JSON object given a key
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    size_type erase(const typename object_t::key_type& key)
+    {
+        // the indirection via erase_internal() is added to avoid making this
+        // function a template and thus de-rank it during overload resolution
+        return erase_internal(key);
+    }
+
+    /// @brief remove element from a JSON object given a key
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    size_type erase(KeyType && key)
+    {
+        return erase_internal(std::forward<KeyType>(key));
+    }
+
+    /// @brief remove element from a JSON array given an index
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    void erase(const size_type idx)
+    {
+        // this erase only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
+            {
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            }
+
+            m_data.m_value.array->erase(m_data.m_value.array->begin() + static_cast<difference_type>(idx));
+        }
+        else
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+    }
+
+    /// @}
+
+    ////////////
+    // lookup //
+    ////////////
+
+    /// @name lookup
+    /// @{
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    iterator find(const typename object_t::key_type& key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(key);
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    const_iterator find(const typename object_t::key_type& key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(key);
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    iterator find(KeyType && key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    const_iterator find(KeyType && key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
+        }
+
+        return result;
+    }
+
+    /// @brief returns the number of occurrences of a key in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/count/
+    size_type count(const typename object_t::key_type& key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_data.m_value.object->count(key) : 0;
+    }
+
+    /// @brief returns the number of occurrences of a key in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/count/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    size_type count(KeyType && key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_data.m_value.object->count(std::forward<KeyType>(key)) : 0;
+    }
+
+    /// @brief check the existence of an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    bool contains(const typename object_t::key_type& key) const
+    {
+        return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
+    }
+
+    /// @brief check the existence of an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    bool contains(KeyType && key) const
+    {
+        return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
+    }
+
+    /// @brief check the existence of an element in a JSON object given a JSON pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    bool contains(const json_pointer& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    /// @}
+
+    ///////////////
+    // iterators //
+    ///////////////
+
+    /// @name iterators
+    /// @{
+
+    /// @brief returns an iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/begin/
+    iterator begin() noexcept
+    {
+        iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /// @brief returns an iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/begin/
+    const_iterator begin() const noexcept
+    {
+        return cbegin();
+    }
+
+    /// @brief returns a const iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/cbegin/
+    const_iterator cbegin() const noexcept
+    {
+        const_iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/end/
+    iterator end() noexcept
+    {
+        iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/end/
+    const_iterator end() const noexcept
+    {
+        return cend();
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/cend/
+    const_iterator cend() const noexcept
+    {
+        const_iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /// @brief returns an iterator to the reverse-beginning
+    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
+    reverse_iterator rbegin() noexcept
+    {
+        return reverse_iterator(end());
+    }
+
+    /// @brief returns an iterator to the reverse-beginning
+    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return crbegin();
+    }
+
+    /// @brief returns an iterator to the reverse-end
+    /// @sa https://json.nlohmann.me/api/basic_json/rend/
+    reverse_iterator rend() noexcept
+    {
+        return reverse_iterator(begin());
+    }
+
+    /// @brief returns an iterator to the reverse-end
+    /// @sa https://json.nlohmann.me/api/basic_json/rend/
+    const_reverse_iterator rend() const noexcept
+    {
+        return crend();
+    }
+
+    /// @brief returns a const reverse iterator to the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/crbegin/
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return const_reverse_iterator(cend());
+    }
+
+    /// @brief returns a const reverse iterator to one before the first
+    /// @sa https://json.nlohmann.me/api/basic_json/crend/
+    const_reverse_iterator crend() const noexcept
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
+  public:
+    /// @brief wrapper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use @ref items() instead;
+    ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /// @brief wrapper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
+    ///         version 4.0.0 of the library. Please use @ref items() instead;
+    ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /// @brief helper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    iteration_proxy<iterator> items() noexcept
+    {
+        return iteration_proxy<iterator>(*this);
+    }
+
+    /// @brief helper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    iteration_proxy<const_iterator> items() const noexcept
+    {
+        return iteration_proxy<const_iterator>(*this);
+    }
+
+    /// @}
+
+    //////////////
+    // capacity //
+    //////////////
+
+    /// @name capacity
+    /// @{
+
+    /// @brief checks whether the container is empty.
+    /// @sa https://json.nlohmann.me/api/basic_json/empty/
+    bool empty() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return true;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::empty()
+                return m_data.m_value.array->empty();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::empty()
+                return m_data.m_value.object->empty();
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types are nonempty
+                return false;
+            }
+        }
+    }
+
+    /// @brief returns the number of elements
+    /// @sa https://json.nlohmann.me/api/basic_json/size/
+    size_type size() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return 0;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::size()
+                return m_data.m_value.array->size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::size()
+                return m_data.m_value.object->size();
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types have size 1
+                return 1;
+            }
+        }
+    }
+
+    /// @brief returns the maximum possible number of elements
+    /// @sa https://json.nlohmann.me/api/basic_json/max_size/
+    size_type max_size() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::array:
+            {
+                // delegate call to array_t::max_size()
+                return m_data.m_value.array->max_size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::max_size()
+                return m_data.m_value.object->max_size();
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types have max_size() == size()
+                return size();
+            }
+        }
+    }
+
+    /// @}
+
+    ///////////////
+    // modifiers //
+    ///////////////
+
+    /// @name modifiers
+    /// @{
+
+    /// @brief clears the contents
+    /// @sa https://json.nlohmann.me/api/basic_json/clear/
+    void clear() noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_data.m_value.number_integer = 0;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value.number_unsigned = 0;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value.number_float = 0.0;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value.boolean = false;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value.string->clear();
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value.binary->clear();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value.array->clear();
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_data.m_value.object->clear();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(basic_json&& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform a null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add the element to the array (move semantics)
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->push_back(std::move(val));
+        set_parent(m_data.m_value.array->back(), old_capacity);
+        // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(basic_json&& val)
+    {
+        push_back(std::move(val));
+        return *this;
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(const basic_json& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform a null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add the element to the array
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->push_back(val);
+        set_parent(m_data.m_value.array->back(), old_capacity);
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(const basic_json& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(const typename object_t::value_type& val)
+    {
+        // push_back only works for null objects or objects
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform a null object into an object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add the element to the object
+        auto res = m_data.m_value.object->insert(val);
+        set_parent(res.first->second);
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(const typename object_t::value_type& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(initializer_list_t init)
+    {
+        if (is_object() && init.size() == 2 && (*init.begin())->is_string())
+        {
+            basic_json&& key = init.begin()->moved_or_copied();
+            push_back(typename object_t::value_type(
+                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
+        }
+        else
+        {
+            push_back(basic_json(init));
+        }
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(initializer_list_t init)
+    {
+        push_back(init);
+        return *this;
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
+    template<class... Args>
+    reference emplace_back(Args&& ... args)
+    {
+        // emplace_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
+        }
+
+        // transform a null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add the element to the array (perfect forwarding)
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
+        return set_parent(m_data.m_value.array->back(), old_capacity);
+    }
+
+    /// @brief add an object to an object if key does not exist
+    /// @sa https://json.nlohmann.me/api/basic_json/emplace/
+    template<class... Args>
+    std::pair<iterator, bool> emplace(Args&& ... args)
+    {
+        // emplace only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace() with ", type_name()), this));
+        }
+
+        // transform a null object into an object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add the element to the array (perfect forwarding)
+        auto res = m_data.m_value.object->emplace(std::forward<Args>(args)...);
+        set_parent(res.first->second);
+
+        // create a result iterator and set iterator to the result of emplace
+        auto it = begin();
+        it.m_it.object_iterator = res.first;
+
+        // return pair of iterator and boolean
+        return {it, res.second};
+    }
+
+    /// Helper for insertion of an iterator
+    /// @note: This uses std::distance to support GCC 4.8,
+    ///        see https://github.com/nlohmann/json/pull/1257
+    template<typename... Args>
+    iterator insert_iterator(const_iterator pos, Args&& ... args) // NOLINT(performance-unnecessary-value-param)
+    {
+        iterator result(this);
+        JSON_ASSERT(m_data.m_value.array != nullptr);
+
+        auto insert_pos = std::distance(m_data.m_value.array->begin(), pos.m_it.array_iterator);
+        m_data.m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
+        result.m_it.array_iterator = m_data.m_value.array->begin() + insert_pos;
+
+        // This could have been written as:
+        // result.m_it.array_iterator = m_data.m_value.array->insert(pos.m_it.array_iterator, cnt, val);
+        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
+
+        set_parents();
+        return result;
+    }
+
+    /// @brief inserts element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, const basic_json& val) // NOLINT(performance-unnecessary-value-param)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, val);
+        }
+
+        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+    }
+
+    /// @brief inserts element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, basic_json&& val) // NOLINT(performance-unnecessary-value-param)
+    {
+        return insert(pos, val);
+    }
+
+    /// @brief inserts copies of element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, size_type cnt, const basic_json& val) // NOLINT(performance-unnecessary-value-param)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, cnt, val);
+        }
+
+        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+    }
+
+    /// @brief inserts range of elements into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, const_iterator first, const_iterator last) // NOLINT(performance-unnecessary-value-param)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
+        {
+            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", this));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
+    }
+
+    /// @brief inserts elements from initializer list into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, initializer_list_t ilist) // NOLINT(performance-unnecessary-value-param)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, ilist.begin(), ilist.end());
+    }
+
+    /// @brief inserts range of elements into object
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    void insert(const_iterator first, const_iterator last) // NOLINT(performance-unnecessary-value-param)
+    {
+        // insert only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", this));
+        }
+
+        m_data.m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
+        set_parents();
+    }
+
+    /// @brief updates a JSON object from another object, overwriting existing keys
+    /// @sa https://json.nlohmann.me/api/basic_json/update/
+    void update(const_reference j, bool merge_objects = false)
+    {
+        update(j.begin(), j.end(), merge_objects);
+    }
+
+    /// @brief updates a JSON object from another object, overwriting existing keys
+    /// @sa https://json.nlohmann.me/api/basic_json/update/
+    void update(const_iterator first, const_iterator last, bool merge_objects = false) // NOLINT(performance-unnecessary-value-param)
+    {
+        // implicitly convert a null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", type_name()), this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
+        }
+
+        for (auto it = first; it != last; ++it)
+        {
+            if (merge_objects && it.value().is_object())
+            {
+                auto it2 = m_data.m_value.object->find(it.key());
+                if (it2 != m_data.m_value.object->end())
+                {
+                    it2->second.update(it.value(), true);
+                    continue;
+                }
+            }
+            m_data.m_value.object->operator[](it.key()) = it.value();
+#if JSON_DIAGNOSTICS
+            m_data.m_value.object->operator[](it.key()).m_parent = this;
+#endif
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(reference other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        std::swap(m_data.m_type, other.m_data.m_type);
+        std::swap(m_data.m_value, other.m_data.m_value);
+
+        set_parents();
+        other.set_parents();
+        assert_invariant();
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    friend void swap(reference left, reference right) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        left.swap(right);
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(array_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.array), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(array_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(object_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.object), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(object_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(string_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_string()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.string), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(string_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(binary_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t::container_type&) with ", type_name()), this));
+        }
+    }
+
+    /// @}
+
+    //////////////////////////////////////////
+    // lexicographical comparison operators //
+    //////////////////////////////////////////
+
+    /// @name lexicographical comparison operators
+    /// @{
+
+    // note parentheses around operands are necessary; see
+    // https://github.com/nlohmann/json/issues/1530
+#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result)                       \
+    const auto lhs_type = lhs.type();                                                                    \
+    const auto rhs_type = rhs.type();                                                                    \
+    \
+    if (lhs_type == rhs_type) /* NOLINT(readability/braces) */                                           \
+    {                                                                                                    \
+        switch (lhs_type)                                                                                \
+        {                                                                                                \
+            case value_t::array:                                                                         \
+                return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array);                                     \
+                \
+            case value_t::object:                                                                        \
+                return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object);                                   \
+                \
+            case value_t::null:                                                                          \
+                return (null_result);                                                                    \
+                \
+            case value_t::string:                                                                        \
+                return (*lhs.m_data.m_value.string) op (*rhs.m_data.m_value.string);                                   \
+                \
+            case value_t::boolean:                                                                       \
+                return (lhs.m_data.m_value.boolean) op (rhs.m_data.m_value.boolean);                                   \
+                \
+            case value_t::number_integer:                                                                \
+                return (lhs.m_data.m_value.number_integer) op (rhs.m_data.m_value.number_integer);                     \
+                \
+            case value_t::number_unsigned:                                                               \
+                return (lhs.m_data.m_value.number_unsigned) op (rhs.m_data.m_value.number_unsigned);                   \
+                \
+            case value_t::number_float:                                                                  \
+                return (lhs.m_data.m_value.number_float) op (rhs.m_data.m_value.number_float);                         \
+                \
+            case value_t::binary:                                                                        \
+                return (*lhs.m_data.m_value.binary) op (*rhs.m_data.m_value.binary);                                   \
+                \
+            case value_t::discarded:                                                                     \
+            default:                                                                                     \
+                return (unordered_result);                                                               \
+        }                                                                                                \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)                   \
+    {                                                                                                    \
+        return static_cast<number_float_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float;      \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)                   \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_integer);      \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)                  \
+    {                                                                                                    \
+        return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float;     \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)                  \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_unsigned);     \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)                \
+    {                                                                                                    \
+        return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_integer; \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)                \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>(rhs.m_data.m_value.number_unsigned); \
+    }                                                                                                    \
+    else if(compares_unordered(lhs, rhs))\
+    {\
+        return (unordered_result);\
+    }\
+    \
+    return (default_result);
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // returns true if:
+    // - any operand is NaN and the other operand is of number type
+    // - any operand is discarded
+    // in legacy mode, discarded values are considered ordered if
+    // an operation is computed as an odd number of inverses of others
+    static bool compares_unordered(const_reference lhs, const_reference rhs, bool inverse = false) noexcept
+    {
+        if ((lhs.is_number_float() && std::isnan(lhs.m_data.m_value.number_float) && rhs.is_number())
+                || (rhs.is_number_float() && std::isnan(rhs.m_data.m_value.number_float) && lhs.is_number()))
+        {
+            return true;
+        }
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+        return (lhs.is_discarded() || rhs.is_discarded()) && !inverse;
+#else
+        static_cast<void>(inverse);
+        return lhs.is_discarded() || rhs.is_discarded();
+#endif
+    }
+
+  private:
+    bool compares_unordered(const_reference rhs, bool inverse = false) const noexcept
+    {
+        return compares_unordered(*this, rhs, inverse);
+    }
+
+  public:
+#if JSON_HAS_THREE_WAY_COMPARISON
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    bool operator==(const_reference rhs) const noexcept
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        const_reference lhs = *this;
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator==(ScalarType rhs) const noexcept
+    {
+        return *this == basic_json(rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    bool operator!=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !operator==(rhs);
+    }
+
+    /// @brief comparison: 3-way
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
+    std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD*
+    {
+        const_reference lhs = *this;
+        // default_result is used if we cannot compare values. In that case,
+        // we compare types.
+        JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*
+                                std::partial_ordering::equivalent,
+                                std::partial_ordering::unordered,
+                                lhs_type <=> rhs_type) // *NOPAD*
+    }
+
+    /// @brief comparison: 3-way
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    std::partial_ordering operator<=>(ScalarType rhs) const noexcept // *NOPAD*
+    {
+        return *this <=> basic_json(rhs); // *NOPAD*
+    }
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    // all operators that are computed as an odd number of inverses of others
+    // need to be overloaded to emulate the legacy comparison behavior
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
+    bool operator<=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !(rhs < *this);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator<=(ScalarType rhs) const noexcept
+    {
+        return *this <= basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
+    bool operator>=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !(*this < rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator>=(ScalarType rhs) const noexcept
+    {
+        return *this >= basic_json(rhs);
+    }
+#endif
+#else
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs == basic_json(rhs);
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) == rhs;
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(lhs == rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs != basic_json(rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) != rhs;
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
+    {
+        // default_result is used if we cannot compare values. In that case,
+        // we compare types. Note we have to call the operator explicitly,
+        // because MSVC has problems otherwise.
+        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type))
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs < basic_json(rhs);
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) < rhs;
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(rhs < lhs);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs <= basic_json(rhs);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) <= rhs;
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
+    {
+        // double inverse
+        if (compares_unordered(lhs, rhs))
+        {
+            return false;
+        }
+        return !(lhs <= rhs);
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs > basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) > rhs;
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(lhs < rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs >= basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) >= rhs;
+    }
+#endif
+
+#undef JSON_IMPLEMENT_OPERATOR
+
+    /// @}
+
+    ///////////////////
+    // serialization //
+    ///////////////////
+
+    /// @name serialization
+    /// @{
+#ifndef JSON_NO_IO
+    /// @brief serialize to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
+    {
+        // read width member and use it as the indentation parameter if nonzero
+        const bool pretty_print = o.width() > 0;
+        const auto indentation = pretty_print ? o.width() : 0;
+
+        // reset width to 0 for subsequent calls to this stream
+        o.width(0);
+
+        // do the actual serialization
+        serializer s(detail::output_adapter<char>(o), o.fill());
+        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
+        return o;
+    }
+
+    /// @brief serialize to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    /// @deprecated This function is deprecated since 3.0.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             operator<<(std::ostream&, const basic_json&) instead; that is,
+    ///             replace calls like `j >> o;` with `o << j;`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
+    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
+    {
+        return o << j;
+    }
+#endif  // JSON_NO_IO
+    /// @}
+
+    /////////////////////
+    // deserialization //
+    /////////////////////
+
+    /// @name deserialization
+    /// @{
+
+    /// @brief deserialize from a compatible input
+    /// @sa https://json.nlohmann.me/api/basic_json/parse/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(InputType&& i,
+                            parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::forward<InputType>(i)), std::move(cb), allow_exceptions, ignore_comments).parse(true, result); // cppcheck-suppress[accessMoved,accessForwarded]
+        return result;
+    }
+
+    /// @brief deserialize from a pair of character iterators
+    /// @sa https://json.nlohmann.me/api/basic_json/parse/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(IteratorType first,
+                            IteratorType last,
+                            parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::move(first), std::move(last)), std::move(cb), allow_exceptions, ignore_comments).parse(true, result); // cppcheck-suppress[accessMoved]
+        return result;
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
+    static basic_json parse(detail::span_input_adapter&& i,
+                            parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(i.get(), std::move(cb), allow_exceptions, ignore_comments).parse(true, result); // cppcheck-suppress[accessMoved]
+        return result;
+    }
+
+    /// @brief check if the input is valid JSON
+    /// @sa https://json.nlohmann.me/api/basic_json/accept/
+    template<typename InputType>
+    static bool accept(InputType&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    /// @brief check if the input is valid JSON
+    /// @sa https://json.nlohmann.me/api/basic_json/accept/
+    template<typename IteratorType>
+    static bool accept(IteratorType first, IteratorType last,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
+    static bool accept(detail::span_input_adapter&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(i.get(), nullptr, false, ignore_comments).accept(true);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    template <typename InputType, typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(InputType&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    template<class IteratorType, class SAX>
+    JSON_HEDLEY_NON_NULL(3)
+    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    /// @deprecated This function is deprecated since 3.8.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             sax_parse(ptr, ptr + len) instead.
+    template <typename SAX>
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = i.get();
+        return format == input_format_t::json
+               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+#ifndef JSON_NO_IO
+    /// @brief deserialize from stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
+    /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             operator>>(std::istream&, basic_json&) instead; that is,
+    ///             replace calls like `j << i;` with `i >> j;`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
+    friend std::istream& operator<<(basic_json& j, std::istream& i)
+    {
+        return operator>>(i, j);
+    }
+
+    /// @brief deserialize from stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
+    friend std::istream& operator>>(std::istream& i, basic_json& j)
+    {
+        parser(detail::input_adapter(i)).parse(false, j);
+        return i;
+    }
+#endif  // JSON_NO_IO
+    /// @}
+
+    ///////////////////////////
+    // convenience functions //
+    ///////////////////////////
+
+    /// @brief return the type as string
+    /// @sa https://json.nlohmann.me/api/basic_json/type_name/
+    JSON_HEDLEY_RETURNS_NON_NULL
+    const char* type_name() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+                return "null";
+            case value_t::object:
+                return "object";
+            case value_t::array:
+                return "array";
+            case value_t::string:
+                return "string";
+            case value_t::boolean:
+                return "boolean";
+            case value_t::binary:
+                return "binary";
+            case value_t::discarded:
+                return "discarded";
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            default:
+                return "number";
+        }
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    //////////////////////
+    // member variables //
+    //////////////////////
+
+    struct data
+    {
+        /// the type of the current element
+        value_t m_type = value_t::null;
+
+        /// the value of the current element
+        json_value m_value = {};
+
+        data(const value_t v)
+            : m_type(v), m_value(v)
+        {
+        }
+
+        data(size_type cnt, const basic_json& val)
+            : m_type(value_t::array)
+        {
+            m_value.array = create<array_t>(cnt, val);
+        }
+
+        data() noexcept = default;
+        data(data&&) noexcept = default;
+        data(const data&) noexcept = delete;
+        data& operator=(data&&) noexcept = delete;
+        data& operator=(const data&) noexcept = delete;
+
+        ~data() noexcept
+        {
+            m_value.destroy(m_type);
+        }
+    };
+
+    data m_data = {};
+
+#if JSON_DIAGNOSTICS
+    /// a pointer to a parent value (for debugging purposes)
+    basic_json* m_parent = nullptr;
+#endif
+
+#if JSON_DIAGNOSTIC_POSITIONS
+    /// the start position of the value
+    std::size_t start_position = std::string::npos;
+    /// the end position of the value
+    std::size_t end_position = std::string::npos;
+  public:
+    constexpr std::size_t start_pos() const noexcept
+    {
+        return start_position;
+    }
+
+    constexpr std::size_t end_pos() const noexcept
+    {
+        return end_position;
+    }
+#endif
+
+    //////////////////////////////////////////
+    // binary serialization/deserialization //
+    //////////////////////////////////////////
+
+    /// @name binary serialization/deserialization support
+    /// @{
+
+  public:
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static std::vector<std::uint8_t> to_cbor(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_cbor(j, result);
+        return result;
+    }
+
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_cbor(j);
+    }
+
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_cbor(j);
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_msgpack(j, result);
+        return result;
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_msgpack(j);
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_msgpack(j);
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
+            const bool use_size = false,
+            const bool use_type = false)
+    {
+        std::vector<std::uint8_t> result;
+        to_ubjson(j, result, use_size, use_type);
+        return result;
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
+            const bool use_size = false,
+            const bool use_type = false,
+            const bjdata_version_t version = bjdata_version_t::draft2)
+    {
+        std::vector<std::uint8_t> result;
+        to_bjdata(j, result, use_size, use_type, version);
+        return result;
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,
+                          const bool use_size = false, const bool use_type = false,
+                          const bjdata_version_t version = bjdata_version_t::draft2)
+    {
+        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true, true, version);
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false,
+                          const bjdata_version_t version = bjdata_version_t::draft2)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type, true, true, version);
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static std::vector<std::uint8_t> to_bson(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_bson(j, result);
+        return result;
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_bson(j);
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_bson(j);
+    }
+
+    /// @brief create a JSON value from an input in CBOR format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in CBOR format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        auto ia = i.get();
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in MessagePack format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(InputType&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in MessagePack format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(IteratorType first, IteratorType last,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(const T* ptr, std::size_t len,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(detail::span_input_adapter&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = i.get();
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in UBJSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(InputType&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in UBJSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(IteratorType first, IteratorType last,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(const T* ptr, std::size_t len,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(detail::span_input_adapter&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = i.get();
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BJData format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bjdata(InputType&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BJData format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bjdata(IteratorType first, IteratorType last,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        return from_bson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = i.get();
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+    /// @}
+
+    //////////////////////////
+    // JSON Pointer support //
+    //////////////////////////
+
+    /// @name JSON Pointer functions
+    /// @{
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](const json_pointer& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](const json_pointer& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(const json_pointer& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(const json_pointer& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    /// @brief return flattened JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/flatten/
+    basic_json flatten() const
+    {
+        basic_json result(value_t::object);
+        json_pointer::flatten("", *this, result);
+        return result;
+    }
+
+    /// @brief unflatten a previously flattened JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/unflatten/
+    basic_json unflatten() const
+    {
+        return json_pointer::unflatten(*this);
+    }
+
+    /// @}
+
+    //////////////////////////
+    // JSON Patch functions //
+    //////////////////////////
+
+    /// @name JSON Patch functions
+    /// @{
+
+    /// @brief applies a JSON patch in-place without copying the object
+    /// @sa https://json.nlohmann.me/api/basic_json/patch/
+    void patch_inplace(const basic_json& json_patch)
+    {
+        basic_json& result = *this;
+        // the valid JSON Patch operations
+        enum class patch_operations {add, remove, replace, move, copy, test, invalid};
+
+        const auto get_op = [](const string_t& op)
+        {
+            if (op == "add")
+            {
+                return patch_operations::add;
+            }
+            if (op == "remove")
+            {
+                return patch_operations::remove;
+            }
+            if (op == "replace")
+            {
+                return patch_operations::replace;
+            }
+            if (op == "move")
+            {
+                return patch_operations::move;
+            }
+            if (op == "copy")
+            {
+                return patch_operations::copy;
+            }
+            if (op == "test")
+            {
+                return patch_operations::test;
+            }
+
+            return patch_operations::invalid;
+        };
+
+        // wrapper for "add" operation; add value at ptr
+        const auto operation_add = [&result](json_pointer & ptr, const basic_json & val)
+        {
+            // adding to the root of the target document means replacing it
+            if (ptr.empty())
+            {
+                result = val;
+                return;
+            }
+
+            // make sure the top element of the pointer exists
+            json_pointer const top_pointer = ptr.top();
+            if (top_pointer != ptr)
+            {
+                result.at(top_pointer);
+            }
+
+            // get reference to the parent of the JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            // parent must exist when performing patch add per RFC6902 specs
+            basic_json& parent = result.at(ptr);
+
+            switch (parent.m_data.m_type)
+            {
+                case value_t::null:
+                case value_t::object:
+                {
+                    // use operator[] to add value
+                    parent[last_path] = val;
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    if (last_path == "-")
+                    {
+                        // special case: append to back
+                        parent.push_back(val);
+                    }
+                    else
+                    {
+                        const auto idx = json_pointer::template array_index<basic_json_t>(last_path);
+                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
+                        {
+                            // avoid undefined behavior
+                            JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent));
+                        }
+
+                        // default case: insert add offset
+                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
+                    }
+                    break;
+                }
+
+                // if there exists a parent, it cannot be primitive
+                case value_t::string: // LCOV_EXCL_LINE
+                case value_t::boolean: // LCOV_EXCL_LINE
+                case value_t::number_integer: // LCOV_EXCL_LINE
+                case value_t::number_unsigned: // LCOV_EXCL_LINE
+                case value_t::number_float: // LCOV_EXCL_LINE
+                case value_t::binary: // LCOV_EXCL_LINE
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            }
+        };
+
+        // wrapper for "remove" operation; remove value at ptr
+        const auto operation_remove = [this, & result](json_pointer & ptr)
+        {
+            // get reference to the parent of the JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            basic_json& parent = result.at(ptr);
+
+            // remove child
+            if (parent.is_object())
+            {
+                // perform range check
+                auto it = parent.find(last_path);
+                if (JSON_HEDLEY_LIKELY(it != parent.end()))
+                {
+                    parent.erase(it);
+                }
+                else
+                {
+                    JSON_THROW(out_of_range::create(403, detail::concat("key '", last_path, "' not found"), this));
+                }
+            }
+            else if (parent.is_array())
+            {
+                // note erase performs range check
+                parent.erase(json_pointer::template array_index<basic_json_t>(last_path));
+            }
+        };
+
+        // type check: top level value must be an array
+        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
+        {
+            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &json_patch));
+        }
+
+        // iterate and apply the operations
+        for (const auto& val : json_patch)
+        {
+            // wrapper to get a value for an operation
+            const auto get_value = [&val](const string_t& op,
+                                          const string_t& member,
+                                          bool string_type) -> basic_json &
+            {
+                // find value
+                auto it = val.m_data.m_value.object->find(member);
+
+                // context-sensitive error message
+                const auto error_msg = (op == "op") ? "operation" : detail::concat("operation '", op, '\''); // NOLINT(bugprone-unused-local-non-trivial-variable)
+
+                // check if the desired value is present
+                if (JSON_HEDLEY_UNLIKELY(it == val.m_data.m_value.object->end()))
+                {
+                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
+                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have member '", member, "'"), &val));
+                }
+
+                // check if the result is of type string
+                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
+                {
+                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
+                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have string member '", member, "'"), &val));
+                }
+
+                // no error: return value
+                return it->second;
+            };
+
+            // type check: every element of the array must be an object
+            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
+            {
+                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &val));
+            }
+
+            // collect mandatory members
+            const auto op = get_value("op", "op", true).template get<string_t>();
+            const auto path = get_value(op, "path", true).template get<string_t>();
+            json_pointer ptr(path);
+
+            switch (get_op(op))
+            {
+                case patch_operations::add:
+                {
+                    operation_add(ptr, get_value("add", "value", false));
+                    break;
+                }
+
+                case patch_operations::remove:
+                {
+                    operation_remove(ptr);
+                    break;
+                }
+
+                case patch_operations::replace:
+                {
+                    // the "path" location must exist - use at()
+                    result.at(ptr) = get_value("replace", "value", false);
+                    break;
+                }
+
+                case patch_operations::move:
+                {
+                    const auto from_path = get_value("move", "from", true).template get<string_t>();
+                    json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json const v = result.at(from_ptr);
+
+                    // The move operation is functionally identical to a
+                    // "remove" operation on the "from" location, followed
+                    // immediately by an "add" operation at the target
+                    // location with the value that was just removed.
+                    operation_remove(from_ptr);
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::copy:
+                {
+                    const auto from_path = get_value("copy", "from", true).template get<string_t>();
+                    const json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json const v = result.at(from_ptr);
+
+                    // The copy is functionally identical to an "add"
+                    // operation at the target location using the value
+                    // specified in the "from" member.
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::test:
+                {
+                    bool success = false;
+                    JSON_TRY
+                    {
+                        // check if "value" matches the one at "path"
+                        // the "path" location must exist - use at()
+                        success = (result.at(ptr) == get_value("test", "value", false));
+                    }
+                    JSON_INTERNAL_CATCH (out_of_range&)
+                    {
+                        // ignore out of range errors: success remains false
+                    }
+
+                    // throw an exception if the test fails
+                    if (JSON_HEDLEY_UNLIKELY(!success))
+                    {
+                        JSON_THROW(other_error::create(501, detail::concat("unsuccessful: ", val.dump()), &val));
+                    }
+
+                    break;
+                }
+
+                case patch_operations::invalid:
+                default:
+                {
+                    // op must be "add", "remove", "replace", "move", "copy", or
+                    // "test"
+                    JSON_THROW(parse_error::create(105, 0, detail::concat("operation value '", op, "' is invalid"), &val));
+                }
+            }
+        }
+    }
+
+    /// @brief applies a JSON patch to a copy of the current object
+    /// @sa https://json.nlohmann.me/api/basic_json/patch/
+    basic_json patch(const basic_json& json_patch) const
+    {
+        basic_json result = *this;
+        result.patch_inplace(json_patch);
+        return result;
+    }
+
+    /// @brief creates a diff as a JSON patch
+    /// @sa https://json.nlohmann.me/api/basic_json/diff/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json diff(const basic_json& source, const basic_json& target,
+                           const string_t& path = "")
+    {
+        // the patch
+        basic_json result(value_t::array);
+
+        // if the values are the same, return an empty patch
+        if (source == target)
+        {
+            return result;
+        }
+
+        if (source.type() != target.type())
+        {
+            // different types: replace value
+            result.push_back(
+            {
+                {"op", "replace"}, {"path", path}, {"value", target}
+            });
+            return result;
+        }
+
+        switch (source.type())
+        {
+            case value_t::array:
+            {
+                // first pass: traverse common elements
+                std::size_t i = 0;
+                while (i < source.size() && i < target.size())
+                {
+                    // recursive call to compare array values at index i
+                    auto temp_diff = diff(source[i], target[i], detail::concat<string_t>(path, '/', detail::to_string<string_t>(i)));
+                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    ++i;
+                }
+
+                // We now reached the end of at least one array
+                // in a second pass, traverse the remaining elements
+
+                // remove my remaining elements
+                const auto end_index = static_cast<difference_type>(result.size());
+                while (i < source.size())
+                {
+                    // add operations in reverse order to avoid invalid
+                    // indices
+                    result.insert(result.begin() + end_index, object(
+                    {
+                        {"op", "remove"},
+                        {"path", detail::concat<string_t>(path, '/', detail::to_string<string_t>(i))}
+                    }));
+                    ++i;
+                }
+
+                // add other remaining elements
+                while (i < target.size())
+                {
+                    result.push_back(
+                    {
+                        {"op", "add"},
+                        {"path", detail::concat<string_t>(path, "/-")},
+                        {"value", target[i]}
+                    });
+                    ++i;
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // first pass: traverse this object's elements
+                for (auto it = source.cbegin(); it != source.cend(); ++it)
+                {
+                    // escape the key name to be used in a JSON patch
+                    const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+
+                    if (target.find(it.key()) != target.end())
+                    {
+                        // recursive call to compare object values at key it
+                        auto temp_diff = diff(it.value(), target[it.key()], path_key);
+                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    }
+                    else
+                    {
+                        // found a key that is not in o -> remove it
+                        result.push_back(object(
+                        {
+                            {"op", "remove"}, {"path", path_key}
+                        }));
+                    }
+                }
+
+                // second pass: traverse other object's elements
+                for (auto it = target.cbegin(); it != target.cend(); ++it)
+                {
+                    if (source.find(it.key()) == source.end())
+                    {
+                        // found a key that is not in this -> add it
+                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+                        result.push_back(
+                        {
+                            {"op", "add"}, {"path", path_key},
+                            {"value", it.value()}
+                        });
+                    }
+                }
+
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // both primitive types: replace value
+                result.push_back(
+                {
+                    {"op", "replace"}, {"path", path}, {"value", target}
+                });
+                break;
+            }
+        }
+
+        return result;
+    }
+    /// @}
+
+    ////////////////////////////////
+    // JSON Merge Patch functions //
+    ////////////////////////////////
+
+    /// @name JSON Merge Patch functions
+    /// @{
+
+    /// @brief applies a JSON Merge Patch
+    /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
+    void merge_patch(const basic_json& apply_patch)
+    {
+        if (apply_patch.is_object())
+        {
+            if (!is_object())
+            {
+                *this = object();
+            }
+            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
+            {
+                if (it.value().is_null())
+                {
+                    erase(it.key());
+                }
+                else
+                {
+                    operator[](it.key()).merge_patch(it.value());
+                }
+            }
+        }
+        else
+        {
+            *this = apply_patch;
+        }
+    }
+
+    /// @}
+};
+
+/// @brief user-defined to_string function for JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/to_string/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
+{
+    return j.dump();
+}
+
+inline namespace literals
+{
+inline namespace json_literals
+{
+
+/// @brief user-defined string literal for JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
+JSON_HEDLEY_NON_NULL(1)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json operator ""_json(const char* s, std::size_t n)
+#else
+    inline nlohmann::json operator "" _json(const char* s, std::size_t n)
+#endif
+{
+    return nlohmann::json::parse(s, s + n);
+}
+
+/// @brief user-defined string literal for JSON pointer
+/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
+JSON_HEDLEY_NON_NULL(1)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json::json_pointer operator ""_json_pointer(const char* s, std::size_t n)
+#else
+    inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
+#endif
+{
+    return nlohmann::json::json_pointer(std::string(s, n));
+}
+
+}  // namespace json_literals
+}  // namespace literals
+NLOHMANN_JSON_NAMESPACE_END
+
+///////////////////////
+// nonmember support //
+///////////////////////
+
+namespace std // NOLINT(cert-dcl58-cpp)
+{
+
+/// @brief hash value for JSON objects
+/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp)
+{
+    std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
+    {
+        return nlohmann::detail::hash(j);
+    }
+};
+
+// specialization for std::less<value_t>
+template<>
+struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
+{
+    /*!
+    @brief compare two value_t enum values
+    @since version 3.0.0
+    */
+    bool operator()(::nlohmann::detail::value_t lhs,
+                    ::nlohmann::detail::value_t rhs) const noexcept
+    {
+#if JSON_HAS_THREE_WAY_COMPARISON
+        return std::is_lt(lhs <=> rhs); // *NOPAD*
+#else
+        return ::nlohmann::detail::operator<(lhs, rhs);
+#endif
+    }
+};
+
+// C++20 prohibit function specialization in the std namespace.
+#ifndef JSON_HAS_CPP_20
+
+/// @brief exchanges the values of two JSON objects
+/// @sa https://json.nlohmann.me/api/basic_json/std_swap/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp)
+    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
+{
+    j1.swap(j2);
+}
+
+#endif
+
+}  // namespace std
+
+#if JSON_USE_GLOBAL_UDLS
+    #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+        using nlohmann::literals::json_literals::operator ""_json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator ""_json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #else
+        using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #endif
+#endif
+
+// #include <nlohmann/detail/macro_unscope.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// restore clang diagnostic settings
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+// clean up
+#undef JSON_ASSERT
+#undef JSON_INTERNAL_CATCH
+#undef JSON_THROW
+#undef JSON_PRIVATE_UNLESS_TESTED
+#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
+#undef NLOHMANN_BASIC_JSON_TPL
+#undef JSON_EXPLICIT
+#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
+#undef JSON_INLINE_VARIABLE
+#undef JSON_NO_UNIQUE_ADDRESS
+#undef JSON_DISABLE_ENUM_SERIALIZATION
+#undef JSON_USE_GLOBAL_UDLS
+
+#ifndef JSON_TEST_KEEP_MACROS
+    #undef JSON_CATCH
+    #undef JSON_TRY
+    #undef JSON_HAS_CPP_11
+    #undef JSON_HAS_CPP_14
+    #undef JSON_HAS_CPP_17
+    #undef JSON_HAS_CPP_20
+    #undef JSON_HAS_CPP_23
+    #undef JSON_HAS_FILESYSTEM
+    #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+    #undef JSON_HAS_THREE_WAY_COMPARISON
+    #undef JSON_HAS_RANGES
+    #undef JSON_HAS_STATIC_RTTI
+    #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+#endif
+
+// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#undef JSON_HEDLEY_ALWAYS_INLINE
+#undef JSON_HEDLEY_ARM_VERSION
+#undef JSON_HEDLEY_ARM_VERSION_CHECK
+#undef JSON_HEDLEY_ARRAY_PARAM
+#undef JSON_HEDLEY_ASSUME
+#undef JSON_HEDLEY_BEGIN_C_DECLS
+#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#undef JSON_HEDLEY_CLANG_HAS_WARNING
+#undef JSON_HEDLEY_COMPCERT_VERSION
+#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#undef JSON_HEDLEY_CONCAT
+#undef JSON_HEDLEY_CONCAT3
+#undef JSON_HEDLEY_CONCAT3_EX
+#undef JSON_HEDLEY_CONCAT_EX
+#undef JSON_HEDLEY_CONST
+#undef JSON_HEDLEY_CONSTEXPR
+#undef JSON_HEDLEY_CONST_CAST
+#undef JSON_HEDLEY_CPP_CAST
+#undef JSON_HEDLEY_CRAY_VERSION
+#undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#undef JSON_HEDLEY_C_DECL
+#undef JSON_HEDLEY_DEPRECATED
+#undef JSON_HEDLEY_DEPRECATED_FOR
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#undef JSON_HEDLEY_DIAGNOSTIC_POP
+#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#undef JSON_HEDLEY_DMC_VERSION
+#undef JSON_HEDLEY_DMC_VERSION_CHECK
+#undef JSON_HEDLEY_EMPTY_BASES
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#undef JSON_HEDLEY_END_C_DECLS
+#undef JSON_HEDLEY_FLAGS
+#undef JSON_HEDLEY_FLAGS_CAST
+#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#undef JSON_HEDLEY_GCC_HAS_FEATURE
+#undef JSON_HEDLEY_GCC_HAS_WARNING
+#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#undef JSON_HEDLEY_GCC_VERSION
+#undef JSON_HEDLEY_GCC_VERSION_CHECK
+#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#undef JSON_HEDLEY_GNUC_HAS_WARNING
+#undef JSON_HEDLEY_GNUC_VERSION
+#undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#undef JSON_HEDLEY_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_BUILTIN
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_EXTENSION
+#undef JSON_HEDLEY_HAS_FEATURE
+#undef JSON_HEDLEY_HAS_WARNING
+#undef JSON_HEDLEY_IAR_VERSION
+#undef JSON_HEDLEY_IAR_VERSION_CHECK
+#undef JSON_HEDLEY_IBM_VERSION
+#undef JSON_HEDLEY_IBM_VERSION_CHECK
+#undef JSON_HEDLEY_IMPORT
+#undef JSON_HEDLEY_INLINE
+#undef JSON_HEDLEY_INTEL_CL_VERSION
+#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#undef JSON_HEDLEY_INTEL_VERSION
+#undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#undef JSON_HEDLEY_IS_CONSTANT
+#undef JSON_HEDLEY_IS_CONSTEXPR_
+#undef JSON_HEDLEY_LIKELY
+#undef JSON_HEDLEY_MALLOC
+#undef JSON_HEDLEY_MCST_LCC_VERSION
+#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
+#undef JSON_HEDLEY_MESSAGE
+#undef JSON_HEDLEY_MSVC_VERSION
+#undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#undef JSON_HEDLEY_NEVER_INLINE
+#undef JSON_HEDLEY_NON_NULL
+#undef JSON_HEDLEY_NO_ESCAPE
+#undef JSON_HEDLEY_NO_RETURN
+#undef JSON_HEDLEY_NO_THROW
+#undef JSON_HEDLEY_NULL
+#undef JSON_HEDLEY_PELLES_VERSION
+#undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#undef JSON_HEDLEY_PGI_VERSION
+#undef JSON_HEDLEY_PGI_VERSION_CHECK
+#undef JSON_HEDLEY_PREDICT
+#undef JSON_HEDLEY_PRINTF_FORMAT
+#undef JSON_HEDLEY_PRIVATE
+#undef JSON_HEDLEY_PUBLIC
+#undef JSON_HEDLEY_PURE
+#undef JSON_HEDLEY_REINTERPRET_CAST
+#undef JSON_HEDLEY_REQUIRE
+#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#undef JSON_HEDLEY_REQUIRE_MSG
+#undef JSON_HEDLEY_RESTRICT
+#undef JSON_HEDLEY_RETURNS_NON_NULL
+#undef JSON_HEDLEY_SENTINEL
+#undef JSON_HEDLEY_STATIC_ASSERT
+#undef JSON_HEDLEY_STATIC_CAST
+#undef JSON_HEDLEY_STRINGIFY
+#undef JSON_HEDLEY_STRINGIFY_EX
+#undef JSON_HEDLEY_SUNPRO_VERSION
+#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#undef JSON_HEDLEY_TINYC_VERSION
+#undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#undef JSON_HEDLEY_TI_ARMCL_VERSION
+#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL2000_VERSION
+#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL430_VERSION
+#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL6X_VERSION
+#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL7X_VERSION
+#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CLPRU_VERSION
+#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#undef JSON_HEDLEY_TI_VERSION
+#undef JSON_HEDLEY_TI_VERSION_CHECK
+#undef JSON_HEDLEY_UNAVAILABLE
+#undef JSON_HEDLEY_UNLIKELY
+#undef JSON_HEDLEY_UNPREDICTABLE
+#undef JSON_HEDLEY_UNREACHABLE
+#undef JSON_HEDLEY_UNREACHABLE_RETURN
+#undef JSON_HEDLEY_VERSION
+#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#undef JSON_HEDLEY_VERSION_ENCODE
+#undef JSON_HEDLEY_WARNING
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#undef JSON_HEDLEY_FALL_THROUGH
+
+
+
+#endif  // INCLUDE_NLOHMANN_JSON_HPP_