From 7772f4e30b31209222c5c76f7dceeae423f850ad Mon Sep 17 00:00:00 2001
From: Harvey Fong <harvey@oomer.org>
Date: Sun, 30 Mar 2025 07:24:33 -0600
Subject: [PATCH] major refactor, reorg, best plist traversal,
 oomer_smooth_cube, 7=glass , 8=liquid

---
 common.h                                      |    13 -
 oomer_misc.h                                  |  1584 +
 oomer_voxel_vmax.h                            |   744 +
 .../DayEnvironmentHDRI019_1K-TONEMAPPED.jpg   |   Bin 429166 -> 0 bytes
 thirdparty/json.hpp                           | 24765 ++++++++++++++++
 stb_image.h => thirdparty/stb_image.h         |     0
 vmax2bella.cpp                                |  1409 +-
 7 files changed, 27421 insertions(+), 1094 deletions(-)
 delete mode 100644 common.h
 create mode 100644 oomer_misc.h
 create mode 100644 oomer_voxel_vmax.h
 delete mode 100644 resources/DayEnvironmentHDRI019_1K-TONEMAPPED.jpg
 create mode 100644 thirdparty/json.hpp
 rename stb_image.h => thirdparty/stb_image.h (100%)

diff --git a/common.h b/common.h
deleted file mode 100644
index a2ab815..0000000
--- a/common.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-// Structure to hold voxel information
-struct newVoxel {
-    uint32_t x, y, z;  // 3D coordinates
-    uint8_t color; // Color value
-};
-
-
-struct dsVoxel {
-    uint8_t layer;
-    uint8_t color;
-};
\ No newline at end of file
diff --git a/oomer_misc.h b/oomer_misc.h
new file mode 100644
index 0000000..0ab12cd
--- /dev/null
+++ b/oomer_misc.h
@@ -0,0 +1,1584 @@
+#pragma once
+#include <string>       // For std::string
+#include <iostream>
+#include <fstream>    // For std::ofstream
+#include <filesystem>  // For std::filesystem
+//#include "DayEnvironmentHDRI019_1K-TONEMAPPED.h" // embedded image dome light
+#include <cmath>      // For std::pow
+
+//Forward declarations
+extern const unsigned int DayEnvironmentHDRI019_1K_TONEMAPPED_jpg_len;
+extern const unsigned char DayEnvironmentHDRI019_1K_TONEMAPPED_jpg[];
+
+// Convert sRGB color value to linear color space
+inline float srgbToLinear(float value) {
+    return (value <= 0.04045f) ?
+           (value * (1.0f/12.92f)) :
+           std::pow((value + 0.055f) * (1.0f/1.055f), 2.4f);
+}
+
+
+// read binary compressed LZFSE file into an array
+inline std::vector<uint8_t> LZFSEToArray(const std::string& lzfseFullName) {
+        std::ifstream lzfseFile(lzfseFullName, std::ios::binary);
+        if (!lzfseFile.is_open()) {
+            std::cerr << "Error: Could not open LZFSE file: " << lzfseFullName << std::endl;
+            throw std::runtime_error("Error message");
+        }
+        // Get file size using std::filesystem
+        size_t lzfseFileSize = std::filesystem::file_size(lzfseFullName);
+        
+        // store the lzfse file in a memory buffer
+        std::vector<uint8_t> lzfseArray(lzfseFileSize);
+        lzfseFile.read(reinterpret_cast<char*>(lzfseArray.data()), lzfseFileSize);
+        lzfseFile.close();
+        return lzfseArray;
+}
+
+
+
+// read binary compressed LZFSE file 
+// Why not use liblzfse directly?
+// @param dirName: the name of the directory containing the LZFSE file
+// @param compressedName: the name of the LZFSE file to decompress
+inline std::vector<uint8_t> decompressLZFSE(const std::string& dirName, const std::string& compressedName) {
+        std::string lzfseFullName = dirName + "/"+compressedName;
+
+        std::cout << "Decompressing LZFSE file: " << lzfseFullName << std::endl;
+        std::ifstream lzfseFile(lzfseFullName, std::ios::binary);
+        if (!lzfseFile.is_open()) {
+            std::cerr << "Error: Could not open input file: " << lzfseFullName << std::endl;
+            throw std::runtime_error("Error message");
+        }
+
+        // Get lzfse file size and read content
+        lzfseFile.seekg(0, std::ios::end);
+        size_t lzfseFileSize = lzfseFile.tellg();
+        lzfseFile.seekg(0, std::ios::beg);
+        // store the lzfse file in a memory buffer
+        std::vector<uint8_t> lzfseBuffer(lzfseFileSize);
+        lzfseFile.read(reinterpret_cast<char*>(lzfseBuffer.data()), lzfseFileSize);
+        lzfseFile.close();
+        return lzfseBuffer;
+}
+
+// Function that saves the embedded HDRI file to the res directory
+// Allows executable to be moved around without the HDRI file
+inline void saveHDRI() {
+    // Create hdri file if it doesn't exist
+    std::string hdriName = "DayEnvironmentHDRI019_1K-TONEMAPPED.jpg";
+    std::string resDir= "./res";
+    std::filesystem::path hdriFile = std::filesystem::path(resDir) / hdriName;  
+    if (!std::filesystem::exists(hdriFile)) {
+        std::cout << "HDRI file not found, creating it" << std::endl;
+        std::filesystem::create_directories(resDir);
+        std::ofstream outFile(hdriFile, std::ios::binary);
+        if (!outFile) {
+            std::cerr << "HDRI failed to write" << hdriFile << std::endl;
+        }
+        
+        // Write the data to the file using the exact length
+        outFile.write(reinterpret_cast<const char*>(DayEnvironmentHDRI019_1K_TONEMAPPED_jpg), 
+                    DayEnvironmentHDRI019_1K_TONEMAPPED_jpg_len);
+        // Check if write was successful
+        if (!outFile) {
+            std::cerr << "HDRI failed to write" << hdriFile << std::endl;
+        }
+    } 
+}
+
+
+
+// Function that returns the license text for this program
+inline std::string initializeGlobalLicense() {
+    // R"(...)" is a C++ raw string literal - allows multi-line strings with preserved formatting
+    return R"(
+vmax2bella
+
+Copyright (c) 2025 Harvey Fong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.)";
+}
+
+// Function that returns third-party license text
+inline std::string initializeGlobalThirdPartyLicences() {
+    return R"(
+Bella SDK (Software Development Kit)
+
+Copyright Diffuse Logic SCP, all rights reserved.
+
+Permission is hereby granted to any person obtaining a copy of this software
+(the "Software"), to use, copy, publish, distribute, sublicense, and/or sell
+copies of the Software.
+
+THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL
+IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY
+ARE HEREBY DISCLAIMED.)
+
+===
+
+lzfse 
+
+Copyright (c) 2015-2016, Apple Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1.  Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder(s) nor the names of any contributors may be used to endorse or promote products derived
+    from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+)"; 
+} 
+
+const unsigned char DayEnvironmentHDRI019_1K_TONEMAPPED_jpg[] = {
+  0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01,
+  0x01, 0x00, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xff, 0xe1, 0x00, 0x4c,
+  0x45, 0x78, 0x69, 0x66, 0x00, 0x00, 0x4d, 0x4d, 0x00, 0x2a, 0x00, 0x00,
+  0x00, 0x08, 0x00, 0x01, 0x87, 0x69, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xa0, 0x01,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0xa0, 0x02,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0xa0, 0x03,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
+  0x00, 0x00, 0xff, 0xed, 0x00, 0x38, 0x50, 0x68, 0x6f, 0x74, 0x6f, 0x73,
+  0x68, 0x6f, 0x70, 0x20, 0x33, 0x2e, 0x30, 0x00, 0x38, 0x42, 0x49, 0x4d,
+  0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x42, 0x49, 0x4d,
+  0x04, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xd4, 0x1d, 0x8c, 0xd9,
+  0x8f, 0x00, 0xb2, 0x04, 0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e,
+  0xff, 0xc0, 0x00, 0x11, 0x08, 0x00, 0x80, 0x01, 0x00, 0x03, 0x01, 0x22,
+  0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xc4, 0x00, 0x1f, 0x00,
+  0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+  0x08, 0x09, 0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x10, 0x00, 0x02, 0x01,
+  0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01,
+  0x7d, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41,
+  0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1,
+  0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62,
+  0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27,
+  0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44,
+  0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+  0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74,
+  0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
+  0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2,
+  0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5,
+  0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8,
+  0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1,
+  0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3,
+  0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xff, 0xc4, 0x00, 0x1f, 0x01,
+  0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+  0x08, 0x09, 0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x11, 0x00, 0x02, 0x01,
+  0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02,
+  0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12,
+  0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42,
+  0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72,
+  0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a,
+  0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43,
+  0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57,
+  0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73,
+  0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86,
+  0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
+  0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3,
+  0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6,
+  0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
+  0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3,
+  0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xff, 0xdb, 0x00, 0x43, 0x00,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x02, 0x02, 0x02,
+  0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x02, 0x02, 0x03, 0x04, 0x03, 0x03,
+  0x03, 0x03, 0x03, 0x04, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05,
+  0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+  0x08, 0x08, 0x08, 0x08, 0xff, 0xdb, 0x00, 0x43, 0x01, 0x01, 0x01, 0x01,
+  0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x03, 0x08, 0x05, 0x05, 0x05, 0x08,
+  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+  0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+  0x08, 0xff, 0xdd, 0x00, 0x04, 0x00, 0x10, 0xff, 0xda, 0x00, 0x0c, 0x03,
+  0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, 0x00, 0xfa, 0xdf, 0x42,
+  0xf8, 0xbd, 0xf0, 0x27, 0xc4, 0xba, 0xde, 0x9b, 0xa5, 0xf8, 0x66, 0xcf,
+  0x52, 0xd3, 0x5a, 0xee, 0xe0, 0x45, 0x73, 0x71, 0xe2, 0x49, 0x9e, 0x44,
+  0x47, 0x2d, 0x80, 0x90, 0x3c, 0x77, 0xf0, 0xc3, 0x33, 0x1c, 0x81, 0xe5,
+  0xab, 0x79, 0x81, 0x8e, 0x0a, 0x82, 0x40, 0xa8, 0xfe, 0x24, 0x7c, 0x46,
+  0xf0, 0xad, 0x8e, 0x93, 0x3d, 0xcf, 0x85, 0x2c, 0xb4, 0x6d, 0x58, 0xd9,
+  0x4a, 0x12, 0xe7, 0xed, 0x45, 0x92, 0xe0, 0xb0, 0x38, 0x65, 0x5b, 0x51,
+  0x3c, 0x93, 0x7c, 0xa3, 0xae, 0xe6, 0xc9, 0xe9, 0xd6, 0xbe, 0x29, 0xf8,
+  0x2f, 0xf1, 0x8e, 0xf7, 0xc4, 0x16, 0x97, 0x9e, 0x1f, 0xd1, 0x27, 0xd3,
+  0x24, 0xd5, 0x6f, 0x60, 0x86, 0xc9, 0xf4, 0xcb, 0xab, 0x8b, 0x58, 0x96,
+  0x26, 0x54, 0x60, 0x8b, 0x0c, 0x33, 0xc9, 0x1a, 0x3e, 0xc2, 0x79, 0x68,
+  0xc2, 0x30, 0x04, 0x90, 0xc1, 0x9b, 0x23, 0xdf, 0xbf, 0x67, 0xdf, 0xd9,
+  0xcf, 0x58, 0xf8, 0xcf, 0x26, 0x94, 0x87, 0xfe, 0x15, 0xe4, 0x72, 0xa6,
+  0xa9, 0x34, 0xf7, 0xe6, 0xf3, 0x53, 0x37, 0x71, 0xcf, 0x35, 0xaa, 0x10,
+  0xb1, 0xbd, 0x94, 0x12, 0xde, 0x32, 0xc8, 0xec, 0x00, 0x25, 0x23, 0x52,
+  0xa0, 0x38, 0x04, 0x73, 0xb7, 0xf8, 0xa6, 0x18, 0x4a, 0x78, 0xc7, 0x2a,
+  0x36, 0xb3, 0xd3, 0x4d, 0x7f, 0xcd, 0x2f, 0x3e, 0xde, 0x76, 0xdb, 0x86,
+  0x35, 0x64, 0xd2, 0xe5, 0x3c, 0x13, 0xe2, 0x17, 0xed, 0x91, 0xf0, 0xdf,
+  0xc2, 0xda, 0xb6, 0x75, 0x5d, 0x3b, 0xc3, 0x46, 0x35, 0x83, 0x65, 0xcc,
+  0x3a, 0x4c, 0x3a, 0x84, 0x12, 0xc2, 0x70, 0x4e, 0xe2, 0x24, 0x55, 0xfd,
+  0xe0, 0xce, 0x08, 0x66, 0x2a, 0x4f, 0x7a, 0xf1, 0x19, 0xff, 0x00, 0x6d,
+  0x4f, 0x00, 0x6a, 0x96, 0x8f, 0x36, 0x8b, 0xa7, 0x25, 0xcc, 0x0d, 0x9d,
+  0xf2, 0x3d, 0xca, 0x45, 0x3c, 0x61, 0x9b, 0x68, 0xdb, 0xe6, 0x4c, 0x84,
+  0x9f, 0x40, 0xbd, 0x0f, 0x04, 0xe6, 0xbe, 0xc8, 0xf8, 0xef, 0xff, 0x00,
+  0x04, 0xfc, 0xbd, 0x16, 0xba, 0xcf, 0x8a, 0x74, 0xb3, 0xa4, 0x58, 0x43,
+  0xa0, 0x5e, 0x3d, 0xbe, 0xb3, 0xa2, 0xe9, 0xd3, 0x4b, 0xf6, 0x98, 0xae,
+  0x19, 0x41, 0x12, 0x5a, 0xd9, 0xdd, 0x4d, 0x24, 0xcd, 0x0b, 0x87, 0x43,
+  0x1b, 0x3a, 0xc6, 0xaf, 0xc8, 0x54, 0x0c, 0x18, 0x57, 0xd1, 0xbf, 0x05,
+  0xff, 0x00, 0x67, 0xbf, 0xd8, 0x7b, 0xe3, 0x0f, 0xc1, 0xb3, 0xa3, 0xe9,
+  0xfe, 0x18, 0xf0, 0x34, 0x5a, 0xc8, 0x86, 0x1b, 0x5d, 0x46, 0xf7, 0xc5,
+  0xb3, 0xdd, 0x5a, 0x6b, 0x92, 0x5e, 0x18, 0x42, 0x3a, 0x59, 0xdb, 0xc6,
+  0x65, 0xb5, 0x95, 0x8c, 0xc4, 0x98, 0xda, 0x46, 0x51, 0xb5, 0x01, 0x96,
+  0x0e, 0x41, 0x3e, 0xde, 0x17, 0x83, 0xf0, 0x55, 0x2d, 0x4e, 0xa2, 0x69,
+  0xa5, 0x7d, 0x64, 0xd2, 0xb6, 0xbb, 0x2e, 0xb7, 0xf2, 0x6c, 0xc6, 0xf5,
+  0x5c, 0xac, 0xda, 0x3f, 0x0e, 0xb5, 0xff, 0x00, 0xda, 0x0f, 0xed, 0x9a,
+  0xbb, 0xda, 0xe8, 0x7a, 0x8e, 0xbb, 0xa7, 0x94, 0x21, 0xd8, 0xdd, 0xcf,
+  0x95, 0xc1, 0x3c, 0x28, 0x55, 0x94, 0x6d, 0xe3, 0xfb, 0xcc, 0x7e, 0x95,
+  0x9f, 0xab, 0xfc, 0x6a, 0xf1, 0x15, 0xc5, 0x93, 0xdc, 0xdb, 0x78, 0xae,
+  0xea, 0x08, 0xbe, 0x48, 0x61, 0x8d, 0xd9, 0x24, 0x99, 0xe5, 0x23, 0x24,
+  0x66, 0xdd, 0xb7, 0xf6, 0x3c, 0x14, 0x07, 0xa7, 0x24, 0xd7, 0xea, 0xcc,
+  0x3f, 0xf0, 0x4f, 0x7f, 0x81, 0x9e, 0x07, 0xf1, 0xc3, 0x78, 0x7b, 0xc6,
+  0x7a, 0x15, 0xb4, 0xba, 0x8e, 0xa9, 0xac, 0xdb, 0x6a, 0x1a, 0x5c, 0x9e,
+  0x1c, 0xf1, 0x85, 0x95, 0x99, 0x02, 0x79, 0x04, 0x09, 0x6d, 0x04, 0x32,
+  0xd9, 0x5d, 0xc5, 0x2d, 0xab, 0xcf, 0xb8, 0x00, 0x63, 0xf3, 0x97, 0x85,
+  0xd8, 0x54, 0x12, 0xdf, 0x70, 0xfc, 0x5c, 0xff, 0x00, 0x82, 0x4a, 0xfe,
+  0xc4, 0x96, 0x3f, 0x0c, 0xa3, 0xd7, 0x6e, 0xa3, 0xf1, 0x77, 0x87, 0x75,
+  0xb3, 0x75, 0x25, 0xdc, 0x3a, 0x3b, 0xdf, 0xd9, 0xc9, 0x79, 0x1b, 0xe5,
+  0x99, 0x61, 0x68, 0x63, 0xb3, 0xf3, 0x66, 0x54, 0x54, 0x60, 0x8f, 0xb8,
+  0x06, 0x05, 0x4e, 0xd0, 0x32, 0xab, 0xee, 0xd3, 0xe1, 0xcc, 0x2d, 0x3a,
+  0x52, 0x92, 0x76, 0xe4, 0x57, 0x77, 0x49, 0x3b, 0x79, 0x5d, 0x5a, 0xef,
+  0xb5, 0xfe, 0xf3, 0x38, 0xe1, 0x6a, 0x4a, 0xfa, 0x9f, 0x80, 0xde, 0x0c,
+  0x3a, 0xb6, 0xa5, 0xa5, 0x4f, 0xaa, 0x78, 0x93, 0xc6, 0xda, 0xcb, 0xcb,
+  0x0a, 0x3c, 0x83, 0x4f, 0xb2, 0x32, 0x99, 0x51, 0x97, 0x8f, 0xde, 0xf0,
+  0xec, 0x99, 0x6e, 0x00, 0x61, 0xed, 0xc1, 0xa9, 0xb4, 0x1b, 0xed, 0x37,
+  0x53, 0xb1, 0x9b, 0x5b, 0xd5, 0xfe, 0x21, 0x5e, 0xe9, 0x91, 0xc5, 0xbd,
+  0x61, 0x85, 0x1a, 0x2b, 0xd9, 0xdc, 0xae, 0x0e, 0x5a, 0x0b, 0xa9, 0xa2,
+  0xca, 0xe0, 0xf5, 0x4c, 0x91, 0xd4, 0xa8, 0x1c, 0xd7, 0x73, 0xfb, 0x4f,
+  0x69, 0xff, 0x00, 0xb2, 0xcf, 0xc2, 0x3d, 0x06, 0x1f, 0x0e, 0xf8, 0x0e,
+  0xc2, 0xf6, 0x0b, 0xf8, 0xef, 0x21, 0xb9, 0xbf, 0x92, 0xe4, 0xdc, 0x4f,
+  0xa8, 0x0f, 0x25, 0x36, 0xfc, 0xd1, 0xcc, 0xfe, 0x4b, 0x39, 0xdc, 0x0c,
+  0xb1, 0x3a, 0xac, 0x71, 0x90, 0x81, 0x9f, 0x92, 0x95, 0xf1, 0x6e, 0x93,
+  0xe0, 0x1d, 0x6f, 0xe2, 0x1c, 0x56, 0xf2, 0x68, 0xba, 0x0d, 0xf3, 0xb3,
+  0x4b, 0x24, 0xb7, 0x17, 0xf7, 0x52, 0x88, 0xe2, 0x98, 0xba, 0x2c, 0x8b,
+  0x1c, 0x51, 0xd9, 0x59, 0x92, 0x82, 0x25, 0x60, 0x15, 0x99, 0xb6, 0x93,
+  0x9c, 0x95, 0x1c, 0x2f, 0x89, 0x86, 0xc2, 0x29, 0x27, 0x5a, 0x55, 0x5a,
+  0x57, 0xed, 0x14, 0xad, 0xe5, 0x74, 0xbf, 0xaf, 0xc2, 0x5d, 0x2b, 0x3e,
+  0x57, 0xfa, 0x9f, 0x49, 0x2f, 0x8c, 0xfe, 0x1d, 0xdc, 0x58, 0x48, 0x20,
+  0xf1, 0x6f, 0x8a, 0x6f, 0x25, 0x8f, 0x20, 0xdd, 0xc6, 0x96, 0x71, 0xc4,
+  0x1c, 0x63, 0xe5, 0x68, 0x4a, 0x92, 0xc4, 0x93, 0xd0, 0x48, 0xb8, 0xc8,
+  0x19, 0x6e, 0x33, 0xcd, 0x78, 0x73, 0xc4, 0x5a, 0x7e, 0xa7, 0xaa, 0x32,
+  0xea, 0x5e, 0x2e, 0xd5, 0xb4, 0x7b, 0x21, 0x38, 0x56, 0xbe, 0xbe, 0xb4,
+  0x12, 0xc2, 0x01, 0x5d, 0xd8, 0x22, 0x34, 0x99, 0x81, 0xc1, 0xc8, 0xda,
+  0xac, 0x00, 0xeb, 0xe9, 0x5f, 0x3d, 0x68, 0x96, 0x5e, 0x38, 0xf0, 0xf4,
+  0xf2, 0x4d, 0x6d, 0xe1, 0x4d, 0x37, 0x54, 0x4b, 0x8b, 0xe5, 0x89, 0xed,
+  0x2e, 0x7c, 0xc9, 0x9e, 0x56, 0x5d, 0xbb, 0x81, 0xb9, 0x8e, 0x6d, 0xd0,
+  0x6f, 0x0d, 0xc3, 0x89, 0x53, 0x0c, 0x09, 0x52, 0x73, 0x5f, 0x5d, 0xfc,
+  0x56, 0xfd, 0xb0, 0xfc, 0x65, 0xf1, 0x43, 0x46, 0xd1, 0xbe, 0x1a, 0x5d,
+  0x78, 0x1b, 0xc1, 0xde, 0x06, 0xb2, 0xd1, 0x8c, 0x11, 0x35, 0xbe, 0x8f,
+  0x02, 0xdf, 0x5f, 0x08, 0x18, 0x36, 0xd8, 0xe6, 0xb8, 0xbd, 0xb8, 0x96,
+  0x6b, 0x86, 0xf9, 0x87, 0xca, 0xf3, 0x33, 0x73, 0x8f, 0x97, 0x21, 0x6b,
+  0xd4, 0xfa, 0x85, 0x25, 0x09, 0x4e, 0x15, 0x5b, 0x6e, 0xda, 0x5e, 0x3b,
+  0x75, 0x7b, 0x3f, 0xf8, 0x73, 0x29, 0x2e, 0xe7, 0xa7, 0x5b, 0xf8, 0x3f,
+  0xe1, 0xee, 0xa3, 0xaf, 0x59, 0xe8, 0x7e, 0x1f, 0xf8, 0x81, 0xfd, 0xa4,
+  0xd7, 0xc8, 0x25, 0xb7, 0xd4, 0x75, 0x48, 0x3f, 0xb2, 0xad, 0x58, 0x3e,
+  0x55, 0x5f, 0x33, 0x5b, 0xf1, 0x19, 0x6c, 0xe1, 0xdb, 0x0a, 0x71, 0xce,
+  0x06, 0x4d, 0x7a, 0xd6, 0x9d, 0xfb, 0x31, 0x78, 0x9e, 0x7d, 0x4e, 0x3b,
+  0x0d, 0x2f, 0xc6, 0x7a, 0x1c, 0xf2, 0x99, 0x9a, 0x28, 0xe4, 0x86, 0xfb,
+  0x47, 0x91, 0x1c, 0x82, 0xbf, 0x28, 0x2d, 0x23, 0x45, 0x26, 0x37, 0x0c,
+  0x95, 0xce, 0x73, 0xc0, 0xaf, 0xcf, 0x27, 0xd7, 0xbc, 0x49, 0x7f, 0xa6,
+  0xea, 0x9a, 0x0e, 0x9b, 0x1e, 0x87, 0x78, 0xa8, 0x96, 0x86, 0xd6, 0x34,
+  0xd3, 0xed, 0x3c, 0xfb, 0x7b, 0x3b, 0xd2, 0x42, 0x22, 0xdc, 0xed, 0x12,
+  0xc7, 0x21, 0x38, 0x59, 0x32, 0x8d, 0x22, 0x11, 0x86, 0x60, 0x46, 0x2b,
+  0xd3, 0xfe, 0x1d, 0xfc, 0x30, 0xf8, 0xe1, 0xae, 0xf8, 0x23, 0x42, 0xf1,
+  0x9f, 0xc3, 0xff, 0x00, 0x0b, 0xdd, 0xea, 0x03, 0x52, 0xd7, 0x0e, 0x8f,
+  0x64, 0xb0, 0x16, 0x90, 0xde, 0x4b, 0x17, 0xcd, 0x29, 0x58, 0x51, 0x5b,
+  0xf7, 0x11, 0xe7, 0x12, 0x5c, 0x4c, 0x52, 0x35, 0x3b, 0x07, 0x4c, 0xd7,
+  0x5c, 0x78, 0x7d, 0x56, 0x8b, 0x71, 0x6e, 0x2f, 0xe4, 0xd5, 0xbe, 0x69,
+  0x7f, 0x97, 0x4d, 0x74, 0x32, 0x75, 0xda, 0xd2, 0xd7, 0x3f, 0x62, 0x3e,
+  0x14, 0x7f, 0xc1, 0x34, 0xfe, 0x32, 0xfc, 0x54, 0x5b, 0x8d, 0x3f, 0xc2,
+  0x3e, 0x2a, 0xf0, 0xf4, 0x13, 0xdb, 0x81, 0x2c, 0x96, 0xd0, 0xdf, 0x5b,
+  0xad, 0xe3, 0x37, 0x46, 0xc4, 0x96, 0x90, 0x10, 0x17, 0x27, 0xee, 0x17,
+  0xe0, 0xe3, 0x8c, 0x74, 0xf7, 0xbb, 0x6f, 0xf8, 0x24, 0x5f, 0xc7, 0x5d,
+  0x2a, 0xd7, 0xcd, 0xf1, 0x57, 0x8a, 0xa5, 0x8a, 0x22, 0xe7, 0x25, 0xb5,
+  0x68, 0x8c, 0x45, 0x41, 0x3b, 0x49, 0x69, 0x1a, 0x1c, 0x67, 0x18, 0xeb,
+  0x8c, 0x9e, 0xb5, 0xf1, 0x6e, 0x97, 0xf0, 0x33, 0xf6, 0xb8, 0xf8, 0x25,
+  0xf0, 0xd6, 0xf3, 0xe2, 0xa7, 0xc6, 0xef, 0x01, 0xdc, 0xbd, 0xb4, 0x7a,
+  0x9c, 0x36, 0xab, 0xf6, 0xeb, 0xe9, 0x22, 0x8e, 0xdd, 0x2e, 0x97, 0x08,
+  0xcf, 0x67, 0x6d, 0x11, 0x2b, 0x19, 0x77, 0x53, 0x13, 0xc7, 0x34, 0x64,
+  0x12, 0x01, 0x45, 0xc1, 0xaf, 0xdc, 0xdf, 0xd8, 0x9f, 0xe0, 0x57, 0xc3,
+  0xcf, 0x8a, 0x9e, 0x00, 0xb3, 0xf8, 0xa3, 0xe2, 0x3d, 0x2b, 0x5e, 0xd2,
+  0x6f, 0xe3, 0xcd, 0xb3, 0xd8, 0xc9, 0x77, 0x3f, 0x93, 0x30, 0x08, 0x81,
+  0xd9, 0xe2, 0xbb, 0x8e, 0x49, 0x42, 0x86, 0x2c, 0x15, 0x44, 0xac, 0x07,
+  0xcc, 0x72, 0x0b, 0x10, 0x3e, 0x9b, 0x2b, 0xe0, 0x8c, 0x3b, 0xaa, 0xb0,
+  0xd5, 0x69, 0x4a, 0x53, 0x6a, 0xea, 0xf2, 0xb2, 0x6b, 0xbb, 0xf7, 0x34,
+  0xfd, 0x76, 0x3a, 0x68, 0xe2, 0x9c, 0x9d, 0xad, 0x6f, 0xbc, 0xf9, 0x63,
+  0xc1, 0x7f, 0xf0, 0x4c, 0x06, 0xd5, 0x66, 0x16, 0xcd, 0x33, 0x4e, 0x8a,
+  0xc8, 0xaf, 0x72, 0xba, 0xad, 0x95, 0xd2, 0xc9, 0x93, 0x86, 0x3b, 0x52,
+  0x77, 0x2b, 0x83, 0xd4, 0x02, 0xde, 0xd9, 0x3c, 0x57, 0xbb, 0xe8, 0xdf,
+  0xf0, 0x49, 0x8f, 0x83, 0x37, 0x17, 0x5f, 0x60, 0xf1, 0x5b, 0xf8, 0xac,
+  0x4e, 0xf3, 0x32, 0x6e, 0xd3, 0x66, 0xb2, 0x10, 0xed, 0x50, 0x09, 0x21,
+  0xe4, 0x8c, 0x60, 0x1e, 0xdd, 0x4f, 0xb0, 0xe9, 0x5f, 0xad, 0xfe, 0x0b,
+  0xf0, 0x6f, 0x82, 0xb4, 0x98, 0xb7, 0xe8, 0x16, 0xd1, 0x83, 0x0b, 0xec,
+  0xde, 0xd1, 0xed, 0x64, 0x60, 0x07, 0x19, 0x2a, 0x0e, 0x40, 0xc5, 0x7a,
+  0x7c, 0x56, 0xe3, 0x18, 0xe0, 0x0f, 0x6a, 0xfb, 0xdc, 0x3f, 0x86, 0x19,
+  0x6d, 0x94, 0xaa, 0x41, 0x37, 0x7f, 0x2d, 0xbe, 0x49, 0x7e, 0xa7, 0x5c,
+  0x25, 0xe4, 0x7e, 0x40, 0x6a, 0xdf, 0xf0, 0x49, 0x7f, 0x82, 0xf1, 0x79,
+  0x50, 0xe8, 0x16, 0x3a, 0x84, 0x91, 0x2c, 0x80, 0xc9, 0x2d, 0xd6, 0xba,
+  0x04, 0xcc, 0xbf, 0xee, 0x0d, 0x35, 0xa3, 0xe3, 0xeb, 0x9f, 0x7a, 0xe7,
+  0x6f, 0xbf, 0xe0, 0x94, 0xf0, 0xd9, 0x78, 0x91, 0xe7, 0xf0, 0xd4, 0x7e,
+  0x1f, 0x9b, 0x48, 0x0b, 0xb9, 0x2d, 0x75, 0x7b, 0xab, 0xb3, 0x3e, 0xe2,
+  0x39, 0x50, 0xd6, 0xb1, 0x44, 0xa0, 0x67, 0xa1, 0xce, 0x7d, 0xab, 0xf6,
+  0xb0, 0x40, 0xa0, 0x0c, 0x11, 0xf8, 0xd3, 0xfc, 0xa1, 0xea, 0x2b, 0xba,
+  0xaf, 0x87, 0x19, 0x4c, 0x9b, 0x7e, 0xca, 0xde, 0x96, 0x56, 0xfb, 0x96,
+  0xbf, 0x3b, 0x97, 0xce, 0xed, 0x63, 0xf9, 0xf4, 0xb8, 0xff, 0x00, 0x82,
+  0x5b, 0x7c, 0x48, 0xb8, 0xf1, 0x28, 0x82, 0x7d, 0x0f, 0xc3, 0x89, 0xa7,
+  0xb6, 0xef, 0x32, 0x7b, 0x1d, 0x62, 0xf1, 0x07, 0x24, 0x81, 0x8f, 0x3f,
+  0xcd, 0x7c, 0x81, 0x82, 0x47, 0x97, 0x83, 0xd3, 0x23, 0xad, 0x7b, 0xce,
+  0x97, 0xff, 0x00, 0x04, 0x6d, 0xf8, 0x0b, 0x77, 0x6f, 0x24, 0x9e, 0x22,
+  0xbb, 0xd5, 0xa0, 0xb8, 0x64, 0xc4, 0x5f, 0x60, 0xbb, 0x49, 0x91, 0x5c,
+  0x8f, 0xbc, 0x44, 0xb6, 0xa8, 0xdc, 0x1e, 0xdb, 0xce, 0x7d, 0x6b, 0xf6,
+  0x44, 0xa2, 0x8f, 0x4a, 0x4c, 0x28, 0xe9, 0x4b, 0x0d, 0xe1, 0xce, 0x55,
+  0x4e, 0x72, 0x9f, 0xb3, 0x6e, 0xfd, 0xde, 0xde, 0x96, 0xb1, 0x3c, 0xc7,
+  0xe4, 0x1e, 0x81, 0xff, 0x00, 0x04, 0x71, 0xf8, 0x0b, 0x61, 0x7d, 0xe7,
+  0x6b, 0xda, 0xce, 0xb7, 0x7f, 0x6e, 0xa0, 0xf9, 0x70, 0x44, 0xb1, 0xdb,
+  0x3e, 0x4f, 0x4d, 0xf2, 0x2e, 0xfd, 0xc0, 0x0e, 0xa3, 0x68, 0xcf, 0x5c,
+  0x8a, 0xee, 0x2d, 0xff, 0x00, 0xe0, 0x96, 0xff, 0x00, 0x04, 0x34, 0xc9,
+  0xcc, 0x16, 0x56, 0xf3, 0xc9, 0x6a, 0x33, 0x82, 0x6e, 0xee, 0x62, 0x9c,
+  0x13, 0xfc, 0x41, 0xc4, 0xcc, 0xa4, 0x8e, 0xa3, 0x28, 0x07, 0xb6, 0x38,
+  0xaf, 0xd4, 0x6d, 0xcb, 0xd6, 0x8c, 0xad, 0x6c, 0xfc, 0x3d, 0xca, 0x79,
+  0x79, 0x7d, 0x87, 0x5b, 0xeb, 0x29, 0x3f, 0xcd, 0xbb, 0xaf, 0x27, 0xa1,
+  0x4a, 0x76, 0xe8, 0x7e, 0x36, 0xf8, 0x97, 0xfe, 0x09, 0xaf, 0xe2, 0x6d,
+  0x03, 0x5a, 0x92, 0xd7, 0xe1, 0x75, 0xf4, 0x57, 0x7a, 0x7c, 0x8a, 0x5d,
+  0x27, 0xf1, 0x1c, 0xe2, 0x59, 0x21, 0x38, 0x3f, 0x22, 0x84, 0x8f, 0x71,
+  0x1d, 0x00, 0x39, 0xe4, 0xf5, 0x03, 0xad, 0x79, 0xae, 0xb1, 0xfb, 0x06,
+  0x7c, 0x77, 0xd3, 0xec, 0x24, 0xd4, 0x6f, 0x1e, 0xda, 0x2e, 0x19, 0x5a,
+  0xdb, 0x45, 0xb7, 0x82, 0x79, 0x24, 0xc0, 0xe1, 0x86, 0x59, 0x4a, 0x9e,
+  0xdc, 0x06, 0x3f, 0x9d, 0x7e, 0xee, 0x6e, 0x1d, 0x29, 0xc3, 0x19, 0xaf,
+  0x17, 0x15, 0xe1, 0x2e, 0x55, 0x52, 0x4e, 0x50, 0xe6, 0x85, 0xee, 0xec,
+  0x9e, 0x9f, 0x73, 0xe9, 0xf3, 0x29, 0x55, 0x67, 0xf3, 0x8f, 0x61, 0xfb,
+  0x14, 0x7e, 0xd3, 0x48, 0xf1, 0xbc, 0xda, 0x5d, 0x8c, 0xf6, 0x73, 0xc4,
+  0xb3, 0xc7, 0x2e, 0xa4, 0xf7, 0xc6, 0x61, 0xbd, 0xb1, 0xb1, 0xa3, 0x8a,
+  0x09, 0x4a, 0xc8, 0x01, 0xe8, 0x7e, 0x51, 0xea, 0x79, 0xaf, 0xa1, 0x74,
+  0xbf, 0xd8, 0x7b, 0xf6, 0x82, 0xb3, 0xd3, 0x9a, 0x7b, 0x5d, 0x2b, 0xc0,
+  0x8b, 0x28, 0xdb, 0x12, 0xc7, 0xfe, 0x96, 0x25, 0x3b, 0x17, 0x87, 0x7d,
+  0xde, 0x5a, 0x10, 0xd9, 0xe7, 0x6b, 0x72, 0x7a, 0x8f, 0x4f, 0xdb, 0x70,
+  0xc3, 0x1c, 0x60, 0x1a, 0x42, 0xcd, 0xed, 0x59, 0xe0, 0x7c, 0x24, 0xcb,
+  0x28, 0xdf, 0x76, 0xfb, 0xde, 0xcc, 0x97, 0x51, 0xbe, 0xa7, 0xf3, 0xdb,
+  0xf1, 0x1f, 0xc1, 0x9f, 0xb6, 0x17, 0xc2, 0x1b, 0xc4, 0xbc, 0x7d, 0x3f,
+  0xc2, 0xf6, 0xf6, 0xcd, 0x22, 0xda, 0x47, 0x6d, 0xa7, 0x03, 0x14, 0x32,
+  0xb1, 0x56, 0x65, 0x76, 0xf3, 0xa1, 0x69, 0x00, 0x38, 0x20, 0x9f, 0x34,
+  0x0e, 0x00, 0xe7, 0x35, 0xf3, 0x16, 0xab, 0xfb, 0x46, 0xfc, 0x5e, 0x32,
+  0x24, 0x3a, 0x81, 0x96, 0xde, 0xe3, 0x24, 0x98, 0x6d, 0x17, 0x30, 0xb2,
+  0x8c, 0x91, 0x86, 0xb6, 0xdb, 0x26, 0xd1, 0xdd, 0x88, 0x3c, 0x77, 0xaf,
+  0xe9, 0xeb, 0x55, 0xf0, 0x27, 0x86, 0x75, 0x9d, 0x60, 0x6b, 0xba, 0x9c,
+  0x53, 0x49, 0x70, 0x0a, 0x95, 0x22, 0x79, 0x55, 0x46, 0xc1, 0x80, 0x02,
+  0x2b, 0x01, 0x8f, 0x5e, 0x39, 0x35, 0xf0, 0xff, 0x00, 0xc7, 0x4f, 0x1c,
+  0xfe, 0xc1, 0xfe, 0x1d, 0xb4, 0xbd, 0xf0, 0x9f, 0x8e, 0xf5, 0x3f, 0x0c,
+  0x69, 0xba, 0x8c, 0x56, 0xb7, 0x12, 0xc5, 0xa4, 0xea, 0x1a, 0x95, 0xde,
+  0x8f, 0x6d, 0x24, 0xf6, 0xe8, 0xca, 0x44, 0xde, 0x41, 0x45, 0x0e, 0x77,
+  0x60, 0xb1, 0x56, 0x91, 0x87, 0x40, 0xd8, 0xaf, 0x9f, 0xcd, 0x7c, 0x38,
+  0x74, 0x54, 0xb9, 0x31, 0x56, 0x4e, 0xf6, 0x53, 0x9b, 0xfc, 0x34, 0x7f,
+  0x86, 0xbd, 0x35, 0x07, 0x37, 0xba, 0x91, 0xf8, 0x29, 0x7f, 0xfb, 0x71,
+  0x7c, 0x5c, 0xd1, 0x2e, 0xc5, 0x8d, 0xb6, 0x8b, 0x60, 0xd0, 0x39, 0xd9,
+  0x23, 0x6a, 0x03, 0x54, 0xb8, 0xbb, 0x45, 0xe0, 0x19, 0x23, 0x55, 0x68,
+  0xd0, 0x83, 0x9c, 0xae, 0xe6, 0x52, 0x7d, 0x00, 0xad, 0x49, 0x7f, 0x6e,
+  0x8f, 0x19, 0xc9, 0xe1, 0x51, 0x75, 0x1e, 0x9c, 0x6e, 0x24, 0xb6, 0x99,
+  0xd7, 0xed, 0x30, 0xcb, 0x2d, 0xb1, 0x91, 0x88, 0x25, 0x41, 0x86, 0x69,
+  0xa2, 0x5c, 0x0c, 0x72, 0x00, 0x27, 0x3d, 0x33, 0xc8, 0x3f, 0x3f, 0x7e,
+  0xd1, 0xbf, 0x16, 0xfc, 0x3d, 0xab, 0xdc, 0xbf, 0x83, 0xf4, 0xdd, 0x03,
+  0xc3, 0x96, 0x56, 0xbf, 0xe9, 0x53, 0xbd, 0xd5, 0xa6, 0xb7, 0x3d, 0xd1,
+  0x48, 0xe3, 0xdc, 0x20, 0xf2, 0x65, 0xf3, 0x5d, 0x54, 0x4c, 0x85, 0x64,
+  0x53, 0x2c, 0x09, 0x21, 0x1d, 0x02, 0x8a, 0xf8, 0x47, 0x47, 0x9e, 0xdb,
+  0xe2, 0x57, 0x8b, 0x2d, 0xf4, 0x2b, 0x46, 0xd6, 0x75, 0x6d, 0x5a, 0xe2,
+  0xf8, 0xd9, 0x47, 0xa7, 0x69, 0xf7, 0xb0, 0x1b, 0x34, 0x62, 0x9f, 0xbb,
+  0x76, 0xbb, 0xb8, 0x69, 0x6d, 0x41, 0x92, 0x5f, 0x90, 0x87, 0x55, 0x3d,
+  0x43, 0x1c, 0x9c, 0x9f, 0xca, 0xaa, 0x51, 0xc5, 0x42, 0x4a, 0x14, 0xea,
+  0x35, 0x6e, 0xcd, 0xf9, 0xef, 0x7b, 0x6f, 0xfa, 0x1c, 0xf2, 0xac, 0xef,
+  0x6b, 0xdc, 0xfb, 0x23, 0x53, 0xff, 0x00, 0x82, 0x91, 0xf8, 0xe4, 0xf9,
+  0xf6, 0x1a, 0xfe, 0x81, 0x6b, 0x34, 0x20, 0x96, 0x8a, 0x5b, 0xcb, 0xb9,
+  0xed, 0xee, 0x62, 0x0b, 0x9d, 0xc4, 0xab, 0xba, 0x21, 0x1c, 0xf1, 0xb4,
+  0xb0, 0xe8, 0x01, 0x26, 0xae, 0xf8, 0x7b, 0xf6, 0xbb, 0xf0, 0x27, 0x88,
+  0x4a, 0xea, 0x7e, 0x25, 0xb2, 0xd7, 0xee, 0xad, 0x61, 0x90, 0x4b, 0x7f,
+  0x0e, 0x8e, 0xb6, 0xf6, 0x88, 0x88, 0x46, 0x0a, 0x7d, 0xaa, 0x6b, 0xa9,
+  0x32, 0xc0, 0x91, 0x8c, 0xae, 0x4e, 0x71, 0xc6, 0x2b, 0xc5, 0x3e, 0x24,
+  0xfc, 0x0b, 0xd2, 0x7e, 0x19, 0xdf, 0xa6, 0x87, 0xa8, 0x4d, 0x02, 0xdf,
+  0x40, 0x62, 0x8b, 0x55, 0xf0, 0xe5, 0xdc, 0x30, 0x5c, 0x5c, 0xc3, 0x34,
+  0x8a, 0x15, 0x76, 0x48, 0x87, 0xc8, 0x99, 0x49, 0xe4, 0xb4, 0x6d, 0xb9,
+  0x0f, 0x45, 0xc6, 0x4d, 0x79, 0x95, 0xd7, 0xc7, 0xfb, 0xdf, 0x08, 0xe9,
+  0x83, 0xc1, 0x3e, 0x16, 0xbf, 0x8a, 0x2b, 0x78, 0x27, 0x96, 0x51, 0x6a,
+  0xe1, 0x67, 0xb4, 0x67, 0x42, 0x02, 0xc6, 0x62, 0x02, 0x4d, 0x8b, 0xc0,
+  0xc1, 0x55, 0x11, 0x8f, 0x94, 0x83, 0x9a, 0xf2, 0x71, 0xf8, 0xd8, 0xce,
+  0xa2, 0x4a, 0x12, 0x94, 0x96, 0x8f, 0x57, 0xa7, 0xad, 0xfa, 0xf9, 0x7d,
+  0xe4, 0xa9, 0x4e, 0x37, 0xe6, 0x67, 0xff, 0xd0, 0xfc, 0x0c, 0xd6, 0x24,
+  0xd4, 0xb4, 0x5b, 0x84, 0xba, 0x67, 0x90, 0x4e, 0xaa, 0x51, 0x58, 0x48,
+  0xca, 0xc3, 0x1c, 0xe1, 0xb6, 0xba, 0x8e, 0x18, 0x67, 0x04, 0x63, 0xd8,
+  0xf5, 0xae, 0x93, 0xc1, 0x9f, 0xb4, 0x07, 0xc4, 0xaf, 0x87, 0xb2, 0x48,
+  0xfe, 0x1c, 0xd5, 0x2e, 0x6c, 0x1d, 0xc0, 0x53, 0x71, 0x61, 0x3b, 0x5a,
+  0xce, 0x08, 0xe4, 0x17, 0x74, 0x70, 0x79, 0x03, 0x38, 0xcf, 0x3f, 0x95,
+  0x7e, 0x88, 0x6a, 0xdf, 0xb1, 0x4f, 0xc7, 0x3f, 0x11, 0x5b, 0x49, 0xac,
+  0x78, 0x3f, 0xc0, 0x1e, 0x2f, 0xbf, 0xd2, 0x6c, 0xa5, 0xb8, 0x82, 0xe6,
+  0x7b, 0x1b, 0x71, 0xa8, 0x2c, 0xc2, 0x29, 0x17, 0x7b, 0xb5, 0xd5, 0xad,
+  0x9a, 0x22, 0x86, 0xdd, 0x84, 0x29, 0x6e, 0x77, 0x8d, 0xa5, 0x01, 0x51,
+  0x9a, 0xf8, 0xbb, 0xe3, 0x77, 0x84, 0xac, 0xda, 0xd2, 0xc3, 0xc2, 0x5e,
+  0x05, 0xbd, 0xfb, 0x64, 0xd6, 0xde, 0x6c, 0xfa, 0xbe, 0x98, 0xb6, 0x9f,
+  0x62, 0x97, 0x4e, 0x9a, 0xd8, 0x3f, 0x99, 0x14, 0xa8, 0x23, 0x8c, 0x12,
+  0x8a, 0xad, 0xe6, 0xbe, 0xd0, 0xc5, 0x87, 0xdd, 0x23, 0x00, 0x7f, 0x3b,
+  0xc6, 0x54, 0xeb, 0x25, 0x29, 0xc1, 0x38, 0xf7, 0xfc, 0xba, 0x68, 0x7c,
+  0xfa, 0xa2, 0xd0, 0xe9, 0xff, 0x00, 0x69, 0xcf, 0x8a, 0x3e, 0x24, 0xd4,
+  0x93, 0x5f, 0xbe, 0xf1, 0x26, 0xa5, 0x71, 0x38, 0x54, 0x92, 0x39, 0xef,
+  0x6f, 0xa6, 0x69, 0x16, 0x40, 0x32, 0x85, 0x18, 0xbb, 0x64, 0x00, 0x30,
+  0xad, 0x93, 0xb3, 0x91, 0xc0, 0xc5, 0x7d, 0xd7, 0xe0, 0xaf, 0xdb, 0x57,
+  0x4d, 0xbe, 0xf8, 0x57, 0x3f, 0x84, 0x35, 0xfd, 0x25, 0x9f, 0x52, 0xbf,
+  0x48, 0x66, 0x59, 0x74, 0xc8, 0x60, 0x8a, 0xce, 0x59, 0x6c, 0x3c, 0xb4,
+  0x78, 0xcb, 0x48, 0x24, 0x8c, 0x6f, 0x88, 0x02, 0xe5, 0x62, 0x93, 0x05,
+  0x73, 0xb2, 0x3d, 0xee, 0xc7, 0xf1, 0x37, 0x41, 0xf0, 0xe5, 0xfe, 0xac,
+  0x6e, 0x75, 0x7b, 0xc7, 0x92, 0xda, 0xc2, 0x26, 0x10, 0xab, 0x92, 0xf8,
+  0x33, 0x0c, 0x16, 0x8f, 0x05, 0x15, 0xce, 0xd1, 0x91, 0x8c, 0x01, 0xbb,
+  0x00, 0x13, 0xc9, 0xab, 0x3a, 0xf7, 0xc4, 0x6b, 0x7f, 0x09, 0x4b, 0x06,
+  0x9f, 0xe0, 0xd9, 0x27, 0x8e, 0xee, 0x37, 0xf3, 0x4d, 0xdc, 0x8f, 0xf2,
+  0x20, 0x44, 0xd8, 0xcd, 0x1a, 0x93, 0x8c, 0xb2, 0x02, 0xa5, 0x73, 0x86,
+  0x52, 0x54, 0xe4, 0x64, 0x0e, 0xa9, 0x65, 0x70, 0x9c, 0x9a, 0xa5, 0x6b,
+  0xf5, 0xf2, 0xf5, 0x7e, 0x46, 0x94, 0xa2, 0xd3, 0x76, 0x3f, 0x41, 0x3c,
+  0x79, 0xfb, 0x47, 0x78, 0xdf, 0xc3, 0x7e, 0x33, 0xbc, 0xd5, 0x7c, 0x29,
+  0x2d, 0xed, 0xb3, 0xa4, 0xe8, 0x66, 0x8e, 0xe1, 0xa3, 0xb9, 0x96, 0x07,
+  0x0e, 0xd2, 0x94, 0x1b, 0xa1, 0x55, 0x54, 0x57, 0x73, 0xc2, 0xae, 0x30,
+  0x48, 0x38, 0x52, 0x6a, 0xdf, 0x8a, 0x7f, 0x6f, 0xdf, 0xda, 0xc3, 0xe3,
+  0x34, 0xd6, 0x3e, 0x1d, 0xd7, 0xfc, 0x59, 0xab, 0x7f, 0xa0, 0x6f, 0x96,
+  0x39, 0x04, 0xad, 0xe7, 0x6e, 0x50, 0x63, 0x65, 0x63, 0x95, 0x2d, 0xf2,
+  0x12, 0xa1, 0x33, 0x8c, 0x64, 0x10, 0x73, 0x8a, 0xf3, 0xaf, 0x81, 0x5f,
+  0x09, 0xef, 0x3e, 0x26, 0x78, 0xfe, 0x4f, 0x84, 0x3e, 0x10, 0xb6, 0xd4,
+  0x7c, 0x55, 0xe2, 0xed, 0x7f, 0x4e, 0xb7, 0xba, 0xb2, 0xd4, 0xec, 0x6e,
+  0x2e, 0x26, 0x5d, 0x32, 0x0c, 0x94, 0xbc, 0xb9, 0x68, 0xde, 0x01, 0xe6,
+  0x61, 0x15, 0xcf, 0x96, 0x84, 0x82, 0x1a, 0x33, 0x90, 0x37, 0x57, 0xaa,
+  0xf8, 0xf3, 0x4a, 0xd0, 0x3e, 0x0d, 0x29, 0xf8, 0x59, 0x73, 0xa4, 0xac,
+  0xba, 0xc0, 0xb4, 0x87, 0x59, 0xb5, 0x4b, 0xbd, 0x3e, 0x5b, 0x7d, 0x72,
+  0xca, 0xee, 0x47, 0x21, 0xe6, 0x96, 0x5d, 0x83, 0x7d, 0xbe, 0xdd, 0xbb,
+  0xe3, 0xb9, 0x12, 0x44, 0xcb, 0x22, 0xaa, 0x46, 0x24, 0x05, 0x85, 0x54,
+  0xc2, 0x53, 0xc3, 0xd0, 0x56, 0xd5, 0xb5, 0xf2, 0xdb, 0x77, 0xbd, 0xfe,
+  0x7b, 0x75, 0x34, 0x54, 0xe5, 0xb2, 0x66, 0x72, 0x7e, 0xcb, 0xbe, 0x34,
+  0xf1, 0x71, 0xba, 0xf1, 0x2e, 0xa5, 0xa8, 0x5d, 0xea, 0x10, 0x46, 0x11,
+  0xae, 0x6e, 0x2f, 0x96, 0x54, 0x90, 0xc4, 0xe8, 0x24, 0x46, 0x91, 0xa4,
+  0x79, 0xc2, 0xfe, 0xef, 0x24, 0xb0, 0x05, 0x55, 0x81, 0x50, 0x18, 0x2e,
+  0x4d, 0xaf, 0x03, 0xfe, 0xcf, 0xf0, 0xde, 0x5d, 0xc7, 0x77, 0xa6, 0xeb,
+  0xb1, 0xdc, 0x69, 0x56, 0xec, 0x27, 0xd4, 0x34, 0x9b, 0xab, 0x98, 0x56,
+  0xe1, 0x54, 0xb6, 0xd9, 0xd6, 0x3b, 0x65, 0x7f, 0xde, 0xba, 0xaa, 0xe4,
+  0xec, 0x51, 0x21, 0x50, 0x1b, 0xe5, 0x5c, 0x11, 0xe2, 0xd6, 0x7e, 0x3b,
+  0xbf, 0xf1, 0xd5, 0xa4, 0xda, 0xb7, 0x8a, 0xfc, 0x47, 0x74, 0xe6, 0xea,
+  0x0f, 0xb4, 0x26, 0x93, 0x63, 0x9d, 0x3e, 0xc5, 0x2e, 0xc1, 0x2e, 0x5f,
+  0xc8, 0x8a, 0x07, 0x45, 0xde, 0xa5, 0x95, 0x11, 0x36, 0x37, 0x98, 0xb9,
+  0xf9, 0x50, 0x80, 0x79, 0x2d, 0x7b, 0xe2, 0x5f, 0x8f, 0x3c, 0x55, 0x6b,
+  0x05, 0xd4, 0x37, 0x9a, 0xb5, 0xad, 0x85, 0x85, 0xb7, 0xf6, 0x6d, 0x81,
+  0xb8, 0x99, 0xa0, 0x82, 0x55, 0xb4, 0x42, 0xe2, 0x3c, 0x1f, 0x95, 0x9c,
+  0x92, 0x19, 0x51, 0x57, 0x83, 0xd7, 0xb9, 0xaf, 0x3a, 0x9e, 0x17, 0x11,
+  0x56, 0x32, 0x8c, 0xaa, 0x5f, 0x4b, 0x69, 0xa2, 0x5e, 0x7b, 0x7d, 0xcb,
+  0xf2, 0x1f, 0x22, 0x4f, 0x63, 0xe9, 0x88, 0x8e, 0xa3, 0xe0, 0x1d, 0x4a,
+  0x6b, 0x8f, 0x0f, 0xc0, 0xff, 0x00, 0x66, 0x22, 0x69, 0xac, 0xe7, 0xbd,
+  0x84, 0xc7, 0x71, 0xe4, 0xa3, 0xe5, 0x8a, 0xbc, 0x89, 0xe6, 0x6d, 0x46,
+  0xf9, 0x02, 0xf9, 0xaf, 0xdb, 0x3d, 0x98, 0x50, 0xd7, 0xf5, 0xbf, 0x14,
+  0x78, 0xbc, 0x59, 0x78, 0xd7, 0x51, 0x4b, 0x69, 0xca, 0x9f, 0x2a, 0x6b,
+  0x7b, 0x5d, 0xb1, 0x5c, 0x15, 0x00, 0x85, 0x91, 0x53, 0xe4, 0xf3, 0x46,
+  0x08, 0x22, 0x46, 0xf4, 0xc0, 0xc8, 0x53, 0x5f, 0x0d, 0x3f, 0xc5, 0x2f,
+  0x1e, 0xc8, 0x12, 0x79, 0xb5, 0x29, 0x21, 0x8e, 0x29, 0xfe, 0x54, 0x67,
+  0xc4, 0x8f, 0xd7, 0x86, 0xc9, 0xc1, 0xe0, 0x1e, 0x54, 0x60, 0x7a, 0x9c,
+  0x8a, 0xee, 0x61, 0xf8, 0xa5, 0xe2, 0x7b, 0x99, 0xed, 0x53, 0x50, 0x9e,
+  0x18, 0x56, 0x08, 0xd5, 0x2d, 0xa2, 0xb1, 0x09, 0x0b, 0xe5, 0xc0, 0xdc,
+  0x84, 0xa7, 0xcc, 0xfb, 0xf1, 0x9e, 0x72, 0x14, 0x9c, 0xa8, 0x5c, 0x91,
+  0x59, 0x50, 0xe1, 0x89, 0x27, 0xcf, 0x2f, 0x79, 0xbd, 0x9f, 0x51, 0x4e,
+  0x37, 0x3e, 0xc6, 0xf0, 0xdf, 0x8d, 0xbc, 0x3d, 0x61, 0xa9, 0xf9, 0xdf,
+  0x11, 0xfc, 0x3f, 0x73, 0x0c, 0x93, 0xac, 0xab, 0x0d, 0xf6, 0x9e, 0x22,
+  0xbe, 0x46, 0xde, 0xd9, 0x56, 0x92, 0x27, 0x72, 0x06, 0xd1, 0x85, 0xc8,
+  0x70, 0xd9, 0xc9, 0x07, 0x02, 0xbf, 0x61, 0x7f, 0x64, 0xdf, 0xda, 0x37,
+  0xe0, 0x8f, 0xc3, 0x9d, 0x52, 0xd9, 0xbc, 0x5f, 0xe1, 0x75, 0xd5, 0xde,
+  0x0f, 0x2a, 0x7b, 0x4b, 0xdf, 0x0c, 0x5d, 0x43, 0x67, 0x7d, 0xe4, 0xef,
+  0x62, 0xb3, 0xc9, 0x04, 0xc6, 0x31, 0x24, 0x9b, 0xb2, 0x36, 0x34, 0x8e,
+  0x06, 0x3e, 0x5c, 0x16, 0x2c, 0xdf, 0x84, 0xde, 0x08, 0xbf, 0xb9, 0x9e,
+  0x47, 0xbf, 0x9d, 0x25, 0x0b, 0x2e, 0xfb, 0x49, 0x65, 0x8e, 0x64, 0x88,
+  0x74, 0x2e, 0xc0, 0x92, 0x64, 0x56, 0x52, 0xb9, 0x39, 0x03, 0x2c, 0x73,
+  0xc7, 0x51, 0x5e, 0xad, 0xa1, 0xf8, 0x32, 0xd8, 0x49, 0x24, 0xf6, 0xfa,
+  0xf5, 0xfc, 0x13, 0xc0, 0x9f, 0xe8, 0x73, 0x3a, 0xa4, 0xcd, 0x0c, 0x4b,
+  0x20, 0xdc, 0x52, 0x21, 0xb6, 0x42, 0x9c, 0xb7, 0x39, 0x55, 0xc6, 0x32,
+  0x38, 0xc1, 0x98, 0x61, 0x5e, 0x12, 0xb2, 0x97, 0x32, 0x5e, 0x4d, 0x5f,
+  0xf3, 0xbf, 0xf5, 0xb5, 0x8c, 0x35, 0x47, 0xf6, 0xbf, 0xf0, 0xeb, 0xfe,
+  0x0a, 0x69, 0xf0, 0x22, 0xdb, 0xc4, 0x17, 0x1e, 0x1a, 0xd4, 0x75, 0x2d,
+  0x67, 0x5b, 0x47, 0x48, 0xd2, 0x08, 0xb5, 0x31, 0xa6, 0x58, 0x3c, 0x13,
+  0x03, 0xb4, 0xa7, 0x9c, 0xf2, 0x40, 0x8e, 0x72, 0x76, 0xb9, 0x24, 0x85,
+  0x65, 0xe1, 0xd9, 0x4e, 0xea, 0xfb, 0x0f, 0x41, 0xfd, 0xa2, 0xfe, 0x03,
+  0xfc, 0x3d, 0xf8, 0x7b, 0x75, 0xe3, 0xaf, 0x16, 0xde, 0xe8, 0x7e, 0x1d,
+  0x12, 0x4e, 0xb3, 0xcb, 0xa1, 0xd8, 0x6a, 0x36, 0xf7, 0xd7, 0x50, 0x87,
+  0x55, 0xc3, 0x4b, 0x0c, 0x2c, 0x02, 0xcd, 0xb4, 0x65, 0xe3, 0x8c, 0x36,
+  0xc0, 0xb8, 0x24, 0x9c, 0x81, 0xfc, 0x31, 0x78, 0x1f, 0xc4, 0x3a, 0x87,
+  0x84, 0x74, 0x4b, 0xad, 0x2f, 0x57, 0xd4, 0x12, 0xe6, 0xe6, 0x68, 0xe5,
+  0x66, 0x8e, 0x40, 0xd2, 0x39, 0xd8, 0xe4, 0x99, 0x12, 0xdd, 0x5b, 0x69,
+  0x91, 0xb8, 0x20, 0xe4, 0x67, 0xd3, 0x8c, 0x1e, 0x8b, 0x59, 0xf1, 0xc4,
+  0xda, 0xc5, 0x98, 0x96, 0x53, 0xaf, 0xbd, 0xb4, 0x50, 0x89, 0x27, 0x79,
+  0xd2, 0x51, 0x1c, 0xb1, 0x47, 0x21, 0xc4, 0x6e, 0xad, 0xf2, 0xa9, 0x77,
+  0x2a, 0x06, 0x42, 0xfa, 0x60, 0x9c, 0x67, 0xea, 0x70, 0x3c, 0x7f, 0x8f,
+  0x55, 0x65, 0x19, 0xfb, 0xcb, 0xa6, 0x9a, 0x2f, 0x3e, 0xef, 0xef, 0xef,
+  0x74, 0x6f, 0x4e, 0xaf, 0xbb, 0xaa, 0x3f, 0xb6, 0x8f, 0x0d, 0x7e, 0xdf,
+  0x3f, 0xb3, 0x9f, 0x8b, 0xf4, 0x1f, 0xf8, 0x48, 0xbc, 0x31, 0x7b, 0x73,
+  0x34, 0x1f, 0x6c, 0xfb, 0x20, 0x33, 0xc6, 0xb0, 0xe4, 0x03, 0x83, 0x20,
+  0x25, 0xcf, 0xcb, 0xfc, 0x43, 0xb9, 0x1c, 0x8a, 0xfa, 0x83, 0xc0, 0x3f,
+  0x14, 0xfe, 0x1d, 0xfc, 0x4a, 0xb5, 0x7b, 0xaf, 0x04, 0xea, 0x96, 0x97,
+  0xe2, 0x20, 0xa6, 0x54, 0x86, 0x54, 0x69, 0x13, 0x70, 0xc8, 0xdc, 0xaa,
+  0x49, 0x1c, 0xe4, 0x72, 0x39, 0x20, 0xe3, 0x38, 0xcd, 0x7f, 0x0a, 0x1a,
+  0x7f, 0xed, 0x07, 0xe2, 0x0d, 0x6b, 0x45, 0xb6, 0xb3, 0xf0, 0xf4, 0xcb,
+  0x6c, 0xb1, 0xc0, 0x6e, 0x2e, 0x7c, 0xa7, 0x68, 0x56, 0x45, 0x32, 0xf9,
+  0x41, 0x9a, 0x15, 0x79, 0x04, 0x65, 0x30, 0x98, 0x68, 0xc2, 0x0d, 0xad,
+  0x8e, 0xb9, 0xcf, 0xec, 0xff, 0x00, 0xfc, 0x12, 0xfb, 0xe2, 0xdf, 0x87,
+  0xb5, 0xbf, 0x8a, 0x36, 0x10, 0x6b, 0x9a, 0xa5, 0xf8, 0xf1, 0x0e, 0xa9,
+  0x0f, 0xd8, 0xed, 0xac, 0x51, 0x54, 0xc4, 0x2d, 0xa1, 0xdc, 0xf2, 0x79,
+  0xc1, 0xc3, 0x9d, 0xa0, 0xaa, 0x04, 0x75, 0x90, 0x1f, 0x9b, 0xa1, 0xce,
+  0x6b, 0xd9, 0xc8, 0x38, 0xd7, 0x32, 0xab, 0x8e, 0x8d, 0x1c, 0x53, 0x83,
+  0x84, 0x9d, 0x95, 0x93, 0x4d, 0x7c, 0xf5, 0x57, 0xbf, 0xf9, 0x16, 0xf1,
+  0x0a, 0xea, 0x36, 0x3f, 0xa4, 0xd7, 0x95, 0x05, 0x55, 0x79, 0xd0, 0xf4,
+  0xc9, 0xaa, 0xb8, 0x77, 0xe7, 0x93, 0x51, 0x34, 0x64, 0x73, 0xd2, 0xbf,
+  0x66, 0x51, 0x45, 0xb6, 0xfa, 0x22, 0x47, 0x94, 0x91, 0xd7, 0x15, 0x09,
+  0xb9, 0x0b, 0xc1, 0x35, 0xe4, 0xfe, 0x3e, 0xf8, 0xe1, 0xf0, 0x9f, 0xe1,
+  0x85, 0xf5, 0xbe, 0x97, 0xe3, 0xbd, 0x77, 0x4f, 0xd3, 0xae, 0x2e, 0x83,
+  0x34, 0x51, 0x5c, 0x4c, 0xaa, 0x76, 0xa2, 0xb3, 0xb1, 0x39, 0x3c, 0x00,
+  0x14, 0xf5, 0xaf, 0x16, 0xb9, 0xfd, 0xb3, 0xbe, 0x00, 0xdd, 0x69, 0x6d,
+  0xaa, 0x68, 0xfa, 0x94, 0xd7, 0xc4, 0x16, 0x11, 0x47, 0x6f, 0x17, 0x32,
+  0x85, 0x19, 0xdc, 0x85, 0x88, 0x52, 0xa4, 0xf0, 0x0e, 0x73, 0x9e, 0xdd,
+  0x33, 0xe6, 0x63, 0x73, 0xfc, 0x06, 0x1a, 0xeb, 0x13, 0x88, 0x8c, 0x3d,
+  0x5a, 0x23, 0x99, 0xbd, 0x11, 0xf6, 0x08, 0xba, 0xe0, 0xe3, 0x14, 0xd8,
+  0xaf, 0xe2, 0x7e, 0x51, 0x95, 0x86, 0x7a, 0xa9, 0x04, 0x71, 0xef, 0xed,
+  0x5f, 0x9a, 0xff, 0x00, 0x14, 0xbf, 0x6a, 0xdd, 0x1b, 0x4b, 0x87, 0x5b,
+  0x59, 0x2f, 0xa6, 0x87, 0x4e, 0xb5, 0xd2, 0x13, 0x53, 0x86, 0x6b, 0x59,
+  0xa3, 0x33, 0x83, 0x73, 0x11, 0x68, 0x93, 0x64, 0x44, 0xb1, 0x50, 0x40,
+  0x2c, 0x58, 0xa9, 0x8f, 0x3f, 0x33, 0x67, 0x02, 0xbe, 0x4e, 0xf0, 0xd7,
+  0xfc, 0x14, 0x83, 0xc0, 0xd2, 0x78, 0x4e, 0xdb, 0x4d, 0xf0, 0xfd, 0xf2,
+  0xd9, 0x6a, 0xd0, 0xa2, 0x3a, 0xc5, 0x68, 0xf1, 0xc8, 0x97, 0xb2, 0x87,
+  0x91, 0xa4, 0x81, 0x63, 0x91, 0x8a, 0xa1, 0x72, 0x77, 0x2b, 0x60, 0xe4,
+  0x02, 0x73, 0xd0, 0x57, 0xcd, 0x62, 0xfc, 0x44, 0xcb, 0x68, 0xd5, 0x74,
+  0xe5, 0x2d, 0x12, 0x7f, 0x3b, 0x74, 0x5f, 0xa5, 0xda, 0xbd, 0xbb, 0x96,
+  0xaf, 0x63, 0xf7, 0x76, 0xe3, 0x57, 0xb1, 0xb1, 0x81, 0xae, 0x6f, 0x24,
+  0x48, 0xd1, 0x17, 0x73, 0xbc, 0x8c, 0x14, 0x28, 0xe9, 0x93, 0xe8, 0x2b,
+  0x4a, 0x39, 0xc4, 0xb1, 0xac, 0xcb, 0x8d, 0x8e, 0x37, 0x2b, 0xe7, 0xe5,
+  0x23, 0x19, 0xc8, 0x3d, 0x3a, 0x57, 0xe2, 0x06, 0xa5, 0xfb, 0x77, 0x78,
+  0x67, 0xc5, 0xf6, 0xce, 0xba, 0xbd, 0xdf, 0xf6, 0x4d, 0xed, 0x8e, 0x99,
+  0x35, 0xcd, 0xed, 0xed, 0xc0, 0x92, 0xce, 0xd9, 0x2d, 0xf6, 0x00, 0x01,
+  0xc8, 0x7d, 0xe1, 0xd9, 0xd4, 0xe5, 0xd3, 0x67, 0xdd, 0x23, 0x39, 0xaf,
+  0x8f, 0x7e, 0x20, 0xff, 0x00, 0xc1, 0x5a, 0xfc, 0x51, 0xa2, 0xf8, 0x3e,
+  0x4f, 0x00, 0x41, 0x0d, 0xbd, 0xe6, 0x9d, 0xa9, 0x42, 0xd6, 0x96, 0x5a,
+  0x95, 0xfc, 0x52, 0xc9, 0x3c, 0x0d, 0x32, 0x06, 0x55, 0x12, 0x07, 0x54,
+  0x67, 0x45, 0x65, 0x74, 0x65, 0xdc, 0x39, 0x04, 0x8c, 0x10, 0x07, 0x9b,
+  0x5f, 0xc4, 0xec, 0x04, 0x6c, 0xe3, 0x19, 0x34, 0xd6, 0x9a, 0x3f, 0xc7,
+  0xb7, 0x6e, 0xa0, 0xa4, 0x96, 0xec, 0xfe, 0x9e, 0x2d, 0x75, 0x8d, 0x27,
+  0x50, 0x85, 0x27, 0xd3, 0xee, 0x61, 0x99, 0x58, 0x95, 0x1e, 0x5b, 0xa9,
+  0xcb, 0x01, 0x92, 0xbd, 0x73, 0xb8, 0x67, 0x91, 0xd4, 0x77, 0xab, 0x73,
+  0xc7, 0x24, 0xf6, 0xef, 0x0c, 0x32, 0x34, 0x2e, 0xe8, 0x42, 0x4a, 0xaa,
+  0x09, 0x42, 0x46, 0x03, 0x00, 0xc0, 0x83, 0x8e, 0xbc, 0x8c, 0x57, 0xe0,
+  0x7f, 0xec, 0x31, 0xf1, 0x43, 0xe2, 0xbf, 0xc4, 0x4d, 0x61, 0x4d, 0xd7,
+  0x88, 0x6c, 0x8d, 0xae, 0x93, 0x6c, 0x75, 0x1b, 0x7d, 0x3e, 0x79, 0x26,
+  0x68, 0xda, 0x72, 0xc0, 0x36, 0xff, 0x00, 0x20, 0x2c, 0x72, 0x3e, 0xcf,
+  0x2d, 0x5a, 0x35, 0x91, 0xb6, 0x02, 0xa5, 0x8e, 0xe0, 0x54, 0x7e, 0xe3,
+  0x69, 0x3e, 0x2a, 0xb2, 0xbd, 0xd2, 0x52, 0xee, 0x6b, 0xdb, 0x57, 0x30,
+  0x84, 0x82, 0xf2, 0x60, 0xe1, 0x11, 0x2e, 0x14, 0x28, 0x75, 0x70, 0x48,
+  0xd8, 0xdb, 0x8f, 0xdd, 0x6c, 0x11, 0x90, 0x31, 0x5f, 0x51, 0xc3, 0xd9,
+  0xda, 0xcc, 0x30, 0xea, 0xba, 0x8f, 0x2d, 0xfc, 0xc6, 0xa4, 0x7c, 0xdd,
+  0xab, 0x5a, 0x7c, 0x7a, 0xf0, 0x8f, 0xc5, 0xd9, 0xf5, 0xad, 0x5b, 0x59,
+  0xd3, 0xe7, 0xf0, 0xb4, 0xe8, 0xcf, 0x63, 0x14, 0x50, 0x47, 0x1d, 0xdb,
+  0x34, 0x0a, 0x64, 0x68, 0xaf, 0xa7, 0x36, 0x8c, 0xb1, 0xdb, 0x95, 0xdf,
+  0xb4, 0xa3, 0x02, 0xa5, 0x41, 0x67, 0xf9, 0x8d, 0x7e, 0x7f, 0x7c, 0x76,
+  0xfd, 0x94, 0x2c, 0xbe, 0x34, 0xf8, 0xa3, 0x58, 0x1a, 0x55, 0xf7, 0x83,
+  0xbc, 0x37, 0xa7, 0xc3, 0x73, 0x3e, 0xad, 0x61, 0xaa, 0xcd, 0x37, 0xdb,
+  0x75, 0x08, 0x66, 0x37, 0x0e, 0x62, 0x81, 0x91, 0x04, 0xb6, 0xd6, 0xf0,
+  0xbd, 0xc3, 0xef, 0x59, 0x98, 0xbb, 0x80, 0x36, 0x22, 0x46, 0x2b, 0xf4,
+  0x2f, 0xf6, 0x8c, 0xf1, 0x8f, 0xc3, 0xa6, 0xf8, 0x63, 0xff, 0x00, 0x09,
+  0xac, 0x9e, 0x1f, 0xb5, 0xf1, 0xf4, 0xd6, 0xe9, 0x25, 0xce, 0x91, 0xa7,
+  0xe9, 0xee, 0x97, 0x4d, 0x2f, 0xca, 0xd1, 0xbb, 0xa1, 0x8d, 0xff, 0x00,
+  0xd5, 0x28, 0x62, 0x24, 0x20, 0x90, 0x01, 0xe8, 0x5b, 0x68, 0x3f, 0x96,
+  0x5a, 0x5f, 0xc6, 0x9d, 0x4f, 0xc3, 0xbf, 0x11, 0xaf, 0xbc, 0x13, 0xaf,
+  0x5f, 0x68, 0xb3, 0x6a, 0x5a, 0x8d, 0x85, 0xc4, 0xde, 0x20, 0xd0, 0xf5,
+  0x9d, 0x1e, 0xcb, 0x50, 0xd3, 0xb4, 0x7b, 0x8b, 0x70, 0x4f, 0xf6, 0x78,
+  0x9e, 0x0b, 0x98, 0xcc, 0xb0, 0x46, 0xb2, 0xff, 0x00, 0xab, 0x94, 0x2c,
+  0x9b, 0xf0, 0x32, 0x5c, 0xe1, 0x3c, 0x5c, 0xf3, 0x2f, 0xc3, 0xca, 0x2a,
+  0x9e, 0x21, 0xf3, 0x45, 0xbd, 0x2e, 0xef, 0xbf, 0x9f, 0xae, 0xd6, 0x7d,
+  0x2f, 0xd0, 0x89, 0xd6, 0xb3, 0x51, 0x48, 0xfc, 0xaf, 0xf1, 0x6f, 0x85,
+  0x3e, 0x26, 0xf8, 0x29, 0xf5, 0x9d, 0x7f, 0xe2, 0x67, 0x87, 0x3e, 0x1f,
+  0xea, 0x97, 0x32, 0xdf, 0xa6, 0x87, 0x13, 0x78, 0x9a, 0x2d, 0x2b, 0x45,
+  0x7b, 0x34, 0x8e, 0xd4, 0x94, 0xbc, 0xbf, 0x97, 0x4d, 0x36, 0xf3, 0xbb,
+  0xa2, 0x97, 0x92, 0xda, 0x68, 0xcc, 0xc6, 0x79, 0x1e, 0x36, 0x85, 0x9c,
+  0x11, 0xe6, 0x7c, 0x05, 0x75, 0xa0, 0xfc, 0x5d, 0xf8, 0x69, 0x6b, 0x69,
+  0xae, 0x7c, 0x32, 0x9e, 0xd7, 0x40, 0x81, 0xae, 0xaf, 0x3f, 0xe2, 0xa6,
+  0xf0, 0xe4, 0xef, 0x1c, 0xf7, 0x70, 0x87, 0x2e, 0xf1, 0xc5, 0x75, 0x14,
+  0xbb, 0x9d, 0xb6, 0xb6, 0x7e, 0x72, 0x65, 0x88, 0x10, 0x0a, 0xed, 0xf9,
+  0x0f, 0xed, 0x1f, 0x8f, 0xbc, 0x7b, 0xa1, 0x6a, 0x77, 0xba, 0xac, 0xb0,
+  0xe9, 0x7e, 0x0c, 0xf0, 0xa6, 0xb7, 0xab, 0x44, 0xda, 0x87, 0x88, 0x75,
+  0x23, 0xa9, 0x89, 0x34, 0x8b, 0xcb, 0x1b, 0x9b, 0x7f, 0x2a, 0x44, 0xb6,
+  0x80, 0xfd, 0xa5, 0xa5, 0x8d, 0xd4, 0x79, 0x2d, 0x6d, 0xe5, 0x4b, 0x99,
+  0x5b, 0x18, 0x0c, 0x85, 0x47, 0xe6, 0xd7, 0x88, 0x3f, 0x67, 0x8d, 0x5f,
+  0xc0, 0x3f, 0x0d, 0xee, 0xbc, 0x51, 0xa9, 0xc5, 0x16, 0x91, 0xa6, 0xea,
+  0xfa, 0x95, 0xd5, 0xe6, 0x9d, 0xfd, 0xa3, 0x31, 0x17, 0xfe, 0x62, 0x4a,
+  0x13, 0x69, 0x49, 0x08, 0x9e, 0x39, 0x11, 0x5f, 0x6b, 0x27, 0x93, 0x81,
+  0xf2, 0xf3, 0xb5, 0x95, 0x8f, 0xe6, 0x3c, 0x51, 0x96, 0x62, 0x29, 0x47,
+  0xeb, 0x18, 0x77, 0xa4, 0x77, 0x7a, 0x7e, 0x37, 0xf7, 0xbb, 0x6f, 0xa1,
+  0xc5, 0x09, 0x27, 0x2b, 0x1f, 0x97, 0xff, 0x00, 0x19, 0x3c, 0x53, 0xe3,
+  0xcf, 0x89, 0x7a, 0xf4, 0xba, 0x9f, 0x8b, 0x75, 0xbb, 0xeb, 0xad, 0x52,
+  0xd6, 0xd2, 0x3b, 0x18, 0x2e, 0xf5, 0x2f, 0x32, 0x59, 0x25, 0xb5, 0x45,
+  0x2c, 0x8c, 0x92, 0x0c, 0x86, 0x4c, 0xb1, 0x1b, 0x9d, 0x83, 0x73, 0x91,
+  0xd0, 0xe3, 0xe6, 0x5b, 0xe8, 0x75, 0xbd, 0x3e, 0x76, 0x9e, 0xee, 0x63,
+  0xe7, 0x48, 0x10, 0xab, 0xa3, 0x2b, 0x11, 0x11, 0x24, 0x61, 0xe4, 0x19,
+  0x75, 0x72, 0xc0, 0x1c, 0x30, 0x07, 0xbe, 0xec, 0xd7, 0xd7, 0xde, 0x35,
+  0xf8, 0x77, 0xe2, 0x5d, 0x52, 0x57, 0xd3, 0xac, 0xe2, 0xd5, 0x2e, 0xa1,
+  0x59, 0x61, 0x37, 0x1a, 0x76, 0x9f, 0x66, 0xd3, 0xde, 0x4a, 0x65, 0x0d,
+  0x23, 0x49, 0x6b, 0x0a, 0x88, 0xde, 0x41, 0x1a, 0x00, 0xcd, 0x99, 0x0a,
+  0x81, 0x92, 0x70, 0x3a, 0x47, 0xa0, 0x7c, 0x0b, 0xf8, 0x8f, 0xe2, 0x2b,
+  0x03, 0xe2, 0x7b, 0x4b, 0x1b, 0xbf, 0xec, 0xa8, 0xae, 0xd6, 0xc3, 0x57,
+  0xbf, 0xb9, 0x8e, 0xdd, 0x05, 0x94, 0x90, 0x3a, 0x2c, 0x2d, 0x79, 0x04,
+  0x4a, 0xee, 0x8a, 0xea, 0xcb, 0x87, 0x90, 0x48, 0x1f, 0x04, 0xff, 0x00,
+  0x06, 0x6b, 0xc3, 0xc2, 0xe3, 0x6d, 0x4f, 0xda, 0xb5, 0x74, 0xf7, 0xdf,
+  0x6d, 0x3a, 0xb5, 0x7f, 0xe9, 0x5b, 0x7d, 0x07, 0x4e, 0xfb, 0x1f, 0xff,
+  0xd1, 0xf2, 0x1d, 0x3b, 0xf6, 0xc1, 0xfd, 0xa0, 0x7c, 0x67, 0x79, 0xa5,
+  0xf8, 0x59, 0x1b, 0x54, 0xd2, 0xf4, 0x37, 0x92, 0x09, 0x96, 0x3f, 0x0c,
+  0xc1, 0x71, 0xa4, 0x35, 0xe8, 0xc8, 0xda, 0x96, 0xf7, 0x16, 0xb2, 0x47,
+  0x70, 0xa1, 0xd1, 0xbf, 0xd6, 0x33, 0x95, 0x64, 0x1c, 0x44, 0xa4, 0x0c,
+  0x71, 0x7a, 0xbf, 0xc4, 0x5f, 0x81, 0x3e, 0x21, 0xbd, 0xd5, 0xfe, 0x25,
+  0x78, 0xe6, 0xe6, 0x1b, 0x3d, 0x6e, 0x4b, 0xc9, 0x8e, 0x87, 0x77, 0xe2,
+  0x2b, 0x18, 0xb5, 0x79, 0x52, 0x65, 0x89, 0xbc, 0xd8, 0xaf, 0x5b, 0x51,
+  0x37, 0x17, 0x32, 0xa3, 0x04, 0x81, 0x22, 0x73, 0x24, 0xc0, 0x21, 0x24,
+  0x85, 0x2c, 0x58, 0x7e, 0x8a, 0x7e, 0xd8, 0x5f, 0xb3, 0x97, 0xc3, 0x8f,
+  0xd9, 0x27, 0xc3, 0x5a, 0xbf, 0x89, 0x3c, 0x71, 0xa9, 0xea, 0x7a, 0x8f,
+  0x88, 0xe6, 0xbd, 0x87, 0x48, 0xf0, 0x3e, 0x8d, 0xa6, 0xeb, 0x46, 0x3b,
+  0x3b, 0x68, 0xfe, 0xf4, 0x91, 0xde, 0x5b, 0x40, 0x04, 0xea, 0xf6, 0xa9,
+  0xb5, 0x4b, 0xcc, 0x1d, 0x4b, 0x7d, 0xe4, 0x6d, 0xc0, 0x0f, 0xe7, 0x07,
+  0xe3, 0xff, 0x00, 0xc6, 0xef, 0x89, 0x5f, 0x12, 0x75, 0x9b, 0x8d, 0x0b,
+  0xc4, 0xfa, 0xc5, 0xe5, 0xec, 0x50, 0x5c, 0x7e, 0xf6, 0x2d, 0x46, 0x76,
+  0x99, 0xa1, 0x98, 0x29, 0x89, 0x84, 0x5b, 0x89, 0x2d, 0x90, 0x36, 0xf2,
+  0x03, 0x1e, 0xa4, 0x13, 0x9c, 0xff, 0x00, 0x3c, 0xcb, 0x26, 0xc4, 0x61,
+  0xe6, 0xa9, 0xce, 0x76, 0x7d, 0x52, 0x7a, 0x2e, 0xcf, 0xfc, 0x5a, 0xf9,
+  0x1e, 0x34, 0x6b, 0xf4, 0x67, 0x85, 0xf8, 0xff, 0x00, 0xc7, 0x10, 0x5c,
+  0xde, 0xdf, 0xea, 0xd7, 0xd7, 0x36, 0xda, 0x8d, 0xe5, 0xfb, 0xbd, 0xe4,
+  0x4d, 0x6c, 0x8d, 0xf6, 0x75, 0x9e, 0x49, 0x4f, 0x98, 0x36, 0x48, 0x7f,
+  0x76, 0x00, 0xc9, 0x45, 0x25, 0x89, 0xf9, 0x72, 0x15, 0x46, 0xda, 0xf9,
+  0x9f, 0xc4, 0xe7, 0x53, 0xbf, 0xd4, 0xa4, 0xb7, 0xd5, 0xad, 0x9e, 0xde,
+  0xf0, 0x49, 0x2c, 0x32, 0xdb, 0xc8, 0xac, 0x93, 0x2b, 0x8c, 0xee, 0x46,
+  0x89, 0xb0, 0xc9, 0xcf, 0x63, 0x93, 0xea, 0x4f, 0x04, 0xfb, 0x2e, 0xa4,
+  0x2e, 0xad, 0x5e, 0xea, 0xc0, 0x34, 0x46, 0xe7, 0x6b, 0xdd, 0x46, 0xb2,
+  0x28, 0x75, 0x95, 0x8b, 0x63, 0x0b, 0xb8, 0x10, 0xdd, 0xf0, 0x32, 0x72,
+  0x32, 0x4d, 0x78, 0x16, 0xa5, 0x79, 0x12, 0x6a, 0xb2, 0xdd, 0x97, 0x90,
+  0x1f, 0xb3, 0x15, 0x77, 0x2e, 0x5a, 0x43, 0x20, 0xc8, 0xce, 0xec, 0xe7,
+  0x07, 0x23, 0x39, 0xec, 0x6b, 0xeb, 0x72, 0xea, 0x09, 0x41, 0xa4, 0xb5,
+  0xfc, 0xff, 0x00, 0x23, 0x6a, 0x4e, 0xe8, 0xfa, 0x2b, 0xc3, 0x3f, 0x12,
+  0x7c, 0x61, 0xf0, 0xe2, 0xf7, 0xc3, 0x3f, 0x13, 0xbc, 0x11, 0x05, 0xe4,
+  0x5a, 0x85, 0x96, 0x74, 0xc7, 0xd5, 0x94, 0x4a, 0xaa, 0x9f, 0x6a, 0x50,
+  0xcb, 0x01, 0x9a, 0x36, 0x01, 0x24, 0x65, 0x46, 0xe0, 0x30, 0x26, 0x32,
+  0xf9, 0x04, 0x16, 0x15, 0xdf, 0x5f, 0xfc, 0x53, 0xb8, 0xf0, 0x36, 0xa3,
+  0x20, 0xf0, 0x24, 0x07, 0x52, 0xba, 0xbd, 0xb3, 0x16, 0x9a, 0xd4, 0x9a,
+  0xba, 0x4b, 0xe4, 0xc5, 0x75, 0x37, 0x37, 0x30, 0x85, 0x8a, 0xe0, 0x07,
+  0x5d, 0xdf, 0x2b, 0x06, 0x0a, 0x71, 0x94, 0x38, 0x1b, 0xc1, 0xf3, 0x0d,
+  0x7a, 0xfb, 0xc3, 0x77, 0x1e, 0x03, 0xf0, 0xee, 0x8f, 0xa4, 0xea, 0x56,
+  0xbf, 0x6b, 0x29, 0x26, 0xa1, 0x7e, 0xb1, 0xc7, 0x2c, 0x1f, 0x65, 0x96,
+  0x00, 0xe1, 0x61, 0x9d, 0x8a, 0xed, 0x9a, 0x49, 0x3e, 0x42, 0x8e, 0x87,
+  0x11, 0xa9, 0xda, 0x7b, 0x9a, 0xfb, 0x83, 0xf6, 0x6b, 0xf0, 0x6f, 0x88,
+  0x7e, 0x21, 0xfc, 0x3d, 0x83, 0xe1, 0x77, 0xc1, 0x9f, 0x02, 0xb5, 0xf7,
+  0x88, 0xa7, 0xd4, 0x2e, 0x1b, 0x58, 0xf1, 0x43, 0x42, 0x6e, 0xa5, 0x92,
+  0xc1, 0xa2, 0x48, 0x0c, 0x56, 0x2f, 0xb1, 0x3c, 0x90, 0x80, 0xc8, 0xf3,
+  0x65, 0x97, 0x74, 0x6f, 0xc9, 0x8c, 0xa9, 0x66, 0xee, 0x8e, 0x40, 0xa7,
+  0x18, 0xb4, 0xaf, 0x6f, 0xf3, 0xd2, 0xff, 0x00, 0x7e, 0x86, 0x55, 0x2b,
+  0x28, 0xb3, 0xe4, 0x2b, 0x7f, 0x88, 0x16, 0xfe, 0x2d, 0x58, 0xef, 0xfc,
+  0x55, 0x15, 0xf3, 0xcb, 0x69, 0x6d, 0x0d, 0x85, 0xb5, 0xc4, 0x13, 0xac,
+  0x41, 0x21, 0x51, 0xb4, 0xc3, 0x15, 0xba, 0x95, 0x8c, 0xa6, 0xd6, 0x60,
+  0xa1, 0x11, 0x46, 0x09, 0xdd, 0xbb, 0x9c, 0x6f, 0x7c, 0x59, 0xf1, 0xef,
+  0x87, 0xf5, 0x4f, 0x0d, 0x5a, 0xcb, 0xe1, 0x9b, 0x2d, 0x62, 0xc2, 0x7b,
+  0x56, 0x31, 0xdf, 0xa6, 0xa3, 0xe4, 0x41, 0x0a, 0x79, 0x88, 0x78, 0xb6,
+  0x58, 0xf7, 0x48, 0xcc, 0x76, 0xff, 0x00, 0xac, 0x90, 0xfc, 0xc3, 0x0b,
+  0x81, 0xb7, 0x2f, 0xf6, 0xcf, 0xc5, 0x9f, 0xd9, 0x0f, 0xc3, 0xdf, 0x06,
+  0xed, 0x64, 0x4b, 0xa8, 0xf5, 0x9b, 0x5d, 0x72, 0xfe, 0xe7, 0x4f, 0x5d,
+  0x2f, 0x43, 0xb9, 0x8d, 0x4d, 0xf5, 0x80, 0xb9, 0x24, 0xc3, 0xf6, 0xa1,
+  0x06, 0x02, 0x4b, 0x30, 0x42, 0xc9, 0x1a, 0xae, 0xe1, 0xca, 0xef, 0x76,
+  0x42, 0xb5, 0xf0, 0xff, 0x00, 0x8e, 0x7c, 0x39, 0x77, 0xac, 0x69, 0xba,
+  0x8e, 0x83, 0xe6, 0x4d, 0xa9, 0xdc, 0xdc, 0x62, 0x4d, 0x3d, 0xe4, 0xb4,
+  0x6f, 0xb7, 0x35, 0xc4, 0x2e, 0x1e, 0x37, 0x56, 0x93, 0x64, 0xe9, 0x1b,
+  0xc0, 0x4e, 0x78, 0x70, 0xe7, 0xb7, 0x71, 0xce, 0xf2, 0xe9, 0x53, 0xa8,
+  0x95, 0x45, 0x6f, 0xcb, 0xe5, 0xea, 0x61, 0x1c, 0x4a, 0x94, 0x8f, 0x0e,
+  0x9f, 0x50, 0xd2, 0x6f, 0x35, 0x54, 0xb5, 0xb1, 0x96, 0xe1, 0xed, 0x7c,
+  0xdd, 0xa8, 0xf8, 0xf2, 0x24, 0xc4, 0x85, 0x37, 0x17, 0xcb, 0xc8, 0xaa,
+  0x32, 0x76, 0x86, 0xdd, 0xdc, 0x16, 0xce, 0x38, 0x92, 0x2b, 0xbb, 0xfd,
+  0x2b, 0xc5, 0x1f, 0xf0, 0x8f, 0xdb, 0x97, 0xdf, 0x04, 0xb2, 0x05, 0x65,
+  0x9b, 0x20, 0xc9, 0x1b, 0x1c, 0x9f, 0x35, 0x48, 0xde, 0xa4, 0x00, 0x37,
+  0x2f, 0x27, 0xaa, 0xf5, 0x02, 0xba, 0x8b, 0x0f, 0x03, 0xe9, 0xb6, 0xfe,
+  0x24, 0xd3, 0x66, 0xd3, 0xc4, 0x76, 0xa8, 0xba, 0x70, 0xba, 0x9d, 0xaf,
+  0x1f, 0xe4, 0x33, 0x42, 0x5c, 0x11, 0x94, 0x0b, 0x80, 0xe0, 0x20, 0xc3,
+  0x90, 0xc4, 0xf2, 0x71, 0xb8, 0x0a, 0xd2, 0xf0, 0x4e, 0x91, 0xe3, 0x36,
+  0xf1, 0xce, 0xa7, 0xe3, 0xdd, 0x0b, 0x4e, 0x8e, 0x54, 0xd0, 0x83, 0xea,
+  0x77, 0x61, 0x63, 0x69, 0xe0, 0xb7, 0x59, 0x27, 0x58, 0x83, 0x34, 0x6d,
+  0x27, 0x28, 0x92, 0x30, 0x50, 0x1c, 0x95, 0x24, 0x00, 0xf9, 0x04, 0xe7,
+  0xdb, 0x8d, 0x04, 0xae, 0xd6, 0xc9, 0x7f, 0x5f, 0x71, 0xd5, 0xed, 0x23,
+  0xb9, 0xed, 0xfa, 0x0f, 0xc5, 0x49, 0xf5, 0xbb, 0x58, 0x6c, 0x6f, 0x63,
+  0x46, 0x95, 0xfe, 0x69, 0xa4, 0x41, 0x3b, 0xcb, 0x08, 0x25, 0x41, 0x74,
+  0x56, 0x32, 0x2a, 0xec, 0x39, 0x01, 0x97, 0x69, 0x1b, 0x8f, 0x71, 0x96,
+  0xf4, 0x56, 0xf1, 0x7f, 0x85, 0xbc, 0x27, 0x72, 0xf7, 0x36, 0xfa, 0xba,
+  0x5c, 0x45, 0x2d, 0x99, 0x69, 0x20, 0x82, 0x4f, 0xdf, 0x0b, 0x80, 0xbc,
+  0xa1, 0x73, 0x21, 0x1b, 0x33, 0x86, 0x2d, 0x9d, 0xe7, 0x90, 0x30, 0x05,
+  0x7c, 0x89, 0xe1, 0xcb, 0x2b, 0x9d, 0x63, 0xc5, 0xd7, 0x12, 0xcf, 0x35,
+  0xae, 0x9a, 0xcb, 0x25, 0xd3, 0xc7, 0x01, 0x42, 0xb0, 0xab, 0x96, 0xda,
+  0x61, 0xb7, 0x89, 0xd9, 0xf2, 0x08, 0x77, 0x0a, 0x0e, 0xe2, 0x0e, 0x39,
+  0xcf, 0x23, 0xbe, 0xb6, 0xb9, 0xb6, 0xf8, 0x57, 0xe3, 0xbd, 0x33, 0x5b,
+  0xf0, 0xfc, 0xf6, 0x3a, 0x9c, 0xb0, 0x5a, 0xc1, 0xa9, 0xc8, 0xf0, 0x44,
+  0xb2, 0xc5, 0x0d, 0xc3, 0xe5, 0xbc, 0x96, 0x59, 0xd3, 0x6c, 0xad, 0x17,
+  0x01, 0xf7, 0x26, 0xd2, 0xe0, 0xa8, 0xdc, 0x06, 0xe6, 0xf0, 0xeb, 0x65,
+  0x34, 0xe4, 0xd4, 0xb6, 0xf4, 0x32, 0x9c, 0x93, 0xd8, 0xfa, 0x7b, 0xc0,
+  0xda, 0xef, 0xc4, 0x2d, 0x72, 0x39, 0x7c, 0x47, 0xa7, 0xc4, 0xfb, 0x44,
+  0x4d, 0x2d, 0xbc, 0x32, 0xb2, 0x19, 0x2e, 0x25, 0x42, 0xb9, 0x58, 0x23,
+  0x6d, 0xf2, 0xbc, 0xdb, 0x5b, 0x12, 0x6d, 0x1d, 0x08, 0xc9, 0xe4, 0x57,
+  0xba, 0xe9, 0x5f, 0x16, 0x6f, 0xfc, 0x2d, 0x75, 0x0b, 0x36, 0xb7, 0x04,
+  0x76, 0xf7, 0x76, 0x91, 0xb5, 0xe6, 0x9d, 0x6d, 0x6d, 0x0b, 0x18, 0x7c,
+  0xf2, 0x41, 0xf3, 0xa3, 0x91, 0xc0, 0x57, 0x3b, 0x4f, 0x98, 0xac, 0xa3,
+  0x67, 0x1c, 0xe0, 0x8c, 0xf8, 0x2c, 0x1e, 0x3c, 0xd2, 0x7c, 0x57, 0xa6,
+  0xc9, 0x7a, 0xe9, 0x34, 0x5a, 0xb3, 0x83, 0x2e, 0x9d, 0xa8, 0xbc, 0xc9,
+  0x0d, 0xa3, 0x5e, 0x33, 0x00, 0xf2, 0xcf, 0x12, 0x44, 0x1d, 0x4e, 0xc6,
+  0xf2, 0xf6, 0x46, 0x4a, 0x65, 0x83, 0x9e, 0x71, 0x9f, 0x18, 0xf1, 0x24,
+  0x5a, 0x37, 0x8a, 0x35, 0x14, 0xd5, 0xec, 0xee, 0x64, 0x82, 0xfe, 0xeb,
+  0x55, 0x30, 0xde, 0xda, 0xc3, 0x1a, 0x49, 0x1c, 0x50, 0x95, 0xc3, 0xcc,
+  0x6e, 0x73, 0xf3, 0x33, 0xee, 0x39, 0xf9, 0x14, 0x00, 0x37, 0x64, 0xe7,
+  0x03, 0x87, 0x13, 0x93, 0xe1, 0xea, 0xa6, 0xe5, 0xa3, 0x31, 0xb3, 0xe8,
+  0x7e, 0xb1, 0x78, 0x23, 0xc5, 0x1e, 0x0c, 0xf1, 0x2d, 0xb4, 0x56, 0x5e,
+  0x1e, 0xbf, 0xb2, 0x99, 0x66, 0x8d, 0x12, 0xe2, 0x78, 0x2d, 0x52, 0xd4,
+  0x4b, 0x22, 0xee, 0x06, 0x26, 0x02, 0x46, 0x5e, 0x37, 0x2b, 0xab, 0x85,
+  0x25, 0x5f, 0xd4, 0x61, 0x8f, 0xea, 0x87, 0xec, 0x6d, 0xaf, 0xdf, 0xfc,
+  0x3a, 0xf8, 0xd3, 0xe1, 0xad, 0x5f, 0xc2, 0x3f, 0xda, 0xfa, 0xdf, 0xf6,
+  0x56, 0x04, 0xf6, 0x50, 0xe9, 0x7e, 0x64, 0xf7, 0x20, 0x33, 0x35, 0xc5,
+  0xb5, 0xa2, 0x36, 0xe5, 0x39, 0x65, 0x3b, 0x19, 0x5a, 0x32, 0x4e, 0xd6,
+  0x1d, 0x48, 0xaf, 0xe7, 0x33, 0xc3, 0x5e, 0x0f, 0x6f, 0x0c, 0xeb, 0xd1,
+  0xf8, 0xef, 0xc1, 0xb6, 0x72, 0x1b, 0x7b, 0x49, 0x9e, 0x6b, 0x67, 0xb5,
+  0x94, 0xcb, 0x22, 0xc6, 0x08, 0x50, 0xd2, 0x21, 0x18, 0x93, 0x60, 0x26,
+  0x47, 0x2c, 0x01, 0xc0, 0x66, 0xda, 0x14, 0x01, 0x5f, 0xbc, 0xff, 0x00,
+  0xb2, 0x6f, 0xc4, 0xbf, 0x82, 0x7e, 0x0a, 0xf0, 0xde, 0x99, 0xe3, 0xad,
+  0x62, 0xf3, 0x5c, 0xbb, 0xd4, 0x6c, 0x0c, 0x76, 0x92, 0xf8, 0x77, 0x53,
+  0xbb, 0xbe, 0x86, 0x3b, 0x9b, 0x88, 0x16, 0x39, 0x5a, 0x4b, 0x29, 0xec,
+  0x60, 0x11, 0xc3, 0x20, 0x72, 0x16, 0x23, 0x3c, 0xae, 0x00, 0x20, 0xba,
+  0xa7, 0xcb, 0x9f, 0x3b, 0x01, 0x93, 0x38, 0xe2, 0x23, 0x3f, 0x6f, 0xcb,
+  0x15, 0xae, 0xba, 0x3d, 0x1d, 0xf4, 0xd5, 0xef, 0xd9, 0xd9, 0xdc, 0xcb,
+  0xda, 0xeb, 0x67, 0xd0, 0xfe, 0xbd, 0x7e, 0x18, 0xfc, 0x59, 0x5f, 0x1c,
+  0x78, 0x5b, 0x4f, 0xd5, 0x7c, 0x59, 0xa7, 0xcb, 0xe1, 0x8d, 0x53, 0x50,
+  0x86, 0x4b, 0xa4, 0xd0, 0xf5, 0x72, 0xb6, 0xf7, 0x4b, 0x12, 0xb6, 0x01,
+  0x11, 0xbb, 0x07, 0x6d, 0xa0, 0xa8, 0x73, 0xb4, 0x0d, 0xdd, 0x3e, 0x5c,
+  0x13, 0xf2, 0x47, 0xed, 0xb1, 0xfb, 0x6b, 0xe9, 0xff, 0x00, 0xb2, 0xe5,
+  0xc6, 0x8f, 0xa3, 0x4b, 0x1d, 0xb4, 0xff, 0x00, 0xf0, 0x91, 0x5b, 0x5c,
+  0xc3, 0x15, 0xe4, 0x37, 0x0a, 0xd3, 0x69, 0xf7, 0x20, 0x06, 0xb7, 0x96,
+  0x68, 0x70, 0xdf, 0xe8, 0xf2, 0x28, 0x71, 0xbf, 0xbb, 0x0c, 0x0e, 0x86,
+  0xbf, 0x0d, 0x7f, 0x6a, 0x3f, 0xda, 0x7b, 0x53, 0xf1, 0x4f, 0xc3, 0x4b,
+  0xc7, 0xd0, 0xae, 0xef, 0xac, 0xbf, 0xb2, 0xbc, 0xef, 0xec, 0x2b, 0x9b,
+  0x6b, 0xd9, 0x2e, 0xef, 0xed, 0x11, 0x2e, 0x8c, 0xeb, 0xf6, 0xa7, 0x9a,
+  0x56, 0x92, 0x59, 0x90, 0x14, 0x89, 0xcb, 0x37, 0xfa, 0xb5, 0x1c, 0x96,
+  0xc9, 0xaf, 0xcc, 0xed, 0x4b, 0xf6, 0x9d, 0xd4, 0xee, 0x34, 0xbb, 0x1f,
+  0x8a, 0x3f, 0x1b, 0xae, 0x6f, 0x6e, 0x6e, 0x61, 0xb3, 0xfb, 0x13, 0xde,
+  0x4b, 0x70, 0xc8, 0x26, 0xdc, 0x02, 0x46, 0xe0, 0xb9, 0x69, 0x19, 0x44,
+  0x00, 0x65, 0x1f, 0xca, 0x0b, 0xcf, 0x04, 0xe0, 0xd7, 0xd5, 0xe7, 0xbc,
+  0x77, 0x51, 0x50, 0x9d, 0x1c, 0x12, 0xe6, 0x93, 0x49, 0x29, 0x27, 0xae,
+  0xab, 0xb5, 0xb7, 0xfc, 0xb7, 0xb2, 0x3a, 0x3e, 0xb3, 0x76, 0xa2, 0x7d,
+  0x9b, 0xe2, 0x8d, 0x52, 0x6f, 0xda, 0x17, 0xc4, 0x17, 0xbe, 0x39, 0xb0,
+  0xf1, 0x3e, 0xa3, 0x73, 0x74, 0xda, 0x83, 0x6a, 0x17, 0x92, 0xdc, 0xc9,
+  0x18, 0x45, 0x8d, 0xe7, 0x69, 0x4d, 0xa4, 0x53, 0x26, 0xed, 0xb0, 0x06,
+  0x24, 0xa9, 0x18, 0xc0, 0x1d, 0x0e, 0x45, 0x78, 0x56, 0xb3, 0xf1, 0xd7,
+  0x52, 0xf8, 0x5f, 0x76, 0xfa, 0x7d, 0xf4, 0xf7, 0xa9, 0xa6, 0xda, 0xa0,
+  0x9e, 0x14, 0xfb, 0x47, 0x9d, 0x77, 0x79, 0x21, 0x2d, 0xbd, 0x1f, 0x80,
+  0xbc, 0x11, 0xc3, 0x60, 0xe4, 0x11, 0xca, 0x90, 0x48, 0xf0, 0x6b, 0x6f,
+  0x8c, 0x1a, 0x4e, 0x87, 0xa3, 0x3f, 0x89, 0x34, 0x5b, 0xb7, 0x8a, 0x2b,
+  0xa7, 0x37, 0x33, 0xc7, 0x6f, 0x37, 0x97, 0xb6, 0x29, 0x57, 0x69, 0xf2,
+  0xf6, 0xb1, 0x2a, 0xbb, 0x18, 0x3f, 0xcd, 0xf3, 0x73, 0xc0, 0x03, 0x04,
+  0x7c, 0xe1, 0xfb, 0x40, 0x7c, 0x4e, 0xd0, 0x26, 0xf0, 0xe8, 0x16, 0xfa,
+  0xb4, 0xd7, 0x92, 0x37, 0xef, 0xe7, 0x9c, 0xce, 0x43, 0xc7, 0x1c, 0x8a,
+  0x07, 0x94, 0x9b, 0x24, 0x00, 0x29, 0x18, 0x57, 0x38, 0xce, 0x08, 0xc8,
+  0x23, 0xa7, 0xe0, 0xd1, 0xc0, 0xe2, 0x71, 0xb5, 0x9c, 0x2b, 0xbe, 0x64,
+  0xde, 0xfb, 0xbf, 0xbd, 0x7f, 0x5a, 0xf7, 0xd4, 0xdb, 0x9a, 0x2a, 0xdc,
+  0xba, 0x33, 0xd3, 0xfc, 0x75, 0xfb, 0x79, 0x68, 0xfa, 0xd1, 0xbc, 0xd2,
+  0xb4, 0x87, 0xd5, 0x2d, 0xee, 0xe5, 0x50, 0xf7, 0x16, 0x7f, 0xbd, 0x0b,
+  0x32, 0x4b, 0x8c, 0x89, 0x06, 0xf6, 0x03, 0x19, 0xf9, 0xf0, 0xac, 0x73,
+  0x93, 0xce, 0xd0, 0x2b, 0xe4, 0x0f, 0x0d, 0x7e, 0xd4, 0x17, 0x9a, 0x07,
+  0x8d, 0xe3, 0xb7, 0xb5, 0xb2, 0x4d, 0x02, 0xe1, 0x2f, 0x3c, 0xc8, 0xa5,
+  0xf2, 0x16, 0xe2, 0xe4, 0x2b, 0x11, 0x90, 0x5e, 0x76, 0x40, 0xbb, 0x9b,
+  0x6b, 0x72, 0x47, 0x04, 0x60, 0xed, 0xe2, 0xbe, 0x27, 0xf1, 0x87, 0x8b,
+  0x56, 0xeb, 0x5e, 0xb9, 0xd3, 0x74, 0x19, 0xa1, 0xb5, 0x12, 0x49, 0xf2,
+  0x30, 0x91, 0xc2, 0x65, 0x06, 0x14, 0x92, 0x77, 0x31, 0x04, 0x12, 0x47,
+  0xd3, 0xa7, 0x27, 0x35, 0x6c, 0xad, 0x7e, 0xdf, 0x30, 0xd6, 0x3c, 0x50,
+  0xf3, 0x8b, 0x79, 0x16, 0x4b, 0x88, 0x2e, 0x6d, 0xe4, 0x0c, 0xeb, 0x2a,
+  0xe1, 0x46, 0x51, 0xcb, 0x00, 0x09, 0x20, 0x00, 0x40, 0x1b, 0x78, 0x07,
+  0x18, 0xaf, 0xbd, 0xcb, 0xf8, 0x57, 0x0d, 0x41, 0x49, 0xa4, 0xf6, 0xea,
+  0xdd, 0xef, 0xe5, 0xfd, 0x32, 0x64, 0xa4, 0xde, 0xa7, 0xee, 0xae, 0x8d,
+  0xfb, 0x56, 0x1f, 0x11, 0x78, 0xe2, 0xca, 0x3b, 0xad, 0x6f, 0x54, 0xb6,
+  0x55, 0xf2, 0x5f, 0x50, 0xd5, 0xa3, 0x53, 0x23, 0x5b, 0x5b, 0x38, 0x48,
+  0xe7, 0x79, 0x22, 0x88, 0x86, 0x96, 0x1d, 0xfb, 0x8a, 0xc4, 0xe7, 0x6a,
+  0x80, 0x15, 0x48, 0x6c, 0x9a, 0xc6, 0xf8, 0xc3, 0xf1, 0x67, 0xc0, 0xfe,
+  0x2f, 0x7d, 0x37, 0x4f, 0x9a, 0xfa, 0xce, 0x5b, 0x1d, 0x1a, 0x25, 0xb0,
+  0xb4, 0x1a, 0x5e, 0xeb, 0x54, 0x90, 0x5a, 0x33, 0x94, 0x99, 0xe0, 0x00,
+  0x28, 0x92, 0x61, 0xb4, 0xc9, 0xb4, 0x97, 0x60, 0x76, 0xe7, 0x03, 0x35,
+  0xf8, 0xd5, 0xa2, 0x78, 0xd3, 0x58, 0xd2, 0x96, 0x28, 0xad, 0x6e, 0x36,
+  0x9b, 0xc2, 0xb1, 0xb2, 0xce, 0x44, 0x1e, 0x58, 0x90, 0x7c, 0xa1, 0xe4,
+  0x04, 0x06, 0x0c, 0xaa, 0x77, 0x7c, 0xa0, 0x7c, 0xa3, 0x8e, 0x95, 0xf4,
+  0xe7, 0xc0, 0xdb, 0x4f, 0x0e, 0x7c, 0x45, 0x87, 0x54, 0xb3, 0xd7, 0x64,
+  0x8a, 0xce, 0x48, 0x20, 0x9a, 0xdc, 0xdd, 0xea, 0x31, 0xca, 0xad, 0x1d,
+  0xc0, 0x06, 0x28, 0xad, 0xc2, 0x96, 0x76, 0x32, 0x6e, 0x2a, 0xc1, 0xc6,
+  0xd4, 0x04, 0x10, 0x54, 0x92, 0x2b, 0xcf, 0xc4, 0xe5, 0x3e, 0xcd, 0x73,
+  0xb9, 0xf2, 0xc7, 0xab, 0xff, 0x00, 0x81, 0xfd, 0x3e, 0xdd, 0x89, 0xe4,
+  0x67, 0xec, 0x5f, 0xc2, 0x2f, 0xf8, 0x28, 0x00, 0xf8, 0x5b, 0x69, 0x37,
+  0x80, 0x7c, 0x12, 0x6d, 0x74, 0xf4, 0x96, 0xe1, 0x26, 0x7b, 0xc6, 0x55,
+  0x69, 0xa2, 0x5c, 0xf2, 0xb6, 0xf2, 0x46, 0x54, 0x21, 0x7c, 0xb1, 0xdd,
+  0xb7, 0x78, 0x18, 0x42, 0xc7, 0x35, 0xea, 0x7e, 0x23, 0xfd, 0xa9, 0xfe,
+  0x30, 0xda, 0xdc, 0xdf, 0xf8, 0x8f, 0x4f, 0xf1, 0x75, 0xe5, 0xdb, 0x6b,
+  0xf0, 0x99, 0xbc, 0x45, 0x66, 0x2f, 0x1a, 0x33, 0x72, 0x62, 0x54, 0x68,
+  0xe5, 0x6d, 0x8c, 0x32, 0xa0, 0x2a, 0x8d, 0xa8, 0x43, 0xee, 0x52, 0x55,
+  0x81, 0x2d, 0x5f, 0x81, 0xff, 0x00, 0x10, 0x7e, 0x1e, 0xf8, 0xcf, 0xe0,
+  0x7b, 0x36, 0xa7, 0xa6, 0xa5, 0xed, 0xf5, 0x92, 0x42, 0xb1, 0x5d, 0x5f,
+  0xc6, 0x64, 0x56, 0x85, 0x83, 0x04, 0x0d, 0x95, 0x2c, 0x0c, 0x6d, 0x9c,
+  0x8e, 0x71, 0x82, 0x47, 0x5a, 0xe4, 0x34, 0x7f, 0x8b, 0x9a, 0x8d, 0x84,
+  0xd1, 0x26, 0xa6, 0x97, 0x88, 0x66, 0x52, 0xb6, 0x9b, 0xc3, 0x42, 0x8e,
+  0xe9, 0xd5, 0xc3, 0x93, 0x86, 0x65, 0xc8, 0x07, 0x8e, 0x3b, 0xf6, 0xae,
+  0x3a, 0x38, 0x5c, 0x54, 0x9c, 0x65, 0x85, 0xc4, 0xb7, 0x05, 0x7d, 0x9b,
+  0xb5, 0xfa, 0xe9, 0x75, 0x67, 0xbf, 0xc9, 0x8e, 0x53, 0x76, 0x3f, 0x72,
+  0x1f, 0xf6, 0xc8, 0xf8, 0x89, 0x67, 0x70, 0xbe, 0x06, 0xf0, 0x36, 0xad,
+  0x3d, 0x8d, 0xc5, 0xd5, 0xbf, 0xf6, 0x4c, 0x52, 0x48, 0x76, 0x39, 0x5b,
+  0x80, 0xc0, 0xc0, 0x5a, 0x63, 0x29, 0x8a, 0x36, 0x66, 0x2a, 0xc2, 0x27,
+  0x53, 0x28, 0x20, 0x1e, 0x82, 0xbb, 0x0f, 0x82, 0x1f, 0x16, 0x7c, 0x1f,
+  0xe3, 0xad, 0x2f, 0x58, 0x1f, 0x11, 0xae, 0x7f, 0xb6, 0x3c, 0x40, 0xd2,
+  0x45, 0x69, 0xa4, 0x69, 0x70, 0x49, 0x79, 0x1d, 0xa5, 0xe6, 0x56, 0xde,
+  0x02, 0xf3, 0xc4, 0xd2, 0xa1, 0x90, 0xe4, 0x39, 0x25, 0x1d, 0x59, 0x9a,
+  0x21, 0xf2, 0xe3, 0x0c, 0xbf, 0x82, 0x1a, 0x47, 0xc5, 0xcf, 0x15, 0x78,
+  0x8f, 0x5f, 0x93, 0x4c, 0xf0, 0xcd, 0xcb, 0x4f, 0x70, 0x1f, 0x6b, 0x49,
+  0x72, 0xc8, 0x1e, 0x29, 0x94, 0x73, 0x92, 0x5b, 0x20, 0x83, 0x81, 0xd3,
+  0x21, 0xb3, 0x8c, 0xf5, 0xaf, 0xe8, 0x27, 0xf6, 0x0b, 0xfd, 0x83, 0xfc,
+  0x4e, 0xda, 0xd7, 0x86, 0x6e, 0xfc, 0x41, 0xe2, 0x5f, 0x0d, 0xe9, 0x3e,
+  0x36, 0x96, 0xfa, 0xdf, 0xc4, 0x76, 0x5a, 0x6e, 0xa9, 0x75, 0xe4, 0xf9,
+  0x96, 0xca, 0xd1, 0xbc, 0x2e, 0x8d, 0xf6, 0x79, 0x09, 0xdb, 0x0b, 0x8b,
+  0x9d, 0x92, 0x15, 0xdd, 0x88, 0xc4, 0x61, 0x8b, 0x19, 0x57, 0xed, 0x72,
+  0x7c, 0x36, 0x31, 0xb5, 0x4e, 0xb4, 0xae, 0xb4, 0x56, 0x6e, 0xfb, 0xed,
+  0xbf, 0xe1, 0xf7, 0x9c, 0x2d, 0xbb, 0xec, 0x7e, 0xb9, 0x7c, 0x1e, 0xfd,
+  0x9f, 0xff, 0x00, 0x65, 0x7f, 0x86, 0xde, 0x24, 0xd2, 0x3c, 0x6f, 0xfb,
+  0x4d, 0xcd, 0xa6, 0x5b, 0x5d, 0x78, 0x8e, 0xc1, 0x0e, 0x99, 0xab, 0x34,
+  0x4b, 0x77, 0xa1, 0xca, 0x6f, 0xad, 0x9a, 0x48, 0xa4, 0x8e, 0xfa, 0xe2,
+  0xea, 0xe6, 0x06, 0x09, 0x0c, 0x86, 0x21, 0xf6, 0xab, 0x76, 0x53, 0xf2,
+  0x48, 0x0e, 0xf6, 0x04, 0x7d, 0xb9, 0x65, 0xfb, 0x16, 0x7c, 0x3b, 0x79,
+  0xa3, 0x99, 0x74, 0x3f, 0x09, 0x6a, 0x9a, 0x44, 0x3a, 0xa5, 0xac, 0xda,
+  0x24, 0x90, 0xc7, 0x35, 0xac, 0x56, 0xba, 0x7c, 0xd3, 0x89, 0x6e, 0x25,
+  0x8a, 0x28, 0x65, 0x74, 0x6b, 0xa3, 0x21, 0x25, 0x4e, 0x23, 0x86, 0x2e,
+  0x4c, 0x48, 0x09, 0x20, 0xfc, 0xdd, 0xfb, 0x44, 0xfc, 0x65, 0xf8, 0x21,
+  0xe1, 0xbd, 0x0a, 0x3f, 0x00, 0x69, 0x1e, 0x09, 0xd3, 0xaf, 0xa7, 0xb3,
+  0x81, 0xb4, 0x7b, 0x96, 0x36, 0x4d, 0x6b, 0x6d, 0x6f, 0x77, 0x6d, 0xbb,
+  0xce, 0x5b, 0x6b, 0x29, 0x59, 0x8c, 0x31, 0x3e, 0xf6, 0x7d, 0x8c, 0x15,
+  0xd9, 0x64, 0x52, 0x72, 0xbf, 0x35, 0x7a, 0x67, 0xec, 0xe5, 0xfb, 0x59,
+  0xf8, 0x32, 0xd7, 0x5e, 0x97, 0xc3, 0x13, 0x98, 0x62, 0x8e, 0x41, 0x25,
+  0xdc, 0x49, 0x1c, 0xa1, 0x96, 0xc2, 0xd1, 0x44, 0xb3, 0x6c, 0x32, 0x10,
+  0xa1, 0xce, 0xf3, 0xf3, 0x31, 0x27, 0x73, 0x12, 0xc4, 0x92, 0x4d, 0x7e,
+  0x99, 0x82, 0xa9, 0x83, 0xa7, 0x27, 0x84, 0xa9, 0x6e, 0x57, 0xe5, 0xa5,
+  0xdf, 0x47, 0x7d, 0x19, 0xd4, 0xf4, 0xd9, 0x1e, 0xdb, 0xfb, 0x53, 0xfe,
+  0xcb, 0x9f, 0xb2, 0x8e, 0xae, 0xde, 0x19, 0xd7, 0x7c, 0x49, 0x6b, 0x6b,
+  0xa1, 0x6a, 0xf6, 0x97, 0xad, 0xa4, 0xf8, 0x63, 0xfb, 0x17, 0x4f, 0xb4,
+  0x37, 0x13, 0xcc, 0xd6, 0xec, 0xe9, 0x64, 0x8b, 0xe5, 0xab, 0x79, 0x40,
+  0x44, 0xcf, 0x85, 0x91, 0x3e, 0x63, 0xcb, 0xe0, 0x85, 0xaf, 0xe7, 0x0f,
+  0xc6, 0x5f, 0xb4, 0x37, 0xc2, 0xaf, 0x85, 0x5e, 0x17, 0xbd, 0xf8, 0x71,
+  0xf0, 0xae, 0xd1, 0x2e, 0x74, 0xdd, 0x0b, 0x5a, 0xbe, 0x09, 0xa8, 0x6a,
+  0x31, 0xc6, 0x9a, 0x7e, 0xa1, 0x75, 0x23, 0xb2, 0xcf, 0x6f, 0xa9, 0xc1,
+  0x2b, 0x5c, 0x49, 0x34, 0x50, 0x44, 0x86, 0x18, 0xe3, 0x8c, 0x34, 0x6a,
+  0xad, 0xb8, 0x0d, 0xee, 0x09, 0xfd, 0xb6, 0xfd, 0xb8, 0xe6, 0xf0, 0x0f,
+  0xc6, 0xbb, 0xad, 0x20, 0xe8, 0xd2, 0xe9, 0x33, 0x6a, 0x3a, 0x6a, 0xdb,
+  0x46, 0x2e, 0x75, 0x3b, 0xa8, 0x55, 0x21, 0x17, 0x8c, 0x5c, 0x88, 0xe3,
+  0x2b, 0x2a, 0xf9, 0x8a, 0x8b, 0x99, 0x4b, 0x23, 0x2a, 0xa9, 0x1c, 0x1c,
+  0xf3, 0xf2, 0x1f, 0xc4, 0x4f, 0xd8, 0xde, 0xcb, 0xe2, 0xa7, 0x8c, 0xb4,
+  0x0f, 0x0a, 0xdd, 0x0f, 0x04, 0x78, 0xb2, 0xcc, 0xde, 0x41, 0x26, 0xbb,
+  0xa8, 0xf8, 0x6a, 0xc5, 0x77, 0x43, 0x0a, 0x4e, 0xed, 0xb5, 0xd1, 0x64,
+  0xc4, 0x02, 0x28, 0xd4, 0x15, 0x78, 0xd3, 0x05, 0xe5, 0x29, 0x8c, 0x63,
+  0x3f, 0x1d, 0xc5, 0xb9, 0x74, 0xf1, 0x15, 0xa7, 0x47, 0x08, 0x94, 0x6d,
+  0x65, 0x75, 0xd5, 0x3b, 0x2b, 0x7e, 0x1d, 0x17, 0x4f, 0x93, 0xe8, 0x73,
+  0xfb, 0x49, 0x1f, 0xff, 0xd2, 0xe4, 0xff, 0x00, 0x6b, 0xaf, 0x89, 0xbe,
+  0x00, 0xf8, 0xb3, 0xf1, 0x63, 0x5c, 0xf1, 0x04, 0x2d, 0x71, 0xa9, 0x6a,
+  0x3f, 0x64, 0x8e, 0x48, 0xae, 0x7c, 0x42, 0x2d, 0x91, 0xae, 0x2e, 0xc3,
+  0x30, 0x90, 0xd9, 0x08, 0x56, 0x18, 0xa4, 0x0e, 0xb9, 0x1b, 0xd5, 0x19,
+  0x82, 0x20, 0x01, 0xb9, 0x3b, 0xff, 0x00, 0x02, 0x7e, 0x20, 0x4c, 0xf7,
+  0x3e, 0x2b, 0xba, 0x87, 0x57, 0xd3, 0xae, 0xb4, 0xf9, 0x52, 0x79, 0x3c,
+  0xc9, 0x8a, 0x2b, 0x1c, 0xee, 0x63, 0x82, 0x54, 0x92, 0xc0, 0x9c, 0xe0,
+  0x85, 0xc6, 0x39, 0xe7, 0x9a, 0xfb, 0x4f, 0x58, 0xf1, 0x6f, 0xc5, 0x2f,
+  0x15, 0xfc, 0x65, 0xd2, 0xa5, 0xd2, 0x6c, 0xae, 0x6f, 0x2c, 0x2d, 0x7c,
+  0x3f, 0xe6, 0x5d, 0x08, 0x2e, 0x55, 0x7e, 0xce, 0xec, 0x76, 0x82, 0xc3,
+  0x0c, 0xb2, 0x14, 0x6d, 0xa4, 0x6d, 0x0c, 0x77, 0x6d, 0x23, 0x07, 0x91,
+  0xe1, 0x5f, 0x10, 0xd0, 0xcb, 0xab, 0xdf, 0x6a, 0xfa, 0x81, 0x2a, 0x63,
+  0x7e, 0x21, 0x96, 0x45, 0x95, 0x88, 0x2b, 0xf7, 0x9b, 0x78, 0x40, 0x76,
+  0x82, 0xd8, 0x04, 0x1c, 0x9e, 0xbc, 0x12, 0x2b, 0xf1, 0x29, 0x51, 0xf6,
+  0x78, 0xa9, 0x37, 0x24, 0xef, 0xae, 0xfd, 0x5f, 0xf9, 0x9f, 0x2b, 0x4e,
+  0xbd, 0xdd, 0xd9, 0xe0, 0xde, 0x21, 0xbb, 0xd3, 0xf5, 0x1b, 0x07, 0xbd,
+  0xd4, 0x9a, 0x65, 0xb9, 0x65, 0x21, 0x8c, 0x65, 0x0b, 0x47, 0xe5, 0x2e,
+  0xf5, 0x08, 0xc7, 0x27, 0x3c, 0x82, 0xd8, 0x18, 0xe4, 0xf4, 0x35, 0xf3,
+  0xa7, 0x8a, 0xe6, 0xb7, 0x91, 0x63, 0xd4, 0x60, 0xc0, 0x9c, 0x81, 0x6e,
+  0x41, 0x50, 0x9b, 0x97, 0x69, 0xc3, 0x95, 0xc6, 0x33, 0xb9, 0x79, 0xed,
+  0xfc, 0xab, 0xd9, 0x7c, 0x77, 0xa9, 0xc1, 0xa7, 0x59, 0x79, 0x2a, 0xa1,
+  0x1f, 0x6a, 0xab, 0x13, 0xb3, 0xf7, 0xa5, 0x41, 0x32, 0x00, 0x8a, 0x3a,
+  0x65, 0x82, 0xee, 0x04, 0xe7, 0x9e, 0xd9, 0xcf, 0xcf, 0x3e, 0x27, 0xd4,
+  0x2c, 0xaf, 0xac, 0xa3, 0xd4, 0xad, 0x14, 0xa2, 0xab, 0xaa, 0x79, 0x51,
+  0xf3, 0xb7, 0x0c, 0x33, 0x19, 0xc0, 0x1d, 0x49, 0xe3, 0x9e, 0x87, 0xeb,
+  0x5f, 0x4d, 0x96, 0x51, 0xd1, 0x3b, 0x1e, 0xce, 0x19, 0x5c, 0xa7, 0xe1,
+  0x8b, 0xe8, 0x66, 0xd7, 0xae, 0xa4, 0x63, 0x70, 0x60, 0x41, 0x2c, 0x8c,
+  0x91, 0x03, 0xb0, 0x0d, 0xb9, 0x70, 0x54, 0x8c, 0x94, 0x5c, 0x1e, 0x73,
+  0xd1, 0x47, 0xbe, 0x3f, 0x72, 0x7f, 0x64, 0xcf, 0xf8, 0x29, 0xe4, 0xdf,
+  0xb1, 0x7e, 0x91, 0x6d, 0xe1, 0x9f, 0x84, 0x1e, 0x1e, 0xf0, 0x54, 0xe0,
+  0x2c, 0xb6, 0xf7, 0x57, 0x9e, 0x25, 0xb0, 0x8f, 0x52, 0x6b, 0xc8, 0xae,
+  0x6d, 0xe2, 0x49, 0xa3, 0x9a, 0xe8, 0x6c, 0x63, 0x02, 0xcb, 0x1b, 0xcb,
+  0x1c, 0x0a, 0x87, 0x97, 0xe7, 0x79, 0x45, 0xcf, 0xe0, 0x16, 0x9b, 0x7e,
+  0xb1, 0x5f, 0xdd, 0x99, 0xc1, 0x8f, 0xcc, 0x12, 0x0b, 0x72, 0x49, 0xc9,
+  0x1f, 0x31, 0x2d, 0xd7, 0x19, 0x39, 0xf4, 0xe3, 0xa5, 0x6e, 0xeb, 0x5e,
+  0x22, 0xbb, 0xb4, 0x91, 0xec, 0xa6, 0xb7, 0xf3, 0x6d, 0xc2, 0xc4, 0x02,
+  0x09, 0x36, 0x36, 0x4a, 0x67, 0x80, 0x70, 0x72, 0x71, 0x8c, 0xe7, 0x8e,
+  0xb8, 0xed, 0x5e, 0xb4, 0xa1, 0x5a, 0xef, 0xd9, 0xc9, 0xa2, 0x31, 0x34,
+  0x6f, 0x2b, 0xa3, 0xf5, 0x1f, 0xe3, 0xa7, 0xed, 0x79, 0xe3, 0xaf, 0x8c,
+  0x9e, 0x23, 0xbf, 0xf1, 0xd5, 0xe9, 0xb7, 0xb0, 0x92, 0xf3, 0x57, 0x93,
+  0x55, 0xd5, 0xac, 0x6c, 0x65, 0x79, 0x20, 0xba, 0xba, 0x32, 0xbb, 0x6f,
+  0x0f, 0x21, 0xf3, 0x3e, 0xcc, 0x80, 0x81, 0x1c, 0x25, 0x98, 0x27, 0x5e,
+  0xa4, 0xd7, 0x39, 0x3f, 0x8e, 0xac, 0xfc, 0x63, 0xe0, 0xb8, 0xee, 0xfc,
+  0x4b, 0x2d, 0xb4, 0x9a, 0xad, 0xbd, 0x8c, 0xf6, 0xd1, 0x5c, 0xdc, 0xbc,
+  0xaf, 0x74, 0xb0, 0x84, 0x41, 0x6c, 0xf1, 0x16, 0x65, 0x84, 0x88, 0xc8,
+  0xd9, 0xe5, 0xe0, 0x6d, 0x8d, 0xc9, 0x5d, 0xc4, 0x2a, 0xc7, 0xf9, 0xa1,
+  0x6b, 0xe3, 0x4f, 0x10, 0xf9, 0x10, 0x59, 0x69, 0xab, 0x38, 0xb6, 0x95,
+  0xc2, 0xdc, 0xdb, 0x4b, 0x23, 0x1d, 0x80, 0x71, 0xf2, 0xbf, 0x42, 0xb8,
+  0x63, 0xc1, 0xf4, 0xe4, 0x73, 0x5e, 0xfb, 0xe1, 0x8f, 0x14, 0x6a, 0x9a,
+  0x0d, 0xdc, 0x77, 0x9e, 0x1d, 0x92, 0xed, 0x2f, 0x23, 0x40, 0xa1, 0xed,
+  0xa5, 0x68, 0x56, 0x38, 0xd8, 0x61, 0x9f, 0x7a, 0x10, 0x70, 0xc1, 0x88,
+  0xea, 0xa7, 0x03, 0x9e, 0x6b, 0xcf, 0xaf, 0x46, 0xb4, 0x1a, 0x95, 0x47,
+  0xcc, 0x79, 0xd5, 0x68, 0xa8, 0xea, 0x8f, 0xae, 0x7e, 0x0b, 0xfc, 0x47,
+  0xf8, 0x7b, 0xe0, 0x5d, 0x62, 0xde, 0x5f, 0x88, 0x5a, 0x43, 0xf8, 0x9b,
+  0x44, 0xba, 0xf0, 0xa4, 0xba, 0x6c, 0xb6, 0x57, 0x72, 0x79, 0x32, 0xdb,
+  0xbc, 0xb2, 0x2b, 0x19, 0xad, 0xa7, 0x50, 0xcb, 0x13, 0x2b, 0xc6, 0x70,
+  0x19, 0x1d, 0x70, 0x4f, 0x07, 0x3c, 0x32, 0xef, 0xe3, 0x4d, 0x85, 0xe7,
+  0x8a, 0x7c, 0x73, 0x7d, 0xe0, 0x55, 0xb7, 0xd0, 0xf4, 0x4d, 0x56, 0xc1,
+  0xac, 0x13, 0x42, 0xb7, 0x6b, 0x88, 0xed, 0xa7, 0xb3, 0x37, 0x25, 0xe3,
+  0x88, 0xed, 0x75, 0xf3, 0x8c, 0x6d, 0x89, 0x7f, 0x78, 0x59, 0x77, 0x8c,
+  0xf9, 0x67, 0x68, 0x51, 0xf1, 0x3e, 0xa7, 0x73, 0x73, 0x69, 0xaa, 0xa1,
+  0x92, 0x55, 0x4b, 0x7f, 0xf5, 0x50, 0xa4, 0x72, 0xa1, 0x55, 0x0e, 0xc1,
+  0x80, 0xc1, 0x21, 0xb1, 0x92, 0xdc, 0x64, 0xfa, 0xe6, 0xb5, 0x23, 0xb9,
+  0xbc, 0x75, 0x8a, 0x7b, 0x26, 0x65, 0x44, 0x97, 0x6c, 0xa8, 0x50, 0x6e,
+  0x27, 0x1c, 0x8e, 0x7a, 0x0e, 0x57, 0xe6, 0xe0, 0x83, 0x4e, 0xa6, 0x3a,
+  0xb7, 0x27, 0x2b, 0x6a, 0xcf, 0xcb, 0xf5, 0xfd, 0x08, 0x9f, 0x46, 0x99,
+  0xa5, 0x61, 0xe2, 0x0d, 0x2b, 0x48, 0xf1, 0x62, 0xbe, 0xad, 0x6a, 0x97,
+  0xd6, 0xf1, 0x34, 0xee, 0xf0, 0x3c, 0xbe, 0x4b, 0xc8, 0x65, 0xdc, 0xb1,
+  0x48, 0x92, 0x36, 0xcc, 0x84, 0x90, 0x86, 0x65, 0x24, 0x6f, 0x50, 0x46,
+  0x57, 0x21, 0xab, 0xdb, 0x34, 0x1f, 0x86, 0xfe, 0x3e, 0xd5, 0xb4, 0xdf,
+  0x14, 0x6b, 0xda, 0x0d, 0xee, 0x9d, 0xa7, 0xd8, 0x5a, 0x88, 0x24, 0xbc,
+  0xb0, 0x9f, 0x51, 0xb7, 0xb7, 0x9e, 0x45, 0x93, 0x98, 0xa2, 0x8a, 0x19,
+  0x9c, 0x4d, 0x37, 0x96, 0x32, 0x0e, 0xc0, 0x76, 0xe3, 0x2d, 0xc1, 0x35,
+  0xf3, 0x26, 0xab, 0x1e, 0xab, 0x69, 0xab, 0xc7, 0x7d, 0x04, 0xb1, 0xc8,
+  0x81, 0x14, 0xf9, 0x62, 0x45, 0x24, 0xbb, 0x7c, 0xed, 0xb1, 0x95, 0x38,
+  0x3d, 0x36, 0x90, 0xa0, 0x13, 0xeb, 0xc1, 0x3d, 0x7d, 0x8f, 0x8c, 0x6d,
+  0xf4, 0xdb, 0xcf, 0xb1, 0x5c, 0x44, 0xe0, 0x30, 0x23, 0xc8, 0x0b, 0xf3,
+  0xe5, 0x97, 0x9c, 0x70, 0x14, 0x92, 0x41, 0xe0, 0x1e, 0xbf, 0x4a, 0xc1,
+  0x55, 0x95, 0xac, 0x95, 0xff, 0x00, 0xaf, 0xeb, 0xfa, 0xd9, 0xd4, 0xa9,
+  0x65, 0x74, 0x7e, 0xda, 0xfe, 0xc2, 0xbf, 0x08, 0x3e, 0x18, 0x78, 0x9b,
+  0xe1, 0xc7, 0x88, 0x75, 0x8f, 0x1a, 0xe8, 0xfa, 0x76, 0xb7, 0xe2, 0x27,
+  0xb1, 0x1a, 0x3e, 0x8d, 0x6f, 0x77, 0x24, 0xbf, 0x65, 0xb0, 0x92, 0x53,
+  0x18, 0x6d, 0x46, 0x48, 0xa2, 0x92, 0xde, 0xed, 0x1a, 0x28, 0xe7, 0x46,
+  0xb7, 0x71, 0x95, 0x79, 0x46, 0xdd, 0xa7, 0x70, 0x2b, 0xf9, 0x87, 0xac,
+  0x5d, 0x59, 0x78, 0x6b, 0xc7, 0xd7, 0xd2, 0x49, 0x3c, 0x01, 0x23, 0xd4,
+  0xae, 0x56, 0x3f, 0x28, 0x09, 0x55, 0xa3, 0x01, 0xb6, 0x12, 0xae, 0x4a,
+  0xed, 0xe4, 0x6d, 0x24, 0x9c, 0x76, 0xcf, 0x5a, 0xd8, 0xf8, 0x73, 0xf1,
+  0x5f, 0xc4, 0xbe, 0x18, 0xbd, 0x33, 0x69, 0x89, 0x6f, 0x75, 0x0b, 0xdb,
+  0x86, 0x96, 0xde, 0xfc, 0xbb, 0xa9, 0x12, 0x6d, 0xcb, 0x34, 0x6a, 0xde,
+  0x59, 0xe0, 0x29, 0x1b, 0xbb, 0xe3, 0x8e, 0x05, 0x78, 0xe7, 0xc5, 0x0d,
+  0x76, 0xef, 0xc6, 0x9e, 0x2c, 0xbd, 0xd5, 0xb5, 0x15, 0x78, 0x25, 0xb9,
+  0xd4, 0xa7, 0x9c, 0xa2, 0xb3, 0x71, 0x19, 0x50, 0x10, 0x1e, 0x7e, 0xe9,
+  0xc0, 0xc6, 0x79, 0x2b, 0xf5, 0xcd, 0x72, 0x54, 0xc4, 0x73, 0xda, 0x0e,
+  0x36, 0xb7, 0x5d, 0x2d, 0xfe, 0x66, 0xb4, 0xa4, 0xa4, 0xb7, 0xb1, 0xfa,
+  0x07, 0xf0, 0xfb, 0xf6, 0x83, 0xf1, 0x36, 0x9d, 0xa0, 0x4d, 0xe1, 0xbb,
+  0x3b, 0xbb, 0x49, 0xad, 0xb5, 0x89, 0x41, 0xb8, 0x97, 0x55, 0xb0, 0x8a,
+  0xfc, 0xab, 0x02, 0x26, 0x76, 0x4b, 0x89, 0x22, 0x92, 0x54, 0xfb, 0xad,
+  0xb4, 0x06, 0x20, 0xab, 0x48, 0x30, 0x4b, 0x31, 0xaf, 0xd1, 0xaf, 0x87,
+  0xff, 0x00, 0x11, 0x6c, 0xbc, 0x73, 0xe1, 0xed, 0x33, 0xc4, 0x01, 0xf4,
+  0x0f, 0x0b, 0x5d, 0x69, 0xdf, 0x68, 0xb0, 0x8e, 0xd3, 0xc2, 0x56, 0x33,
+  0xa2, 0x4e, 0xb3, 0x13, 0x2b, 0xcb, 0x72, 0x97, 0x32, 0xaa, 0xc4, 0x59,
+  0x48, 0x42, 0x13, 0xf7, 0x44, 0x82, 0xdb, 0x32, 0x58, 0xb7, 0xf3, 0xcb,
+  0xa7, 0x78, 0xc6, 0x1f, 0x0f, 0x03, 0x67, 0x6d, 0x14, 0x26, 0x11, 0x10,
+  0x79, 0xe2, 0x77, 0x39, 0x21, 0x31, 0xbd, 0xa1, 0x18, 0x39, 0x65, 0x19,
+  0xc1, 0xfc, 0x7b, 0x57, 0xd9, 0x9f, 0x02, 0xbe, 0x29, 0xf8, 0x82, 0xeb,
+  0x40, 0xd5, 0xed, 0xb4, 0x9d, 0x50, 0x47, 0x6a, 0xb6, 0x92, 0x43, 0x75,
+  0x1a, 0x4b, 0x04, 0xb7, 0x17, 0x31, 0xcc, 0xc8, 0xd0, 0x28, 0xde, 0xcf,
+  0x30, 0x31, 0xed, 0x0d, 0x29, 0x25, 0xc2, 0xa8, 0x5c, 0x05, 0x3c, 0x57,
+  0x3c, 0xdd, 0x57, 0x16, 0x9c, 0xbd, 0xdf, 0x3d, 0x7e, 0xee, 0xc6, 0x53,
+  0x8b, 0xb5, 0xde, 0xa7, 0xd5, 0x7f, 0xb4, 0x87, 0xc5, 0x5d, 0x02, 0x61,
+  0xa9, 0x69, 0x9a, 0x76, 0xa7, 0xa9, 0xcb, 0x7d, 0x75, 0x70, 0xb2, 0xfd,
+  0x96, 0xc2, 0xf5, 0x21, 0x58, 0x90, 0x37, 0xce, 0xbe, 0x62, 0x8d, 0xcf,
+  0xd4, 0x93, 0x8f, 0x61, 0xc8, 0x3b, 0x8f, 0xc1, 0x5e, 0x25, 0xf8, 0xc3,
+  0xe1, 0xfd, 0x32, 0x58, 0xb4, 0x1f, 0x0e, 0x43, 0x79, 0x6c, 0x21, 0x8d,
+  0x8d, 0xec, 0xd6, 0x52, 0x93, 0x3c, 0xd2, 0xc8, 0x03, 0x4b, 0x70, 0xd3,
+  0x5c, 0x96, 0x6d, 0xc1, 0xc7, 0xc8, 0xea, 0xa9, 0x8f, 0x98, 0xaf, 0x27,
+  0x9f, 0x2f, 0xf8, 0xd7, 0xad, 0xf8, 0x97, 0x46, 0xb9, 0xb6, 0x8e, 0xfe,
+  0xc7, 0x6c, 0xb2, 0x46, 0xb7, 0xd6, 0xd7, 0x22, 0x52, 0xe0, 0x06, 0x3f,
+  0x24, 0xaa, 0x14, 0x83, 0x92, 0x33, 0x9d, 0xd9, 0x03, 0x90, 0x72, 0x40,
+  0xaf, 0x9c, 0xf5, 0x3d, 0x7b, 0xc6, 0x57, 0x3a, 0x9c, 0xf7, 0x3a, 0x55,
+  0xdd, 0xcc, 0x2f, 0x3a, 0x18, 0xa7, 0x68, 0xc9, 0xcb, 0x29, 0x23, 0x70,
+  0x04, 0x72, 0x7b, 0x63, 0x1d, 0x0f, 0x4a, 0x8c, 0xa3, 0x24, 0x84, 0x57,
+  0x3f, 0x35, 0xec, 0x55, 0x28, 0x36, 0xae, 0x7d, 0x8f, 0xac, 0x7c, 0x5c,
+  0xd5, 0x3c, 0x23, 0x60, 0xd7, 0xba, 0x9c, 0xfa, 0x5e, 0xb7, 0x6a, 0x20,
+  0x8d, 0x6c, 0x66, 0xdc, 0x4e, 0x55, 0x94, 0x00, 0x0d, 0xbc, 0x81, 0x19,
+  0xe4, 0x52, 0xdf, 0x3c, 0xbf, 0x38, 0x2c, 0x4e, 0x1c, 0x70, 0x07, 0xc8,
+  0x9e, 0x37, 0xf8, 0xc1, 0xab, 0x78, 0x87, 0x50, 0x9e, 0x79, 0xb7, 0x85,
+  0x95, 0xcb, 0xc7, 0x12, 0x3f, 0xca, 0xa4, 0x02, 0xab, 0xf2, 0xaf, 0x0a,
+  0x71, 0xe9, 0x8f, 0xc4, 0x56, 0x36, 0xbd, 0xa3, 0x5c, 0xc6, 0xb1, 0x59,
+  0x49, 0x70, 0x64, 0x31, 0xc8, 0xd2, 0xbf, 0xda, 0xb7, 0xb9, 0x4c, 0xa8,
+  0xf9, 0x94, 0xa6, 0x54, 0xf2, 0x41, 0x38, 0x24, 0x11, 0xea, 0x05, 0x78,
+  0xe5, 0xd2, 0xbc, 0x17, 0x4e, 0xd2, 0xb7, 0xc8, 0xbf, 0x20, 0xf2, 0xce,
+  0x43, 0x0e, 0x49, 0x20, 0xe7, 0x9e, 0x3d, 0x3b, 0x57, 0xbf, 0x80, 0xcb,
+  0x28, 0xc5, 0xb9, 0xa5, 0xab, 0x3b, 0xe9, 0x53, 0xb6, 0xe7, 0x41, 0x27,
+  0x89, 0xf5, 0x3f, 0xed, 0x90, 0xb7, 0x1e, 0x70, 0x98, 0xca, 0x41, 0x53,
+  0x80, 0xc8, 0xd9, 0xc7, 0x00, 0x72, 0x0a, 0xe3, 0xa1, 0x1c, 0x0c, 0x0e,
+  0xd5, 0xf4, 0xc6, 0x81, 0xf1, 0x33, 0xc3, 0x97, 0x10, 0x3d, 0x8d, 0xfe,
+  0x16, 0x4b, 0x9b, 0x01, 0x6d, 0x77, 0x04, 0x4a, 0x36, 0x6f, 0x8d, 0x86,
+  0xd1, 0xb4, 0xb0, 0x21, 0xb8, 0xc9, 0x23, 0x92, 0xc0, 0x1e, 0x71, 0x8a,
+  0xf8, 0xd2, 0x4d, 0x52, 0xd9, 0xa6, 0x71, 0x08, 0x2b, 0xb8, 0xe4, 0x01,
+  0xcf, 0xca, 0x41, 0xc0, 0x5c, 0xe4, 0x9f, 0xc4, 0xe7, 0x8e, 0xf5, 0x5e,
+  0x2b, 0xa6, 0xb5, 0x9a, 0x49, 0xd6, 0x43, 0xbd, 0x97, 0x70, 0x20, 0x91,
+  0x83, 0xcf, 0x43, 0x9e, 0x41, 0x38, 0xce, 0x6b, 0xbf, 0x13, 0x95, 0xc2,
+  0x76, 0xb2, 0xb5, 0x8d, 0xdc, 0x7b, 0x1f, 0x42, 0xea, 0x7f, 0x13, 0xee,
+  0x75, 0xa5, 0x2e, 0x8c, 0xbf, 0xba, 0x48, 0xe1, 0x6d, 0xca, 0x01, 0x69,
+  0x21, 0xe3, 0x70, 0x3c, 0x9c, 0x36, 0x72, 0x71, 0xd8, 0x57, 0xa9, 0x78,
+  0x1f, 0xe2, 0x9e, 0xa5, 0xa6, 0xda, 0xc7, 0x67, 0xa4, 0x43, 0x24, 0x3b,
+  0x64, 0x49, 0x9e, 0x60, 0x5c, 0xee, 0x62, 0x39, 0x67, 0x05, 0xb6, 0x90,
+  0xd8, 0xeb, 0x80, 0x48, 0x03, 0x92, 0x41, 0xaf, 0x8f, 0xb4, 0xe9, 0x64,
+  0x85, 0xe4, 0xd8, 0xbf, 0x23, 0x66, 0x64, 0x91, 0x8f, 0x19, 0x27, 0x3b,
+  0x8e, 0x72, 0x08, 0x2b, 0x9e, 0x38, 0xe7, 0xf2, 0x3d, 0xbe, 0x97, 0xae,
+  0xc9, 0x67, 0xa8, 0xaa, 0xc4, 0xc5, 0xa1, 0x29, 0xd4, 0x00, 0xc7, 0x95,
+  0xf9, 0x87, 0x7e, 0x9f, 0x5f, 0xc2, 0xb8, 0xf1, 0x99, 0x35, 0x27, 0x17,
+  0x05, 0x10, 0x70, 0x4e, 0x3b, 0x1f, 0xa1, 0xb3, 0x7e, 0xd1, 0xbe, 0x2d,
+  0xb6, 0xf0, 0xba, 0xe8, 0x97, 0x92, 0xc9, 0xf6, 0x69, 0xe4, 0xcc, 0xa5,
+  0x25, 0x3b, 0xdc, 0x81, 0xd1, 0x1b, 0x39, 0x04, 0xe4, 0x83, 0xec, 0x78,
+  0xe0, 0x9c, 0xfc, 0xcf, 0x7d, 0xe2, 0x6f, 0x10, 0xf8, 0xd3, 0x58, 0xb6,
+  0xd1, 0x8d, 0xfb, 0x38, 0x12, 0x79, 0x56, 0xf1, 0x5d, 0x5c, 0x14, 0x83,
+  0x63, 0xb1, 0x20, 0x10, 0xe4, 0xa2, 0x2f, 0x2b, 0xba, 0x4e, 0x3e, 0x6f,
+  0x9b, 0x20, 0x1d, 0xd5, 0xe3, 0x7a, 0xd7, 0x8a, 0x2e, 0x27, 0xb5, 0x36,
+  0xf2, 0xf9, 0x8a, 0xdb, 0x4a, 0xc6, 0xb1, 0x6d, 0x65, 0x8f, 0x91, 0xfc,
+  0x19, 0x23, 0xee, 0xe4, 0x1c, 0x10, 0x71, 0xd2, 0xae, 0xc7, 0x76, 0x74,
+  0x8b, 0x28, 0x2f, 0xa1, 0x7b, 0x67, 0xba, 0x56, 0x25, 0x31, 0x97, 0x25,
+  0x31, 0xd4, 0x03, 0xf2, 0x9c, 0x63, 0x90, 0x47, 0x3c, 0x67, 0xa8, 0x15,
+  0xe6, 0xd1, 0xc8, 0xa9, 0x50, 0x4e, 0x74, 0xe2, 0x93, 0x7f, 0xd5, 0xff,
+  0x00, 0xcc, 0xc6, 0x54, 0xdd, 0x8f, 0x7f, 0xf0, 0x85, 0xb4, 0x1e, 0x0a,
+  0xbb, 0x92, 0xee, 0xfe, 0xe4, 0xc7, 0x7b, 0x79, 0x3c, 0x8c, 0x24, 0x49,
+  0x7c, 0xb8, 0xe6, 0x50, 0x4b, 0x31, 0xdc, 0xa5, 0xd5, 0x90, 0xb0, 0x04,
+  0x02, 0x76, 0x9f, 0xef, 0x73, 0x8a, 0xfe, 0x87, 0xbf, 0xe0, 0x9c, 0x1a,
+  0xde, 0x91, 0xf1, 0xc3, 0xc6, 0x10, 0xe9, 0xda, 0xbc, 0x97, 0xe7, 0xc6,
+  0x16, 0x29, 0x1d, 0x96, 0x9d, 0x35, 0x9c, 0xde, 0x5d, 0xfb, 0x5a, 0xc7,
+  0x11, 0xb7, 0xd9, 0xa6, 0x8b, 0x47, 0xb3, 0xf3, 0x5a, 0x23, 0x2c, 0x4f,
+  0x1c, 0x62, 0x51, 0xbb, 0x69, 0x24, 0x9c, 0x2a, 0xa7, 0xf2, 0xe1, 0xa1,
+  0x78, 0x96, 0xf6, 0xff, 0x00, 0x54, 0xb7, 0xd2, 0xef, 0x27, 0x13, 0xc7,
+  0x71, 0x74, 0x17, 0xcc, 0xb8, 0x52, 0x63, 0x8d, 0x9b, 0x38, 0x70, 0x01,
+  0x24, 0x0e, 0x73, 0x9e, 0xfe, 0x87, 0xa5, 0x7e, 0xb1, 0xfe, 0xcb, 0x5f,
+  0x12, 0xfc, 0x6b, 0xf0, 0x6f, 0xc6, 0x3a, 0x77, 0x89, 0xbc, 0x22, 0xd7,
+  0x65, 0xb4, 0xd9, 0xcc, 0x96, 0xda, 0x8a, 0x83, 0xe7, 0x16, 0x2b, 0xb5,
+  0xd1, 0x76, 0x6f, 0x2a, 0xc4, 0x1f, 0x97, 0xe6, 0xef, 0xce, 0x4e, 0x48,
+  0xf9, 0xfe, 0x23, 0xc4, 0x4f, 0x0d, 0xc9, 0x52, 0x4e, 0xed, 0x34, 0xf4,
+  0xed, 0xf3, 0xfc, 0xbf, 0x13, 0x8a, 0x74, 0xfd, 0xed, 0x4f, 0xea, 0x1b,
+  0xf6, 0xd2, 0xf8, 0x49, 0xa7, 0x78, 0x03, 0x56, 0xd5, 0x75, 0xdd, 0x3e,
+  0xea, 0x5b, 0x4b, 0x7d, 0x35, 0x20, 0x4b, 0x7d, 0x46, 0x50, 0x41, 0xbe,
+  0xd6, 0xe4, 0xb7, 0xdd, 0x2c, 0x11, 0x02, 0xcf, 0x24, 0x71, 0xa9, 0xc1,
+  0x1f, 0xbf, 0x94, 0x0d, 0xc5, 0x8c, 0x84, 0xe3, 0x77, 0xe7, 0x7f, 0xc2,
+  0x7d, 0x7f, 0xc5, 0x3e, 0x11, 0xd2, 0x2f, 0xbc, 0x45, 0xe2, 0x73, 0x0a,
+  0x5f, 0xfd, 0xac, 0x6d, 0x11, 0x5d, 0xa5, 0xd4, 0xb2, 0x46, 0xee, 0xcd,
+  0x96, 0x48, 0xd8, 0xb2, 0xa6, 0x71, 0xb5, 0x8b, 0x8c, 0x90, 0x46, 0x39,
+  0x38, 0xe2, 0x7c, 0x55, 0xfb, 0x67, 0x6b, 0xbf, 0x10, 0xf5, 0x0b, 0x2f,
+  0x0f, 0xfc, 0x50, 0xbb, 0x7d, 0x56, 0xd0, 0x5e, 0xa3, 0xac, 0x36, 0xc8,
+  0x63, 0x48, 0xac, 0x60, 0x88, 0x08, 0x91, 0xe2, 0x8d, 0x52, 0x1f, 0x32,
+  0x30, 0xac, 0xa5, 0xcf, 0xdf, 0x07, 0x1c, 0x71, 0xb7, 0xe4, 0x6f, 0x1e,
+  0xfc, 0x3b, 0xf8, 0xc7, 0xe1, 0xff, 0x00, 0x18, 0x2e, 0xb9, 0xf0, 0xd9,
+  0x75, 0x0b, 0xcd, 0x1f, 0x5b, 0x7c, 0x43, 0x6d, 0x63, 0x1b, 0xce, 0x96,
+  0xf9, 0x3c, 0xac, 0xcc, 0x81, 0x15, 0x43, 0x6d, 0x52, 0xae, 0xd9, 0x4d,
+  0xc0, 0xe4, 0x8c, 0x64, 0xf3, 0xae, 0x25, 0xc2, 0x57, 0xa8, 0xa1, 0x46,
+  0x2e, 0x09, 0xa6, 0xd5, 0xfa, 0xf5, 0xd3, 0xb7, 0xfc, 0x07, 0xab, 0x7a,
+  0xb9, 0xa9, 0x51, 0xa7, 0x78, 0xa3, 0xf5, 0xeb, 0x49, 0xf8, 0xc7, 0xa1,
+  0xf8, 0xaa, 0xfe, 0x1b, 0x6b, 0xcb, 0xc9, 0xe2, 0xf3, 0xca, 0x99, 0xae,
+  0xe3, 0x7c, 0x48, 0x97, 0x4c, 0xbe, 0x58, 0x66, 0xe5, 0xbf, 0x8b, 0x04,
+  0x0f, 0x97, 0x77, 0x18, 0x35, 0xd5, 0x7c, 0x25, 0xf1, 0xc7, 0xc5, 0x99,
+  0x7c, 0x73, 0x75, 0x63, 0xa1, 0x97, 0x3f, 0x64, 0x89, 0xae, 0x75, 0x5b,
+  0x8f, 0x32, 0xde, 0xda, 0x61, 0xe5, 0x65, 0xe3, 0x99, 0x63, 0x93, 0xf7,
+  0x6d, 0x04, 0x85, 0x0e, 0x64, 0x73, 0xb4, 0xf9, 0x6c, 0xcd, 0x81, 0xc8,
+  0xfc, 0x68, 0xf0, 0xfd, 0xaf, 0xc4, 0x5f, 0x0e, 0xbf, 0xfc, 0x24, 0xba,
+  0xf4, 0x71, 0xc9, 0x63, 0x13, 0x46, 0xaf, 0x0c, 0x5b, 0xbc, 0xf8, 0x51,
+  0x82, 0xf9, 0x8b, 0x24, 0x7c, 0x1d, 0xc1, 0xc1, 0x5d, 0x8b, 0xc7, 0x04,
+  0x92, 0x14, 0x1a, 0xea, 0x3c, 0x79, 0xfb, 0x42, 0x37, 0x87, 0xbc, 0x43,
+  0x67, 0xe2, 0x2b, 0x3b, 0xf6, 0xb2, 0x4b, 0xbd, 0x26, 0x58, 0x6e, 0x26,
+  0x96, 0x62, 0x2d, 0x6e, 0x02, 0xab, 0x66, 0x29, 0x82, 0x9e, 0x92, 0x01,
+  0x94, 0xc2, 0x96, 0x0c, 0xc3, 0xe4, 0xe3, 0x23, 0xd5, 0xca, 0xea, 0x46,
+  0x75, 0x79, 0x7e, 0x24, 0xfb, 0x3b, 0x3b, 0xfa, 0xf4, 0xf3, 0x09, 0x62,
+  0x2e, 0xed, 0xd4, 0xff, 0xd3, 0xf2, 0x0f, 0x1a, 0xfc, 0x1b, 0xf0, 0x9f,
+  0x82, 0xad, 0x6e, 0x64, 0xf0, 0xa8, 0xf2, 0xa3, 0x1b, 0x0c, 0x76, 0x96,
+  0xaa, 0x0c, 0x71, 0x2c, 0x20, 0x85, 0x11, 0xc4, 0xa0, 0x02, 0xd8, 0xe0,
+  0x33, 0x64, 0xf6, 0xf6, 0x3f, 0x93, 0x3f, 0x16, 0x34, 0x19, 0x3c, 0x45,
+  0x3d, 0xc4, 0x5a, 0x34, 0x6f, 0xa7, 0x11, 0x72, 0xea, 0xef, 0x2f, 0x92,
+  0x93, 0xcd, 0xb5, 0x49, 0xc7, 0x90, 0xe3, 0x95, 0x3c, 0x0f, 0xbb, 0x9e,
+  0x79, 0xce, 0x73, 0x5f, 0xa9, 0x1e, 0x32, 0xf1, 0xa7, 0x9b, 0x1c, 0x91,
+  0x4a, 0x49, 0x59, 0x01, 0x46, 0xed, 0xc1, 0x04, 0x1c, 0x8c, 0xfb, 0xd7,
+  0xc2, 0xdf, 0x10, 0xb4, 0x58, 0xe3, 0x95, 0xaf, 0x34, 0x5b, 0x74, 0x2d,
+  0x1c, 0xbe, 0x72, 0xc5, 0x14, 0x51, 0x8f, 0x9d, 0x72, 0xe1, 0xd9, 0x82,
+  0x93, 0xd7, 0xa9, 0x00, 0xb1, 0xcf, 0x00, 0xf2, 0x2b, 0xe2, 0xf8, 0x8b,
+  0x86, 0xbd, 0x85, 0x67, 0x8a, 0xa5, 0xb3, 0xe9, 0xd9, 0xf9, 0x79, 0x7e,
+  0x47, 0x8a, 0xb0, 0x4a, 0x4f, 0x9a, 0x9a, 0xd7, 0xb1, 0xf0, 0x17, 0x88,
+  0xfc, 0x05, 0xa7, 0x68, 0xe2, 0x48, 0x35, 0x6b, 0xc7, 0x94, 0xc2, 0xcd,
+  0x27, 0xd9, 0xd5, 0x87, 0xee, 0x4b, 0xf0, 0x57, 0x70, 0x0a, 0x07, 0x3d,
+  0x00, 0x23, 0x8e, 0x9d, 0x06, 0x7e, 0x7b, 0xd6, 0xa0, 0x16, 0xf7, 0x37,
+  0x16, 0xb0, 0x08, 0xbc, 0x98, 0x8a, 0xaa, 0x34, 0x6c, 0x4a, 0xbb, 0x13,
+  0xbb, 0x76, 0x3a, 0xe4, 0x71, 0x9c, 0x9e, 0x7a, 0x57, 0xd4, 0x3e, 0x3f,
+  0xf0, 0x0f, 0x8c, 0x3c, 0x4b, 0x39, 0x96, 0xea, 0xfa, 0xd9, 0x03, 0x49,
+  0x23, 0xc1, 0x63, 0x6e, 0xaa, 0x03, 0x0d, 0xb8, 0x73, 0xf3, 0x92, 0xf2,
+  0x3e, 0x08, 0xf9, 0x88, 0xe0, 0xe7, 0x85, 0x18, 0x07, 0x91, 0xd2, 0x3e,
+  0x0b, 0xdf, 0x5a, 0x99, 0x6c, 0x64, 0x68, 0xa4, 0x79, 0xe3, 0x8f, 0x33,
+  0xca, 0x59, 0x92, 0x21, 0x95, 0x00, 0x95, 0x8c, 0x92, 0xd8, 0xdc, 0x7b,
+  0x70, 0x06, 0x47, 0x3c, 0xd7, 0x15, 0x2c, 0x4a, 0x8a, 0xf7, 0x99, 0xbe,
+  0x1e, 0x8d, 0x4d, 0x5e, 0xe7, 0xcd, 0x3a, 0x8e, 0x92, 0xb0, 0x5c, 0x45,
+  0x7d, 0x13, 0x0c, 0x41, 0x93, 0x12, 0x44, 0x01, 0x38, 0x3d, 0x4b, 0x9e,
+  0xb9, 0x23, 0x9f, 0xff, 0x00, 0x58, 0xad, 0xa8, 0xf4, 0x09, 0xb5, 0xcb,
+  0x96, 0xba, 0x6f, 0x92, 0x29, 0x02, 0xfd, 0xec, 0xe4, 0xf1, 0x8c, 0x60,
+  0x9e, 0xd8, 0x24, 0x9e, 0xdf, 0x95, 0x7b, 0xf5, 0x8f, 0xc3, 0x2d, 0x52,
+  0xee, 0xe6, 0x68, 0x6e, 0x7c, 0xa6, 0x26, 0x76, 0xb7, 0x9a, 0xe0, 0xb7,
+  0x97, 0x0e, 0x20, 0x3b, 0x98, 0x04, 0x73, 0xbd, 0x8e, 0x3d, 0x38, 0x03,
+  0x3c, 0x71, 0x5b, 0x36, 0x7e, 0x17, 0x8e, 0x29, 0xe0, 0xb2, 0x9e, 0x19,
+  0x55, 0x65, 0x97, 0xf7, 0x51, 0x60, 0x85, 0xe1, 0xb3, 0xc9, 0x23, 0x81,
+  0x81, 0xd0, 0x0e, 0xa3, 0x8e, 0x49, 0xad, 0x7f, 0xb4, 0x63, 0x14, 0xd2,
+  0x77, 0x38, 0x2a, 0x56, 0xe8, 0x8f, 0x06, 0x8b, 0xc1, 0xb1, 0xdb, 0x49,
+  0xb5, 0xb0, 0xc4, 0x0c, 0x81, 0xd3, 0x38, 0xeb, 0x80, 0x3e, 0xbc, 0x7f,
+  0xfa, 0xab, 0x4e, 0xca, 0xd2, 0xe2, 0xce, 0x5f, 0x21, 0x61, 0x66, 0x54,
+  0x89, 0xbc, 0xc2, 0x13, 0x24, 0x03, 0x91, 0x8e, 0x3a, 0x03, 0xdf, 0x23,
+  0x19, 0xfc, 0xab, 0xd8, 0x2e, 0xb4, 0x68, 0xf4, 0xfd, 0x52, 0x3b, 0x3e,
+  0x48, 0x79, 0x7c, 0xc0, 0x19, 0xbe, 0x50, 0xb9, 0x24, 0x29, 0x62, 0x14,
+  0xf0, 0xbc, 0x0e, 0x87, 0xf3, 0xae, 0x17, 0x56, 0xbd, 0xd5, 0xec, 0x56,
+  0x70, 0xac, 0x6e, 0xe5, 0x07, 0xfd, 0x54, 0x28, 0xf2, 0x28, 0xc8, 0x3c,
+  0x92, 0x19, 0x70, 0x3a, 0x8f, 0x62, 0x47, 0x4c, 0xe6, 0xa1, 0xe2, 0x1c,
+  0xd5, 0xbb, 0x9c, 0x9e, 0xd6, 0x4f, 0x43, 0x02, 0x5d, 0x2b, 0x4a, 0x96,
+  0x5c, 0x6a, 0xa2, 0x43, 0x37, 0x94, 0xc0, 0x60, 0x8d, 0xb1, 0x83, 0xf3,
+  0x7c, 0xd9, 0xc0, 0xc8, 0xcf, 0x60, 0x38, 0xef, 0x93, 0x57, 0xcc, 0x7e,
+  0x25, 0xb8, 0x94, 0x69, 0x1e, 0x1e, 0x68, 0x92, 0x28, 0x60, 0x2f, 0xe6,
+  0x65, 0xd9, 0x63, 0x52, 0x46, 0x59, 0xd8, 0x21, 0xe4, 0x91, 0x90, 0xb9,
+  0xe7, 0xd7, 0xd6, 0x85, 0xde, 0x8b, 0x79, 0xad, 0xe9, 0x76, 0x8f, 0x71,
+  0x2b, 0xd9, 0xbd, 0xc4, 0xcb, 0x14, 0x91, 0xd8, 0xc4, 0xde, 0x60, 0xf3,
+  0x1b, 0x6a, 0x79, 0xa0, 0xb6, 0x01, 0x1b, 0x83, 0x10, 0x32, 0x46, 0x48,
+  0xe8, 0x01, 0xae, 0xae, 0xc7, 0xc0, 0x1a, 0xa6, 0x9d, 0x12, 0xcb, 0x6b,
+  0x34, 0x52, 0x79, 0x2c, 0x61, 0x92, 0x78, 0x51, 0xa6, 0x9d, 0x64, 0x87,
+  0x1f, 0x39, 0x42, 0x40, 0xda, 0x70, 0x70, 0x36, 0x13, 0xcf, 0x71, 0xcd,
+  0x73, 0xd7, 0x8d, 0x92, 0x77, 0xb8, 0x9d, 0xd5, 0x93, 0x67, 0x25, 0x7f,
+  0xa8, 0xc1, 0xa3, 0x3d, 0xc6, 0x91, 0xac, 0xad, 0xa4, 0x8c, 0x56, 0x38,
+  0xad, 0xae, 0x4b, 0xee, 0x09, 0xb7, 0x86, 0x0c, 0x04, 0x9b, 0xa3, 0x2c,
+  0xd9, 0xe9, 0xf3, 0xe0, 0x82, 0x70, 0x39, 0xad, 0x8d, 0x1f, 0xfb, 0x1a,
+  0xea, 0xd6, 0x2b, 0xcd, 0x31, 0x61, 0xb6, 0x64, 0x9f, 0x63, 0xc3, 0x29,
+  0x48, 0x46, 0x57, 0x3b, 0xd4, 0x90, 0xb2, 0xbb, 0xee, 0x07, 0x83, 0x8e,
+  0x9d, 0xb8, 0x02, 0xb4, 0x13, 0xc1, 0xf7, 0x9a, 0xc4, 0xf1, 0x47, 0x73,
+  0xa6, 0x47, 0x72, 0x0c, 0x53, 0x4b, 0x14, 0x7a, 0x91, 0x82, 0xde, 0xe1,
+  0xa3, 0x50, 0x73, 0xb1, 0x58, 0x33, 0x13, 0xd0, 0x0d, 0xcb, 0x9f, 0x42,
+  0x0e, 0x6b, 0x67, 0x49, 0xd1, 0x7c, 0xef, 0x3e, 0xd9, 0xa0, 0x99, 0x2d,
+  0x9c, 0x29, 0x16, 0x77, 0x16, 0xa1, 0xd0, 0x6e, 0xdb, 0x82, 0xdb, 0x1b,
+  0xef, 0x12, 0xa4, 0xe3, 0x6a, 0xf3, 0xc8, 0x38, 0x04, 0x1c, 0x9a, 0x49,
+  0x22, 0xdc, 0x74, 0xb9, 0x9f, 0x6e, 0x9a, 0xb4, 0x51, 0x9b, 0x88, 0x9a,
+  0xd9, 0x65, 0x8f, 0x6e, 0xc8, 0x4b, 0xbe, 0x14, 0x64, 0x9c, 0x85, 0xf2,
+  0xc6, 0xec, 0x21, 0x23, 0x19, 0xce, 0xee, 0x0e, 0x0e, 0x45, 0x61, 0xe9,
+  0x3a, 0x4e, 0xb3, 0x78, 0x5c, 0xea, 0x49, 0x20, 0x99, 0xce, 0xe9, 0x0c,
+  0xbb, 0x94, 0x29, 0x72, 0xb8, 0xce, 0x40, 0xee, 0xc3, 0x8c, 0xe4, 0x77,
+  0x07, 0xbf, 0xbe, 0xf8, 0x5f, 0xe1, 0x66, 0xa7, 0xa9, 0xf3, 0x6d, 0x6f,
+  0x1c, 0x43, 0xcc, 0x1b, 0xa7, 0x58, 0x8a, 0x97, 0xda, 0x4e, 0x77, 0xe4,
+  0x01, 0xdb, 0x9c, 0x1c, 0x8c, 0x74, 0xec, 0x7e, 0x8e, 0xd0, 0xbe, 0x18,
+  0xe8, 0x96, 0x09, 0x9d, 0x79, 0xd2, 0x47, 0x04, 0x33, 0x46, 0xec, 0x5d,
+  0x63, 0x90, 0x2e, 0x0a, 0x8c, 0xe1, 0xb6, 0x9c, 0xf2, 0xa4, 0xe0, 0x0e,
+  0xc0, 0x1a, 0xda, 0x86, 0x16, 0x73, 0xf8, 0x63, 0xa7, 0x73, 0xb3, 0x0d,
+  0x97, 0xd5, 0xa9, 0xf0, 0xab, 0x1f, 0x33, 0xf8, 0x4b, 0xe1, 0x1d, 0xef,
+  0x8a, 0x9c, 0x4e, 0x91, 0x5b, 0xdb, 0xa0, 0xfd, 0xe4, 0xb7, 0x72, 0x28,
+  0x61, 0xe5, 0x95, 0xf9, 0xc0, 0xc2, 0xf7, 0x19, 0xe0, 0x30, 0xfa, 0x7a,
+  0xfd, 0x71, 0xfb, 0x25, 0xe8, 0x7f, 0x0f, 0x3e, 0x16, 0x6a, 0x1a, 0xbd,
+  0x87, 0x89, 0xfc, 0x2f, 0x2f, 0x88, 0xb4, 0x2b, 0x90, 0x9e, 0x4a, 0xce,
+  0xcb, 0x13, 0x49, 0x2a, 0x79, 0x7b, 0x18, 0x36, 0x32, 0xa8, 0xa1, 0x08,
+  0x21, 0x79, 0x6c, 0xf2, 0x48, 0xc8, 0x39, 0xdf, 0xd9, 0xf7, 0x9a, 0x8d,
+  0xef, 0xf6, 0x76, 0x83, 0x17, 0x93, 0x63, 0xc4, 0x4e, 0x07, 0xca, 0xac,
+  0x83, 0x19, 0x50, 0x07, 0x18, 0x24, 0x72, 0x3b, 0xd7, 0xbf, 0x78, 0x47,
+  0x47, 0xba, 0xb7, 0x85, 0x60, 0x65, 0x55, 0x03, 0x00, 0x2e, 0x2b, 0xee,
+  0x72, 0x6c, 0xb1, 0x42, 0x3c, 0xd2, 0xd7, 0xfa, 0xec, 0x7a, 0x15, 0x30,
+  0x91, 0xa2, 0xb9, 0x6f, 0x77, 0xd4, 0xf0, 0xaf, 0xda, 0x57, 0x43, 0xd1,
+  0x3e, 0x2a, 0x78, 0x9e, 0xe7, 0x50, 0xd2, 0x34, 0xd1, 0xe1, 0xdb, 0x0f,
+  0xb1, 0x0b, 0x4b, 0x3b, 0x68, 0xc6, 0xf8, 0x2d, 0xe3, 0x43, 0xb8, 0xa9,
+  0x0a, 0xab, 0x92, 0x5c, 0xb3, 0x64, 0x11, 0xd4, 0xf0, 0x73, 0x5f, 0x1e,
+  0x6a, 0xdf, 0x08, 0xfc, 0x75, 0xe1, 0x9b, 0x86, 0xd4, 0x6c, 0xad, 0xcd,
+  0xd5, 0x9e, 0xed, 0xc9, 0x79, 0xa7, 0x6d, 0x9c, 0x15, 0xf5, 0x28, 0x14,
+  0x32, 0x9f, 0xe1, 0xc1, 0xed, 0xd6, 0xbf, 0x5f, 0x2e, 0xb4, 0x1b, 0x59,
+  0x20, 0xff, 0x00, 0x49, 0x8e, 0x36, 0x53, 0xc3, 0x02, 0xb9, 0xfa, 0xd7,
+  0x99, 0x6a, 0x9e, 0x0b, 0xb5, 0xd3, 0xa5, 0x6d, 0x43, 0xc3, 0xbf, 0xba,
+  0x75, 0x53, 0xfe, 0x8f, 0x92, 0x22, 0x6e, 0x0f, 0x61, 0xd3, 0xaf, 0x51,
+  0x9f, 0xa1, 0xac, 0xb1, 0xd9, 0x54, 0x3d, 0xe9, 0x45, 0x5a, 0xfd, 0xbb,
+  0xfa, 0x1a, 0x53, 0xc3, 0xc2, 0x7a, 0x3d, 0x0f, 0xc6, 0x1b, 0xeb, 0xa6,
+  0x9a, 0xe6, 0x6b, 0x29, 0xd4, 0x89, 0xae, 0x5d, 0xc4, 0x8c, 0x4e, 0xd6,
+  0x8d, 0x14, 0x91, 0x86, 0xe3, 0x71, 0x2b, 0x8c, 0x16, 0x00, 0xe0, 0xe4,
+  0x06, 0xc7, 0x15, 0xf3, 0xc6, 0xb9, 0x35, 0x8c, 0x37, 0x37, 0x16, 0x79,
+  0x96, 0x19, 0x15, 0xb6, 0x18, 0x18, 0xfd, 0x0f, 0x27, 0xaa, 0x93, 0xd8,
+  0x73, 0xe9, 0x5f, 0xaf, 0xbf, 0x15, 0x34, 0x8f, 0x08, 0xea, 0x2f, 0x22,
+  0x78, 0xab, 0x47, 0xf2, 0x59, 0xed, 0xc2, 0x9b, 0xc5, 0x86, 0x3f, 0x3d,
+  0x9d, 0x37, 0x31, 0x55, 0x93, 0x69, 0x47, 0x05, 0x86, 0xe0, 0x0e, 0x18,
+  0x67, 0x27, 0x04, 0x1a, 0xf8, 0xef, 0xc6, 0x5f, 0xb3, 0xdd, 0x85, 0xcc,
+  0x92, 0x4d, 0xe1, 0x7b, 0xfd, 0xc6, 0x44, 0x32, 0x3f, 0x9a, 0x42, 0x3b,
+  0x21, 0x3c, 0x06, 0x60, 0x06, 0x49, 0x27, 0x9e, 0xa4, 0x67, 0x8c, 0x57,
+  0x91, 0x43, 0x0f, 0x28, 0xb7, 0x73, 0x5a, 0xb4, 0x1c, 0x1d, 0xb7, 0xf4,
+  0x3e, 0x2a, 0xb0, 0xd4, 0xad, 0x64, 0xbe, 0xb6, 0x26, 0x37, 0x91, 0xfc,
+  0xc2, 0x24, 0x88, 0x44, 0x1f, 0xe4, 0xc6, 0x03, 0x01, 0xcf, 0xd0, 0xfd,
+  0x72, 0x31, 0xd6, 0xb5, 0x24, 0x16, 0x6d, 0x71, 0x15, 0xd4, 0x1f, 0xea,
+  0xf8, 0x0d, 0xb4, 0x29, 0xc9, 0x66, 0xe5, 0x7b, 0xf7, 0x18, 0xe3, 0x23,
+  0x9a, 0xee, 0xb5, 0xff, 0x00, 0x85, 0x3e, 0x2a, 0xf0, 0xf2, 0x07, 0xfe,
+  0xcf, 0xb8, 0x96, 0x4d, 0x9e, 0x4b, 0xc9, 0x19, 0x67, 0x0c, 0xa5, 0x89,
+  0xdd, 0xc9, 0x5e, 0x7b, 0x92, 0x7d, 0x7a, 0x1c, 0x57, 0x0f, 0x07, 0x87,
+  0xb5, 0x48, 0xa6, 0x68, 0x75, 0x1b, 0x39, 0x20, 0x64, 0x5d, 0xf1, 0x32,
+  0x2e, 0xcc, 0x95, 0xe7, 0x18, 0xc1, 0xc9, 0xcf, 0x1c, 0x7f, 0x8d, 0x74,
+  0x73, 0x2e, 0xe6, 0x0e, 0x5e, 0x56, 0x1d, 0x7d, 0x7a, 0xd0, 0x13, 0x15,
+  0xa2, 0xb0, 0x06, 0x4f, 0xde, 0x09, 0x0f, 0x4e, 0x70, 0x38, 0x07, 0x18,
+  0xc0, 0xee, 0x3b, 0xfb, 0xd4, 0x77, 0xfa, 0xc5, 0x9c, 0x60, 0x4e, 0x65,
+  0x7c, 0x7c, 0xa8, 0x91, 0x82, 0xca, 0xa0, 0x05, 0x00, 0x9f, 0x9b, 0x27,
+  0x38, 0x1e, 0xa4, 0x56, 0x6d, 0xc4, 0x17, 0xb7, 0xf7, 0x96, 0xf1, 0x3c,
+  0x7e, 0x53, 0x4a, 0x86, 0x10, 0xf2, 0xa8, 0x0c, 0x0a, 0x64, 0xfc, 0xdc,
+  0xe4, 0x0c, 0xf4, 0xef, 0xf5, 0xad, 0x23, 0xa1, 0xcb, 0x7b, 0x32, 0x3d,
+  0xa4, 0x0f, 0xe5, 0x8f, 0x97, 0x6c, 0x03, 0xcc, 0x05, 0xcf, 0x38, 0x1c,
+  0x6e, 0xf5, 0x1d, 0x3b, 0x13, 0xcf, 0x35, 0x1a, 0x2b, 0x5c, 0x9f, 0x6a,
+  0x96, 0xe6, 0xbd, 0xa6, 0xbf, 0xa7, 0xa5, 0xc2, 0xc9, 0x76, 0x44, 0x8a,
+  0x8a, 0x4c, 0x6a, 0x41, 0x07, 0x9f, 0xef, 0x05, 0x6e, 0x3e, 0xa0, 0xe7,
+  0xb7, 0xbd, 0x6e, 0x4f, 0xa9, 0xd9, 0xcf, 0x0f, 0x51, 0x18, 0xc9, 0xf9,
+  0x09, 0xe4, 0x03, 0xf3, 0x75, 0xec, 0x49, 0x03, 0x27, 0xd3, 0x8c, 0xfa,
+  0x79, 0xdd, 0x8d, 0x8f, 0xcf, 0xf6, 0x84, 0x57, 0x50, 0x66, 0xf2, 0x55,
+  0x98, 0xe5, 0x77, 0xe0, 0xed, 0x03, 0x04, 0x10, 0xcc, 0x01, 0xc0, 0x00,
+  0xd6, 0x9d, 0x96, 0x93, 0xad, 0x2e, 0xa4, 0xd2, 0xc3, 0x69, 0x36, 0x4c,
+  0x82, 0x39, 0x91, 0x9d, 0x4e, 0x32, 0x33, 0x85, 0x5e, 0x30, 0x57, 0xa8,
+  0xef, 0xb7, 0x3e, 0xf5, 0x9c, 0xe1, 0xd7, 0x98, 0x4e, 0x6a, 0xfd, 0x8f,
+  0x5a, 0xf0, 0xe6, 0xb1, 0x6d, 0x69, 0x72, 0x93, 0x5c, 0x22, 0xef, 0xc8,
+  0x70, 0x24, 0x01, 0x80, 0x3c, 0x6d, 0xda, 0x7d, 0xbf, 0x9f, 0xd6, 0xbe,
+  0xe2, 0xf8, 0x57, 0xe3, 0xad, 0x32, 0x3b, 0x28, 0x8c, 0x8b, 0x24, 0x32,
+  0xc5, 0x3a, 0xc8, 0xb1, 0x33, 0xb6, 0x33, 0x91, 0xb9, 0x98, 0x82, 0x70,
+  0xbc, 0x06, 0x2c, 0x3f, 0x0e, 0x79, 0xaf, 0x82, 0x2d, 0x3c, 0x0f, 0xe3,
+  0x0b, 0xd9, 0x73, 0x6b, 0x6d, 0x73, 0xe4, 0x49, 0x1f, 0x9d, 0x0d, 0xd1,
+  0x86, 0x53, 0x13, 0xb8, 0xcf, 0xee, 0xd6, 0x50, 0x98, 0xdf, 0x91, 0x80,
+  0xa0, 0x1e, 0x7f, 0x0a, 0xe8, 0x74, 0xeb, 0x3f, 0x88, 0xba, 0x86, 0x97,
+  0x1b, 0x69, 0x7a, 0x76, 0xa2, 0x2e, 0x16, 0x7f, 0x24, 0xce, 0xdb, 0xed,
+  0x8c, 0x6a, 0x71, 0x90, 0xde, 0x62, 0x80, 0x72, 0x0f, 0x1e, 0x9f, 0x4e,
+  0x2b, 0xe6, 0x33, 0x6c, 0x99, 0x62, 0x55, 0x9b, 0x30, 0x71, 0xe6, 0x7e,
+  0xe9, 0xf7, 0xb2, 0xfc, 0x5b, 0xd6, 0x62, 0xf1, 0x1a, 0x6a, 0x67, 0x51,
+  0x8a, 0x38, 0x22, 0xd4, 0x96, 0x27, 0xb6, 0x8a, 0x55, 0xc8, 0xb6, 0xdb,
+  0x86, 0xda, 0xb2, 0x3a, 0x17, 0x0c, 0x31, 0x8f, 0xbc, 0x31, 0x92, 0x00,
+  0xcd, 0x7e, 0xa6, 0x78, 0x7f, 0xe3, 0x65, 0xce, 0xab, 0x63, 0xa7, 0x5b,
+  0x78, 0x46, 0x59, 0x6f, 0x4d, 0xc1, 0x5b, 0x79, 0x5a, 0xd9, 0x15, 0x59,
+  0x23, 0x45, 0x6c, 0xef, 0xda, 0xc0, 0x05, 0x04, 0x0e, 0xa4, 0x0e, 0xc7,
+  0x23, 0x15, 0xf8, 0xdd, 0xe0, 0x9f, 0x80, 0x7e, 0x35, 0xf1, 0x1b, 0x5b,
+  0x6a, 0x1a, 0xad, 0xff, 0x00, 0x9a, 0xb0, 0xa8, 0x13, 0xda, 0x5b, 0xe9,
+  0xe9, 0x72, 0xf2, 0x30, 0x65, 0x2c, 0x10, 0xac, 0x6a, 0xbf, 0x75, 0x80,
+  0xce, 0xf3, 0x9e, 0x9c, 0x8c, 0xd7, 0xeb, 0xc7, 0xc0, 0x9f, 0x83, 0x53,
+  0xf8, 0x53, 0x47, 0xfb, 0x27, 0x89, 0xe5, 0x5f, 0xb0, 0x96, 0x59, 0x62,
+  0xb0, 0xb7, 0x50, 0x92, 0xb0, 0xe9, 0x8b, 0x86, 0x0a, 0x15, 0x41, 0x00,
+  0x7c, 0x88, 0x38, 0xc9, 0x19, 0xef, 0x5f, 0x23, 0x5b, 0x82, 0xea, 0x62,
+  0x2b, 0xd3, 0x78, 0x58, 0xdd, 0xa5, 0x67, 0xd1, 0x5b, 0xcd, 0xe9, 0xff,
+  0x00, 0x04, 0xd1, 0xe5, 0xb2, 0x6b, 0x9a, 0x5a, 0x23, 0xe9, 0xfd, 0x3b,
+  0xe0, 0xff, 0x00, 0x84, 0xfe, 0x31, 0x38, 0xbc, 0xf1, 0x04, 0x4f, 0x0f,
+  0x97, 0xe5, 0xa9, 0x7b, 0x59, 0x1d, 0x21, 0xca, 0x15, 0x93, 0x6b, 0x61,
+  0xb6, 0xb1, 0x2d, 0x86, 0x05, 0x70, 0x31, 0x81, 0xd2, 0xbd, 0x4e, 0x7f,
+  0xd9, 0xef, 0xe0, 0x9d, 0x96, 0x8e, 0x9a, 0x24, 0x9a, 0x4e, 0x97, 0x3c,
+  0x51, 0xc3, 0xe4, 0xa2, 0xdc, 0xdb, 0xa3, 0x90, 0xbd, 0x86, 0x71, 0xf9,
+  0x73, 0x5c, 0x95, 0xbf, 0x8d, 0x61, 0xd3, 0x6c, 0xe3, 0xb0, 0xd3, 0x42,
+  0xc5, 0x6f, 0x0a, 0x08, 0xa3, 0x8a, 0x3f, 0xba, 0x00, 0xfa, 0x1f, 0xcf,
+  0xd6, 0xb9, 0xad, 0x4b, 0xe2, 0x0c, 0x92, 0x92, 0x4b, 0x3b, 0x63, 0x8e,
+  0x4f, 0xff, 0x00, 0x5e, 0xbf, 0x64, 0xe1, 0x8e, 0x0f, 0x86, 0x06, 0x17,
+  0xab, 0x2e, 0x79, 0xbf, 0xb9, 0x7a, 0x2f, 0xe9, 0x8d, 0x51, 0xa7, 0x0f,
+  0x81, 0x7c, 0xcf, 0xff, 0xd4, 0xfc, 0xf5, 0xd6, 0xfc, 0x43, 0x2d, 0xc4,
+  0x4d, 0xf3, 0x6e, 0xe4, 0xaf, 0x3c, 0xfa, 0xfb, 0xd7, 0x91, 0x6a, 0xb3,
+  0x1b, 0xe2, 0x60, 0x7f, 0x98, 0x13, 0x8e, 0xbd, 0xbf, 0xc6, 0xbd, 0x0e,
+  0x4d, 0x13, 0x52, 0x74, 0x92, 0x47, 0x7b, 0x40, 0x01, 0xe5, 0x5a, 0x43,
+  0xb8, 0xf5, 0xce, 0x3e, 0x4e, 0x6b, 0x88, 0xd5, 0xf4, 0xbb, 0xa8, 0xd7,
+  0x7c, 0x53, 0xc5, 0xd4, 0x6e, 0x50, 0x84, 0x1c, 0x13, 0xce, 0x18, 0xf1,
+  0xfa, 0x7f, 0x4a, 0xec, 0xc4, 0x54, 0x8c, 0xa2, 0xe2, 0xf5, 0x39, 0x68,
+  0xc1, 0xa6, 0xa4, 0x8f, 0x25, 0xbc, 0xd1, 0x20, 0xd3, 0xee, 0x64, 0xbd,
+  0x8c, 0xdc, 0x65, 0x6d, 0xe5, 0xd8, 0xb0, 0x29, 0x33, 0x0d, 0xaa, 0xdd,
+  0x24, 0x55, 0xe0, 0x73, 0x8c, 0x6e, 0x52, 0xc0, 0x90, 0x49, 0xcd, 0x60,
+  0xfc, 0x3e, 0xd2, 0x87, 0x88, 0x7c, 0x52, 0x3c, 0x2f, 0x73, 0x2c, 0xf6,
+  0x37, 0x12, 0x79, 0xfe, 0x6d, 0xd5, 0xce, 0x10, 0x44, 0xd1, 0x92, 0x71,
+  0xe5, 0xae, 0x3e, 0x7e, 0x76, 0xae, 0xe2, 0x76, 0x90, 0x39, 0xcd, 0x7a,
+  0xac, 0xd0, 0x49, 0x6e, 0x99, 0x79, 0x19, 0x58, 0x1c, 0x87, 0x42, 0x72,
+  0x0f, 0x3c, 0xe7, 0x8d, 0xbd, 0x7f, 0xfa, 0xf5, 0xc5, 0xdf, 0x45, 0x02,
+  0xce, 0x97, 0x56, 0xe8, 0xad, 0x34, 0x4c, 0x76, 0xcc, 0xa3, 0x6b, 0x0d,
+  0xdd, 0x79, 0x5f, 0xf3, 0xf5, 0xed, 0xf1, 0x15, 0x38, 0x7f, 0xdf, 0xe6,
+  0x7a, 0xa7, 0xd0, 0xee, 0xab, 0x4e, 0x95, 0x49, 0x49, 0xcb, 0x46, 0xcd,
+  0x7d, 0x47, 0xe1, 0xe6, 0xaf, 0xa7, 0x6a, 0xa2, 0xf2, 0xc6, 0xe1, 0xae,
+  0x60, 0x03, 0xca, 0x54, 0x9d, 0x17, 0x7b, 0x47, 0x92, 0x49, 0x46, 0x8c,
+  0x2b, 0x2e, 0x49, 0xdd, 0xd7, 0x3c, 0x9c, 0xe4, 0xf4, 0xe1, 0x23, 0xf0,
+  0x4e, 0xb1, 0x65, 0x3b, 0x6a, 0x5f, 0x66, 0x49, 0xdd, 0xc4, 0xa6, 0x55,
+  0x72, 0xec, 0xaa, 0xee, 0xac, 0xa5, 0x81, 0x27, 0xb9, 0xc6, 0x39, 0x53,
+  0x8c, 0x8c, 0x30, 0x27, 0x3d, 0xbb, 0x78, 0xfb, 0x59, 0xb4, 0x78, 0xe2,
+  0x99, 0x1a, 0xe2, 0xdd, 0x54, 0x80, 0xb3, 0xa0, 0x0c, 0xc1, 0x80, 0xc8,
+  0x05, 0x46, 0x38, 0xc1, 0xc7, 0xf1, 0x11, 0xcf, 0x1d, 0x06, 0x85, 0x8f,
+  0xc4, 0x1f, 0x0f, 0x5f, 0x06, 0x92, 0x13, 0x3c, 0x4a, 0xcc, 0xce, 0x8b,
+  0x90, 0xd1, 0x6f, 0x6e, 0xa0, 0xf0, 0xe3, 0xef, 0x77, 0x03, 0x38, 0xed,
+  0x53, 0x53, 0x23, 0xa1, 0x2d, 0x52, 0xe5, 0xf4, 0xff, 0x00, 0x23, 0x92,
+  0xa6, 0x5d, 0x09, 0x69, 0xcb, 0xf7, 0x1e, 0x19, 0x7b, 0x61, 0x3d, 0xcc,
+  0x0b, 0x69, 0x71, 0xa7, 0xcd, 0x6e, 0x86, 0x5b, 0x78, 0xcd, 0xe1, 0x47,
+  0x72, 0x15, 0x48, 0xdd, 0xbe, 0x40, 0x54, 0x31, 0x04, 0xe0, 0x60, 0xaa,
+  0xe0, 0x75, 0xe4, 0x63, 0x99, 0x99, 0x2c, 0x2e, 0x6d, 0x4a, 0x4a, 0x65,
+  0x0d, 0xb4, 0xa9, 0x29, 0x0c, 0x91, 0x89, 0x3e, 0x62, 0x85, 0x42, 0x01,
+  0x95, 0x07, 0x9d, 0xd9, 0xc1, 0xc0, 0x07, 0xb9, 0xaf, 0xab, 0x91, 0xb4,
+  0xcd, 0x52, 0x63, 0x3b, 0xc9, 0x6e, 0x4a, 0xc5, 0x2c, 0x8b, 0x10, 0x60,
+  0xa3, 0x7e, 0x17, 0x6a, 0xed, 0xce, 0xef, 0xef, 0x0c, 0x90, 0x3a, 0xd6,
+  0xb5, 0x9d, 0xb5, 0xaf, 0xd9, 0x53, 0x61, 0xb4, 0x2c, 0xec, 0x44, 0x83,
+  0x80, 0x23, 0x1d, 0x41, 0xeb, 0x93, 0xc6, 0x3f, 0x3a, 0xc6, 0x39, 0x14,
+  0x7f, 0x9d, 0x99, 0x4b, 0x28, 0x82, 0x7b, 0xff, 0x00, 0x5e, 0xa7, 0xc9,
+  0xf6, 0x70, 0xc3, 0x2c, 0xfe, 0x45, 0xcc, 0x93, 0x8d, 0xee, 0xde, 0x4c,
+  0x31, 0xc1, 0x1c, 0x64, 0x06, 0x47, 0x04, 0x65, 0x9f, 0x8c, 0x7d, 0xe2,
+  0xdb, 0xba, 0xfc, 0xc3, 0x3c, 0x8a, 0xb3, 0xff, 0x00, 0x08, 0x84, 0x1a,
+  0x9d, 0xf8, 0x96, 0xc6, 0x1d, 0x48, 0x4b, 0x2f, 0xef, 0x6d, 0xe6, 0x16,
+  0xeb, 0xb4, 0x1d, 0xfb, 0x04, 0x72, 0x67, 0x66, 0xc5, 0xc1, 0x27, 0x93,
+  0xf7, 0x78, 0xea, 0x54, 0x57, 0xd2, 0xf1, 0x49, 0xe1, 0x7d, 0x3e, 0x36,
+  0x37, 0xb3, 0xdb, 0x2f, 0x96, 0xc4, 0x44, 0xa6, 0x36, 0x6c, 0x6d, 0x38,
+  0xe7, 0xa0, 0x1c, 0x74, 0xc7, 0xd2, 0xb4, 0xe3, 0xf1, 0x27, 0x84, 0xde,
+  0xe4, 0xcd, 0x6d, 0x22, 0x22, 0xc6, 0x59, 0x1a, 0x40, 0x8a, 0xa4, 0xa6,
+  0xd1, 0x80, 0x77, 0x1e, 0x4e, 0xe2, 0x48, 0x1c, 0x0f, 0xd7, 0x35, 0xfd,
+  0x81, 0x1b, 0xfc, 0x6c, 0xca, 0x39, 0x5c, 0x6e, 0xec, 0xcf, 0x27, 0xb0,
+  0xf8, 0x7b, 0xe2, 0x49, 0xaf, 0x21, 0x9b, 0x50, 0x68, 0xad, 0xd6, 0x2c,
+  0x79, 0x33, 0x6d, 0x0f, 0xb1, 0x98, 0x10, 0x43, 0x60, 0x00, 0x4b, 0x6e,
+  0x27, 0x2d, 0xc7, 0xa1, 0xe1, 0x6b, 0xb2, 0xb1, 0xf0, 0x5f, 0x87, 0xb4,
+  0x2d, 0xb3, 0x5f, 0x6f, 0xbb, 0x9f, 0xe6, 0x63, 0xb1, 0x40, 0xca, 0x96,
+  0xe7, 0x19, 0xc2, 0x00, 0x0e, 0x07, 0x27, 0x8c, 0x0e, 0x6a, 0x29, 0xfe,
+  0x22, 0x5b, 0xcf, 0xa7, 0x7f, 0x66, 0xdb, 0x87, 0x99, 0xa2, 0xb8, 0xf3,
+  0x1a, 0x49, 0x48, 0x05, 0xa4, 0x5c, 0x05, 0x6f, 0x94, 0xed, 0xc7, 0xa0,
+  0xfe, 0x7d, 0x2b, 0x13, 0x54, 0xd7, 0x3c, 0x49, 0xe2, 0xd9, 0x22, 0xb9,
+  0x79, 0x16, 0x4f, 0x25, 0x76, 0xa3, 0x31, 0xdd, 0x86, 0x24, 0xb3, 0x85,
+  0x50, 0x02, 0xa7, 0x61, 0xc0, 0x62, 0x7b, 0xfa, 0xd7, 0x65, 0x1c, 0xaa,
+  0x94, 0x15, 0xe0, 0xb5, 0xf3, 0xd4, 0xf5, 0x28, 0x60, 0x29, 0x53, 0x9a,
+  0xba, 0xbf, 0xf5, 0xa7, 0xe2, 0x75, 0xed, 0xe2, 0x18, 0x24, 0x78, 0xe0,
+  0xb0, 0x80, 0xc6, 0xac, 0x4f, 0xee, 0x51, 0xb0, 0xc5, 0x08, 0x3b, 0x59,
+  0xc9, 0x00, 0x8c, 0x75, 0xc2, 0x9c, 0x67, 0xb9, 0xe2, 0xb5, 0x60, 0xd2,
+  0x2e, 0xb5, 0x89, 0x59, 0xa6, 0x04, 0x2b, 0x48, 0x5d, 0xa4, 0x93, 0x82,
+  0x4b, 0x72, 0xca, 0x14, 0x1c, 0x01, 0x9f, 0xc7, 0xe8, 0x38, 0xac, 0xff,
+  0x00, 0x0d, 0xe8, 0xd8, 0x6f, 0xb5, 0x5d, 0x84, 0xdd, 0xd4, 0x28, 0x18,
+  0xc7, 0x7c, 0x12, 0x49, 0x24, 0x8f, 0x5e, 0x3e, 0x95, 0xe9, 0xd6, 0x08,
+  0x87, 0x01, 0x41, 0x03, 0xeb, 0xce, 0x6b, 0xd4, 0xc3, 0x60, 0xde, 0xf2,
+  0x67, 0x6e, 0x2b, 0x18, 0x9e, 0x90, 0x8a, 0x4b, 0xfa, 0xea, 0x49, 0xa6,
+  0x68, 0xb1, 0x5a, 0x22, 0xc5, 0x0e, 0x06, 0xda, 0xf4, 0xad, 0x22, 0x76,
+  0x84, 0x2a, 0x37, 0xcc, 0x07, 0x1e, 0xe2, 0xb9, 0xb8, 0x15, 0x54, 0x02,
+  0x79, 0xfe, 0x75, 0xa7, 0x0b, 0x88, 0xf9, 0xf6, 0xc8, 0x15, 0xeb, 0x41,
+  0xd9, 0x59, 0x1e, 0x3c, 0xb5, 0x77, 0x67, 0x77, 0x2d, 0xd2, 0x49, 0x6f,
+  0xb7, 0xb8, 0xae, 0x0b, 0x56, 0x97, 0x69, 0x2c, 0xa4, 0x83, 0xcf, 0x35,
+  0x64, 0xdf, 0x29, 0x53, 0xbc, 0x8c, 0x8e, 0x99, 0xf5, 0xe9, 0xf8, 0x56,
+  0x3d, 0xf3, 0x79, 0x89, 0xf3, 0x77, 0x1c, 0x67, 0xf2, 0xc8, 0xfc, 0x8d,
+  0x4f, 0x37, 0x71, 0xd8, 0xf3, 0x7f, 0x13, 0x47, 0x06, 0xa3, 0x68, 0xf6,
+  0xb7, 0xa8, 0xb2, 0xa3, 0x8c, 0x32, 0xb2, 0x82, 0x1b, 0xea, 0x08, 0xc1,
+  0xaf, 0x96, 0x3c, 0x47, 0xf0, 0xd9, 0x12, 0xe9, 0xae, 0x74, 0x3b, 0x99,
+  0xa0, 0x24, 0xe7, 0x63, 0x13, 0x24, 0x7d, 0x7a, 0x0c, 0x9d, 0xc0, 0x7d,
+  0x1b, 0x03, 0xb0, 0xaf, 0xae, 0x35, 0x0b, 0x60, 0xcb, 0x90, 0x41, 0xed,
+  0xb6, 0xb8, 0x2d, 0x4b, 0x4a, 0x56, 0xc9, 0xc0, 0xcf, 0x3d, 0x2b, 0x9e,
+  0xae, 0x1a, 0x2c, 0xda, 0x13, 0x3e, 0x42, 0xd4, 0x34, 0x9f, 0x1a, 0x69,
+  0xb9, 0x01, 0x3c, 0xe8, 0xd7, 0xa2, 0xc7, 0xf3, 0x21, 0xe3, 0x18, 0x2a,
+  0x71, 0xc7, 0x7e, 0x87, 0xfa, 0xd6, 0x2d, 0xe6, 0xa3, 0xa3, 0x79, 0x65,
+  0xb5, 0xdd, 0x3e, 0x0d, 0xe0, 0x11, 0xb5, 0xe1, 0xda, 0xd9, 0xe3, 0xaf,
+  0xdd, 0x18, 0xeb, 0x5f, 0x56, 0x5c, 0xe8, 0xce, 0xd9, 0xe8, 0x7d, 0x88,
+  0xfe, 0x95, 0x8b, 0x36, 0x83, 0xbd, 0x4a, 0xb4, 0x2a, 0xc0, 0xfa, 0x01,
+  0xd0, 0x7a, 0xf6, 0xae, 0x29, 0xe1, 0x1f, 0x73, 0x4b, 0xa3, 0xe5, 0xdb,
+  0x38, 0x7e, 0x1d, 0xde, 0x62, 0xe0, 0xe9, 0xe1, 0xa3, 0x6d, 0xdb, 0xc2,
+  0xb8, 0x40, 0xa7, 0x8e, 0x3e, 0xe3, 0x72, 0x39, 0xfc, 0xb1, 0x57, 0xed,
+  0x3c, 0x39, 0xf0, 0xce, 0x69, 0x8d, 0xcc, 0x5a, 0x5d, 0xd6, 0x76, 0x6f,
+  0xdd, 0x95, 0x24, 0x91, 0xd8, 0x1c, 0x03, 0xeb, 0xfe, 0x4d, 0x7b, 0xb4,
+  0x9e, 0x17, 0xd2, 0x18, 0x9d, 0xd6, 0x30, 0xb1, 0x27, 0xf8, 0xa2, 0x42,
+  0x7d, 0xc7, 0x23, 0x9f, 0xeb, 0x51, 0x8f, 0x05, 0xf8, 0x73, 0x70, 0x5f,
+  0xec, 0xf8, 0x49, 0xcf, 0x43, 0x12, 0xfe, 0x9c, 0x0a, 0xe6, 0xa9, 0x81,
+  0x93, 0xe8, 0x1c, 0x90, 0x7b, 0x9e, 0x57, 0xa6, 0xe9, 0x9f, 0x08, 0x62,
+  0x85, 0x6e, 0x9b, 0x48, 0xf3, 0x16, 0x32, 0xca, 0x55, 0xcc, 0x4a, 0x78,
+  0x04, 0xe4, 0x10, 0x8c, 0x7e, 0xf0, 0x1c, 0xfe, 0x23, 0x15, 0xd5, 0x78,
+  0x6a, 0xef, 0xc1, 0xf3, 0x5e, 0x05, 0xd0, 0x7c, 0x33, 0x63, 0x3b, 0x12,
+  0x0b, 0xac, 0xca, 0x67, 0x6c, 0x8e, 0x87, 0x8d, 0x87, 0x83, 0x8e, 0x06,
+  0x4f, 0x53, 0x8a, 0xf4, 0xdd, 0x2f, 0xc2, 0x3a, 0x0d, 0x86, 0xd4, 0xb7,
+  0xd3, 0x6d, 0xd7, 0x03, 0x0a, 0x7c, 0xb4, 0xe3, 0xa7, 0xb1, 0xf4, 0xaf,
+  0x49, 0xd3, 0xed, 0xee, 0x17, 0x68, 0x2a, 0x8a, 0xbc, 0x74, 0x1c, 0x0e,
+  0xc3, 0xdb, 0xf2, 0xac, 0x7f, 0xb3, 0x1b, 0xf2, 0x29, 0x46, 0x9a, 0xd6,
+  0xc7, 0x1f, 0xa7, 0xe9, 0xbf, 0x12, 0xaf, 0xf4, 0x7b, 0xed, 0x2f, 0x40,
+  0xd3, 0xac, 0x74, 0xd4, 0xbb, 0x86, 0x55, 0x48, 0xe6, 0x88, 0x47, 0x1b,
+  0x3b, 0xfd, 0xd6, 0x64, 0x20, 0xb9, 0xc1, 0x19, 0xf9, 0x88, 0x00, 0xf3,
+  0xcf, 0x7e, 0xe3, 0xc0, 0xdf, 0x09, 0x35, 0x61, 0x27, 0x93, 0xe2, 0x2b,
+  0x78, 0xe6, 0xb8, 0x0b, 0x87, 0x96, 0xd9, 0x5a, 0x4c, 0x2f, 0xca, 0x49,
+  0x52, 0x88, 0xb9, 0xc9, 0x56, 0x01, 0x41, 0x64, 0x03, 0xb6, 0x4f, 0x1d,
+  0x7e, 0x94, 0xf2, 0xc5, 0xb6, 0x3b, 0x99, 0x18, 0xa2, 0x9f, 0x95, 0x41,
+  0x20, 0x0e, 0x7a, 0x81, 0xd0, 0x57, 0xa4, 0xd8, 0x78, 0x96, 0x5d, 0x3e,
+  0x31, 0x1c, 0x07, 0x80, 0x06, 0x72, 0x3b, 0x7a, 0x7b, 0xfb, 0x57, 0x47,
+  0xf6, 0x34, 0x24, 0x92, 0x92, 0xd8, 0x4a, 0x70, 0x4e, 0xfc, 0xa7, 0x43,
+  0xe1, 0x99, 0x74, 0x3d, 0x06, 0x33, 0x69, 0xa6, 0xc7, 0x15, 0xbe, 0x3f,
+  0x76, 0xdb, 0x14, 0x07, 0x24, 0x1e, 0x43, 0x77, 0xe0, 0x71, 0x8a, 0xeb,
+  0x64, 0xf1, 0x7f, 0x96, 0x9b, 0x15, 0xd7, 0x00, 0xf0, 0xa5, 0x8e, 0x4f,
+  0x15, 0xc3, 0x4d, 0xe2, 0x4d, 0x2b, 0x55, 0x1b, 0x35, 0x68, 0x62, 0x91,
+  0xc2, 0x05, 0xdc, 0xea, 0x32, 0xa0, 0x67, 0x18, 0x6c, 0x86, 0x1d, 0x7f,
+  0x85, 0x85, 0x65, 0xde, 0x68, 0x3a, 0x45, 0xde, 0x1a, 0xc6, 0xe2, 0xe2,
+  0x22, 0x48, 0x65, 0x57, 0x61, 0x2a, 0x9c, 0xfa, 0x67, 0x0d, 0xf4, 0xcb,
+  0x1a, 0xf7, 0xf0, 0xd0, 0x8d, 0x38, 0xa4, 0x95, 0x8c, 0x2b, 0x49, 0xcd,
+  0xdd, 0xbb, 0x9e, 0xad, 0xa4, 0xf8, 0x82, 0xd2, 0xee, 0xec, 0xa6, 0xb7,
+  0x78, 0x6c, 0xa0, 0xf2, 0x8b, 0x89, 0x21, 0x8c, 0xc9, 0x97, 0x0d, 0x8d,
+  0x84, 0x0c, 0xed, 0xe3, 0x07, 0x38, 0x20, 0xf4, 0xe3, 0x1c, 0xf2, 0x7a,
+  0xc7, 0x8a, 0xd2, 0x2b, 0xd9, 0xad, 0x6c, 0x2e, 0x0d, 0xc5, 0xba, 0xfd,
+  0xcb, 0x86, 0x8c, 0xc4, 0x5b, 0x8e, 0x72, 0xa4, 0xe7, 0x83, 0x9e, 0x70,
+  0x01, 0xeb, 0xc5, 0x70, 0x12, 0xe9, 0x3a, 0xc4, 0x12, 0x7f, 0xa3, 0xcf,
+  0x06, 0x02, 0x9e, 0x5f, 0x7c, 0x7c, 0xfa, 0x9c, 0x06, 0xeb, 0xec, 0xd5,
+  0x9d, 0x35, 0x97, 0x88, 0x1f, 0x11, 0xb9, 0x87, 0x1b, 0x43, 0x63, 0xcc,
+  0x20, 0x71, 0xf5, 0x5e, 0xa7, 0x3f, 0xe4, 0xd6, 0xca, 0xa4, 0xb9, 0xee,
+  0x9e, 0x84, 0x49, 0x47, 0x96, 0xd6, 0xd4, 0xff, 0xd5, 0xfc, 0xde, 0x37,
+  0x64, 0x38, 0x3f, 0x2e, 0x17, 0x1b, 0x90, 0x16, 0x19, 0x5c, 0xf2, 0x7a,
+  0xf7, 0xac, 0x3b, 0xe3, 0xb9, 0x76, 0x64, 0x9f, 0x9b, 0x3d, 0x3b, 0xfe,
+  0x54, 0x2d, 0xec, 0x4d, 0x19, 0x32, 0x32, 0x82, 0xa8, 0x47, 0x97, 0xd9,
+  0x89, 0x20, 0x60, 0x60, 0x11, 0x91, 0xea, 0x70, 0x31, 0x9e, 0xfd, 0x72,
+  0xae, 0x2e, 0xf7, 0x92, 0x5b, 0x6e, 0x70, 0x4a, 0xaa, 0xe4, 0x64, 0x7e,
+  0x95, 0xd6, 0xac, 0x71, 0x5d, 0x98, 0x37, 0xd0, 0xdb, 0xb6, 0x4b, 0x02,
+  0xc7, 0x04, 0x03, 0x8e, 0x95, 0x85, 0xe4, 0x2b, 0x12, 0xa0, 0x0c, 0x74,
+  0xc5, 0x6f, 0x5d, 0x3b, 0x31, 0x3b, 0x32, 0x48, 0x19, 0x39, 0xf4, 0xef,
+  0x91, 0xd7, 0xf5, 0xac, 0xd5, 0xda, 0x8b, 0xb9, 0xf8, 0x18, 0xcb, 0x75,
+  0xe7, 0xdb, 0x35, 0x56, 0x56, 0xd0, 0xa5, 0x27, 0xd4, 0xcf, 0x6d, 0x3c,
+  0xb3, 0xee, 0xec, 0x3b, 0x91, 0xfc, 0xab, 0x16, 0x7f, 0x09, 0xe9, 0x4e,
+  0xb0, 0xc7, 0xe4, 0xa4, 0x6b, 0x0c, 0x86, 0x44, 0x58, 0xbe, 0x4c, 0x93,
+  0x9c, 0x86, 0x03, 0xa8, 0x39, 0xcf, 0x5e, 0xb5, 0xda, 0x2e, 0xc2, 0xdb,
+  0x94, 0x71, 0xfe, 0x73, 0xc5, 0x3f, 0x64, 0x00, 0x15, 0x39, 0xf9, 0xbb,
+  0x1f, 0x5a, 0xc6, 0x74, 0x53, 0xd1, 0x9a, 0x42, 0xab, 0x4f, 0x43, 0x88,
+  0x93, 0xc2, 0xd6, 0xa6, 0x32, 0xd6, 0xe6, 0x45, 0xde, 0x54, 0x67, 0xe5,
+  0x3b, 0x7d, 0xd4, 0x1e, 0x71, 0xc7, 0x72, 0x40, 0xa8, 0x9f, 0xc3, 0xd7,
+  0x0a, 0xc1, 0x61, 0xb8, 0x18, 0x53, 0x97, 0x18, 0xfb, 0xc4, 0xe0, 0x73,
+  0xcf, 0x07, 0x03, 0xe9, 0x5d, 0xd7, 0xca, 0x46, 0x06, 0x33, 0x9e, 0x49,
+  0xc7, 0x5a, 0x80, 0xc2, 0x00, 0xde, 0x70, 0x7d, 0x79, 0xeb, 0x5c, 0xef,
+  0x0a, 0x8d, 0xd6, 0x21, 0xf5, 0x3c, 0xff, 0x00, 0x50, 0xf0, 0xba, 0xcb,
+  0x07, 0x95, 0x2b, 0x02, 0xc7, 0x70, 0x1c, 0x93, 0xd7, 0xa6, 0x47, 0x43,
+  0x4c, 0xb4, 0xf0, 0xed, 0xb4, 0x5f, 0xbb, 0x6c, 0xb7, 0xcb, 0x8d, 0xc4,
+  0x00, 0xdc, 0x77, 0xca, 0x81, 0xc8, 0xae, 0xee, 0x68, 0x58, 0x2e, 0xe0,
+  0x73, 0x8f, 0x40, 0x7f, 0xad, 0x20, 0xb2, 0x0c, 0x37, 0x0c, 0x8c, 0xf4,
+  0x3c, 0x83, 0xf8, 0xf5, 0xfc, 0x6a, 0xbe, 0xab, 0x1e, 0xa2, 0xf6, 0xed,
+  0x98, 0xba, 0x5e, 0x89, 0xa3, 0x69, 0xb1, 0x94, 0xb7, 0xb7, 0x88, 0x17,
+  0x6d, 0xcc, 0x08, 0xea, 0x71, 0xd7, 0xbf, 0x4a, 0xe9, 0xad, 0x62, 0x83,
+  0xfe, 0x59, 0xa0, 0x03, 0xdb, 0x81, 0x8f, 0xf3, 0xff, 0x00, 0xea, 0xaa,
+  0x42, 0xd1, 0x51, 0x87, 0x72, 0x48, 0xca, 0x83, 0xf9, 0x91, 0xd7, 0x1f,
+  0xe7, 0xeb, 0x57, 0xe1, 0x04, 0x48, 0x15, 0x0e, 0xec, 0x0c, 0x72, 0x00,
+  0x3f, 0xfd, 0x7f, 0xd2, 0xb4, 0xf6, 0x29, 0x11, 0xed, 0x1b, 0x3a, 0x5b,
+  0x36, 0x5d, 0xc3, 0xe5, 0x38, 0xc6, 0x46, 0x3b, 0x77, 0xae, 0xa2, 0xd2,
+  0x44, 0x0a, 0x19, 0xb0, 0x0e, 0x33, 0xc7, 0x5f, 0x63, 0x5c, 0x3c, 0x37,
+  0x18, 0xc0, 0xfb, 0xa4, 0x0c, 0xe3, 0x20, 0x67, 0x1f, 0x5f, 0xe8, 0x6a,
+  0xec, 0x77, 0x8c, 0xa7, 0x78, 0x6c, 0x81, 0xc1, 0x04, 0xff, 0x00, 0xfa,
+  0xb2, 0x68, 0xe5, 0x44, 0xdf, 0xb9, 0xe9, 0x30, 0xdd, 0x03, 0xc6, 0xe0,
+  0x36, 0xe3, 0xfc, 0xf3, 0x52, 0x49, 0x78, 0x31, 0xc3, 0x77, 0xc0, 0x39,
+  0xaf, 0x3d, 0x3a, 0xb9, 0x4f, 0xf5, 0x7c, 0x8e, 0x83, 0x9e, 0x4f, 0xe3,
+  0x9a, 0xb6, 0xba, 0xb2, 0xb2, 0x00, 0xca, 0xa4, 0xf1, 0xcf, 0xcd, 0x9c,
+  0x0e, 0xbe, 0xdc, 0xe6, 0x95, 0x84, 0x75, 0xdf, 0x6e, 0xc9, 0xf9, 0xfa,
+  0x9f, 0x5f, 0x43, 0x51, 0xcb, 0x72, 0x79, 0x18, 0xe7, 0xbe, 0x0e, 0x71,
+  0x5c, 0x8b, 0xea, 0xd1, 0x46, 0x9b, 0xdf, 0x00, 0x03, 0x82, 0xc7, 0x3d,
+  0x01, 0xfc, 0x2a, 0x16, 0xd5, 0xff, 0x00, 0x79, 0x87, 0x60, 0x06, 0x70,
+  0x39, 0x1c, 0x8e, 0xfd, 0xe8, 0x71, 0x11, 0xb5, 0x34, 0xc4, 0x82, 0xc3,
+  0x1e, 0x9c, 0xf1, 0x9a, 0xc4, 0xb9, 0x40, 0xca, 0x46, 0x31, 0x8f, 0x5e,
+  0x08, 0xa7, 0xff, 0x00, 0x69, 0xc6, 0xec, 0x70, 0x09, 0xce, 0x71, 0x81,
+  0xc7, 0x7f, 0xa5, 0x52, 0x9a, 0xf1, 0x26, 0x5d, 0xdc, 0xe7, 0x39, 0xda,
+  0x39, 0x20, 0x76, 0xfa, 0x55, 0x72, 0x85, 0xca, 0x2f, 0x0f, 0xcc, 0x48,
+  0x1d, 0x4f, 0x39, 0x18, 0xe7, 0xdb, 0x15, 0x44, 0xc6, 0x26, 0x95, 0x62,
+  0x89, 0x43, 0x33, 0x30, 0x50, 0x07, 0x52, 0x49, 0xc0, 0x1d, 0x6a, 0xfb,
+  0x5c, 0xc6, 0xdf, 0xbc, 0x61, 0x81, 0x8c, 0x91, 0xfe, 0x35, 0x1c, 0x7b,
+  0x19, 0x8c, 0x88, 0xa1, 0x41, 0x07, 0x1d, 0x87, 0xff, 0x00, 0x5a, 0x87,
+  0x01, 0xa9, 0x99, 0x6d, 0xa7, 0xba, 0x4e, 0xf1, 0xca, 0x36, 0xb2, 0x31,
+  0x04, 0x63, 0xa3, 0x8e, 0x31, 0xf8, 0x54, 0xd1, 0xd9, 0x87, 0x6d, 0xb8,
+  0xe7, 0x38, 0x15, 0x71, 0xe4, 0x85, 0x13, 0xe4, 0x46, 0xe3, 0x8e, 0x3b,
+  0x9f, 0x5c, 0x55, 0x94, 0x2f, 0x2b, 0x26, 0x5b, 0xa2, 0x60, 0x67, 0xb7,
+  0x1c, 0x0a, 0x95, 0x4d, 0x14, 0xe6, 0x3e, 0xda, 0xd2, 0x2f, 0x30, 0x85,
+  0x03, 0x76, 0xd5, 0xf4, 0xc8, 0xff, 0x00, 0x26, 0xb5, 0xa3, 0x89, 0x87,
+  0x0c, 0xca, 0xa0, 0x1c, 0x7a, 0x03, 0x9f, 0xc3, 0xf2, 0xaa, 0x36, 0xca,
+  0x50, 0x8e, 0x46, 0x3b, 0xf7, 0xeb, 0x5b, 0x30, 0xed, 0xea, 0xa3, 0x38,
+  0xcf, 0x6c, 0x64, 0x51, 0xc8, 0x85, 0xce, 0xcb, 0x31, 0x2f, 0x97, 0x86,
+  0x62, 0x73, 0x9e, 0xa7, 0xb7, 0xff, 0x00, 0xae, 0xb6, 0xa3, 0x6f, 0x3a,
+  0x1c, 0x63, 0x20, 0x73, 0xc0, 0x00, 0xf3, 0xea, 0x7a, 0xff, 0x00, 0x4a,
+  0xc8, 0x56, 0x59, 0x0e, 0x00, 0xdd, 0xe8, 0x7b, 0x8c, 0x7f, 0x3a, 0xd3,
+  0x80, 0xc0, 0x17, 0x6e, 0xe3, 0x9c, 0xe7, 0x8e, 0x6b, 0x45, 0xe4, 0x26,
+  0xcb, 0x30, 0xdb, 0x4a, 0xce, 0x15, 0x7a, 0x74, 0x18, 0xe9, 0xfd, 0x73,
+  0x5d, 0x25, 0xaa, 0x1b, 0x75, 0x2b, 0x93, 0x9f, 0x5e, 0xd9, 0xff, 0x00,
+  0x3d, 0x6b, 0x36, 0x0b, 0x95, 0xc6, 0xd2, 0x57, 0x23, 0xef, 0x33, 0x75,
+  0xfc, 0x71, 0x56, 0x13, 0x50, 0x88, 0x82, 0xd9, 0x0c, 0x01, 0xc0, 0x61,
+  0xd3, 0xea, 0x08, 0xeb, 0x4a, 0xfa, 0x92, 0xd1, 0xa8, 0x2e, 0x19, 0x13,
+  0x6c, 0x6e, 0x01, 0xee, 0x4f, 0x1f, 0xef, 0x1c, 0xd6, 0x0d, 0xfc, 0xf2,
+  0x3e, 0x5d, 0xb9, 0x1c, 0xf4, 0x24, 0xe7, 0x1f, 0x8e, 0x29, 0xd2, 0xea,
+  0x1b, 0x23, 0x25, 0x4b, 0x29, 0x74, 0xda, 0x17, 0x90, 0x36, 0x9e, 0xbc,
+  0x7b, 0xf7, 0xac, 0x29, 0xef, 0x54, 0x7d, 0xee, 0x4e, 0x3f, 0x5e, 0x6a,
+  0xa3, 0xb8, 0xa4, 0xec, 0x7f, 0xff, 0xd6, 0xfc, 0xa4, 0x2e, 0x8a, 0xad,
+  0x1c, 0x87, 0x18, 0x6f, 0x6c, 0x63, 0x8f, 0x7c, 0xf5, 0xcf, 0x7a, 0xa6,
+  0xf2, 0x42, 0x48, 0x0c, 0x38, 0x03, 0x20, 0x9e, 0x45, 0x57, 0x7b, 0xa8,
+  0x9b, 0xe6, 0x1c, 0xe3, 0xa7, 0x22, 0xa2, 0x33, 0x92, 0x73, 0x85, 0x38,
+  0xfe, 0x12, 0xd9, 0xfe, 0x55, 0xd2, 0xee, 0x71, 0x7c, 0x88, 0xe4, 0xdc,
+  0x09, 0x09, 0x92, 0x4f, 0x7e, 0x41, 0xfe, 0xb5, 0x51, 0xa1, 0x25, 0xc3,
+  0xc8, 0xe1, 0x4e, 0x0e, 0x3b, 0x37, 0xbf, 0x5f, 0xa5, 0x4f, 0x73, 0x2c,
+  0x93, 0xb6, 0xf2, 0x22, 0x8b, 0xda, 0x3c, 0x80, 0x7e, 0xb9, 0x27, 0xfc,
+  0x2a, 0x8c, 0xa3, 0x2a, 0x23, 0x6e, 0x4f, 0x6c, 0x12, 0x47, 0xe8, 0x29,
+  0x29, 0x30, 0xe5, 0x2d, 0xf9, 0x6c, 0x70, 0xb1, 0xb7, 0x52, 0x00, 0x24,
+  0x1f, 0xfe, 0xb5, 0x43, 0x24, 0xce, 0xaf, 0x86, 0x00, 0xf3, 0xc8, 0xe7,
+  0xaf, 0x4f, 0x4a, 0xa2, 0xf1, 0x4f, 0xbb, 0xe5, 0x1f, 0x36, 0x79, 0xcb,
+  0x0c, 0x7e, 0x54, 0xd8, 0xd2, 0xff, 0x00, 0x24, 0x12, 0x9e, 0xf8, 0x1c,
+  0x75, 0xeb, 0xc1, 0xcd, 0x37, 0x2d, 0x46, 0x93, 0x12, 0x5b, 0xd6, 0x8d,
+  0xc2, 0xe3, 0x39, 0x3d, 0x80, 0x3c, 0xe2, 0xa2, 0x6d, 0x53, 0x68, 0x05,
+  0x23, 0x38, 0xcf, 0x07, 0xa7, 0x4f, 0x4e, 0x6a, 0x59, 0x62, 0xbc, 0xce,
+  0xcc, 0x82, 0x3d, 0x36, 0x93, 0xed, 0xdf, 0xdb, 0xda, 0xa9, 0x4d, 0x65,
+  0x77, 0x23, 0xf0, 0x4a, 0xe3, 0x9e, 0x13, 0x1c, 0xfe, 0x15, 0x5c, 0xc8,
+  0x5b, 0x12, 0x2e, 0xab, 0x38, 0x52, 0xeb, 0x19, 0x2a, 0x0f, 0xcd, 0x9e,
+  0xc4, 0x8e, 0x33, 0xcf, 0xf4, 0xab, 0x56, 0x9a, 0xe9, 0x61, 0x89, 0x15,
+  0x17, 0x9c, 0xe7, 0x24, 0x74, 0xed, 0xc9, 0xac, 0xcf, 0xec, 0xfb, 0xa8,
+  0x1b, 0xcc, 0x59, 0x1f, 0xd0, 0x8c, 0x1e, 0x9f, 0x4e, 0x95, 0x58, 0xe9,
+  0x45, 0x88, 0x42, 0xf2, 0x83, 0x8e, 0xb8, 0x07, 0xf3, 0x1f, 0x2f, 0xf9,
+  0xed, 0x4b, 0x99, 0x02, 0x6f, 0x73, 0xaf, 0x8e, 0xfe, 0x09, 0xdb, 0x9d,
+  0x9c, 0x76, 0x2c, 0x32, 0x7f, 0x2c, 0xf4, 0xad, 0x78, 0xae, 0x6d, 0xd1,
+  0x32, 0x19, 0x54, 0x8c, 0x10, 0xcb, 0xc6, 0x3f, 0xcf, 0xe1, 0x5e, 0x6b,
+  0xfd, 0x99, 0x76, 0x1b, 0x31, 0xcc, 0xdb, 0x54, 0xf0, 0x0a, 0x95, 0xfe,
+  0x59, 0xa6, 0x9b, 0x7d, 0x4a, 0x3c, 0x2e, 0x64, 0x60, 0x7f, 0xba, 0x0a,
+  0xf3, 0xfa, 0x71, 0x52, 0xd7, 0x62, 0x94, 0x9f, 0x63, 0xd0, 0x9e, 0x7b,
+  0x55, 0x24, 0x79, 0xcb, 0x96, 0x6e, 0xc4, 0x11, 0x83, 0xeb, 0xc9, 0xfd,
+  0x2a, 0xbb, 0xdd, 0xc7, 0xd1, 0x59, 0x48, 0x03, 0xf8, 0x3f, 0xc4, 0x73,
+  0xfa, 0x57, 0x04, 0x96, 0xd7, 0xff, 0x00, 0x7a, 0x55, 0x63, 0x9c, 0x0e,
+  0x0f, 0x23, 0xf3, 0xff, 0x00, 0x1a, 0x73, 0xdb, 0xea, 0x4d, 0x18, 0x08,
+  0x87, 0xaf, 0x21, 0x8e, 0x31, 0xf9, 0x67, 0xfa, 0x50, 0xad, 0xd4, 0x77,
+  0x67, 0x63, 0xf6, 0xa7, 0x70, 0x5f, 0xe6, 0xe3, 0xb8, 0x27, 0xf3, 0x20,
+  0xd3, 0x16, 0xe2, 0x66, 0x7d, 0xee, 0x48, 0x5c, 0xed, 0x19, 0xc7, 0x05,
+  0x4f, 0x39, 0xe0, 0x7a, 0x8a, 0xe3, 0x4c, 0x1a, 0x94, 0x07, 0xe4, 0x57,
+  0x04, 0x73, 0x95, 0x38, 0x03, 0x3d, 0x71, 0xcd, 0x48, 0xcb, 0xaa, 0xdc,
+  0x2e, 0xc9, 0x4c, 0x8c, 0x3d, 0x0e, 0x4f, 0xf2, 0x22, 0xaa, 0xca, 0xfb,
+  0x87, 0x31, 0xd9, 0x8b, 0xc4, 0x49, 0x08, 0x03, 0xa9, 0xdf, 0xbb, 0x8e,
+  0x4f, 0x70, 0x30, 0x3f, 0x4a, 0x79, 0xbe, 0xb4, 0xc0, 0xf3, 0xa4, 0x38,
+  0x27, 0x3c, 0xf5, 0x1e, 0x9e, 0x9f, 0xca, 0xb9, 0x7b, 0x58, 0xef, 0x2d,
+  0x86, 0xe5, 0x50, 0xb9, 0x3c, 0x8e, 0x4f, 0x51, 0xdf, 0xa8, 0xe6, 0xac,
+  0xca, 0x93, 0xcf, 0x28, 0x79, 0x90, 0x02, 0xa3, 0x0a, 0x49, 0x1d, 0x3e,
+  0x98, 0xc7, 0xeb, 0x4d, 0x45, 0x77, 0x13, 0x99, 0xae, 0xfa, 0x82, 0xaf,
+  0x4c, 0xb0, 0xcf, 0x0c, 0xa7, 0x9f, 0xcb, 0x92, 0x45, 0x3b, 0xfb, 0x45,
+  0xe4, 0x20, 0x42, 0x8d, 0x9c, 0x60, 0x91, 0xc1, 0xc7, 0xae, 0x47, 0x4f,
+  0xcb, 0xf2, 0xaa, 0x11, 0xed, 0x87, 0xe7, 0x75, 0x52, 0x38, 0x1b, 0x41,
+  0x51, 0xfc, 0x89, 0xfe, 0x55, 0x7c, 0x5e, 0xdb, 0x6d, 0x2a, 0x88, 0xe3,
+  0x9e, 0xbb, 0x89, 0xfc, 0x38, 0xa6, 0xe2, 0x84, 0xa5, 0xd0, 0x9e, 0x1b,
+  0xac, 0xb8, 0x69, 0x5b, 0x73, 0x1e, 0x70, 0xe3, 0x38, 0xfc, 0x7a, 0x7f,
+  0x5a, 0xbf, 0xe7, 0x29, 0x00, 0x21, 0xc8, 0xcf, 0x71, 0x81, 0x9f, 0xce,
+  0xb2, 0x9a, 0xe6, 0x07, 0x1c, 0xed, 0x23, 0x18, 0x39, 0xc9, 0x3f, 0xad,
+  0x49, 0xf6, 0x9b, 0x48, 0xce, 0x4a, 0x12, 0x47, 0x18, 0x53, 0x8e, 0x3e,
+  0xa5, 0x6a, 0x6c, 0x3b, 0xf6, 0x35, 0xde, 0xe1, 0x89, 0x0c, 0xdc, 0x11,
+  0xc0, 0xc7, 0x4c, 0x0e, 0xd5, 0x6c, 0xbb, 0xc5, 0x3a, 0xcf, 0x1b, 0x61,
+  0xd7, 0x0e, 0x42, 0x12, 0xbb, 0x48, 0xe4, 0x60, 0x80, 0x30, 0x47, 0x5e,
+  0x0d, 0x66, 0xc7, 0x79, 0xa4, 0x9e, 0x62, 0x8a, 0xe1, 0x4f, 0x19, 0x72,
+  0xea, 0x7f, 0x00, 0x31, 0xd3, 0xeb, 0x44, 0xb7, 0x96, 0x4b, 0xf3, 0x15,
+  0x94, 0x13, 0xfd, 0xf3, 0xd4, 0x7b, 0x70, 0x28, 0x48, 0x1b, 0x67, 0x45,
+  0xe7, 0x2a, 0x0f, 0x36, 0x43, 0xb9, 0xa5, 0xcb, 0x3b, 0x64, 0xe7, 0x71,
+  0x27, 0x92, 0x4e, 0x49, 0xc9, 0xe4, 0x9e, 0xf5, 0x2a, 0x5c, 0xc6, 0x88,
+  0x5a, 0x3e, 0xdd, 0x71, 0xc5, 0x73, 0x49, 0xa9, 0xda, 0x92, 0x15, 0xf3,
+  0xb4, 0x73, 0x80, 0x7d, 0x7a, 0xf3, 0x8a, 0x90, 0xea, 0x10, 0x6e, 0x0e,
+  0x08, 0x0a, 0x4e, 0x79, 0x27, 0x3f, 0x5e, 0xdf, 0xce, 0x93, 0x8d, 0x85,
+  0xcd, 0xd8, 0xeb, 0x12, 0x7d, 0xc4, 0xf2, 0xc1, 0x8f, 0x43, 0xf7, 0xbf,
+  0xfa, 0xdf, 0xae, 0x6b, 0x42, 0x2b, 0x8f, 0x24, 0x0f, 0x9d, 0x89, 0xec,
+  0x41, 0x18, 0x23, 0xe9, 0xd3, 0xf4, 0xcd, 0x70, 0x71, 0xea, 0x68, 0xec,
+  0x77, 0x04, 0x18, 0x1f, 0xc0, 0xd8, 0x3c, 0x7e, 0x38, 0xfd, 0x0d, 0x09,
+  0xa9, 0xa9, 0x61, 0x24, 0x4a, 0x57, 0x9c, 0xe7, 0x69, 0x27, 0x3f, 0x5e,
+  0xd4, 0xb9, 0x47, 0xcc, 0x77, 0xa7, 0x53, 0x9c, 0x11, 0x1a, 0x01, 0x95,
+  0xe0, 0x30, 0x1c, 0x73, 0xeb, 0xcf, 0x38, 0xa9, 0x93, 0x50, 0x56, 0x01,
+  0x66, 0x75, 0x2c, 0x30, 0x4e, 0x7f, 0xc3, 0x35, 0xc6, 0x8d, 0x58, 0x32,
+  0x6d, 0xf3, 0x19, 0x79, 0xe8, 0xfc, 0xff, 0x00, 0x4c, 0xd5, 0x85, 0xb9,
+  0xb5, 0x75, 0xde, 0xd7, 0x30, 0x80, 0xa7, 0x9c, 0xa1, 0xe7, 0xfa, 0x9a,
+  0x5c, 0xa3, 0xe6, 0xb9, 0xd2, 0x3d, 0xde, 0xf6, 0x2c, 0x4f, 0x1e, 0xa7,
+  0x07, 0x8a, 0xce, 0x92, 0x55, 0x70, 0x5a, 0x33, 0x8f, 0xbd, 0x90, 0xc3,
+  0x9c, 0xfb, 0x73, 0x5c, 0xdc, 0xfa, 0xa4, 0x71, 0x7c, 0xb1, 0x11, 0x21,
+  0x27, 0xef, 0x20, 0x65, 0x1f, 0x53, 0xbb, 0x03, 0xf5, 0xa8, 0x06, 0xa8,
+  0xbc, 0x06, 0x27, 0x9c, 0xf7, 0xe0, 0x0f, 0xd6, 0x9a, 0x25, 0xdc, 0xff,
+  0xd9
+};
+const unsigned int DayEnvironmentHDRI019_1K_TONEMAPPED_jpg_len = 17065;
\ No newline at end of file
diff --git a/oomer_voxel_vmax.h b/oomer_voxel_vmax.h
new file mode 100644
index 0000000..aeb5dd6
--- /dev/null
+++ b/oomer_voxel_vmax.h
@@ -0,0 +1,744 @@
+#pragma once
+
+#include <map>     // For std::map
+#include <set>     // For std::set
+#include <vector>  // For std::vector (you're already using this)
+#include <string>  // For std::string (you're already using this)
+#include <cstdint> // For uint8_t
+#include <fstream> // For std::ifstream and std::ofstream
+#include <iostream> // For std::cerr, std::cout
+#include <filesystem> // For std::filesystem functions
+
+#include "../lzfse/src/lzfse.h"
+#include "../libplist/include/plist/plist.h" // Library for handling Apple property list files
+#include "thirdparty/json.hpp"
+
+using json = nlohmann::json;
+
+// Define STB_IMAGE_IMPLEMENTATION before including to create the implementation
+#define STB_IMAGE_IMPLEMENTATION
+#include "thirdparty/stb_image.h" // STB Image library
+
+struct VoxelRGBA {
+    uint8_t r, g, b, a;
+};
+
+// Read a 256x1 PNG file and return a vector of VoxelRGBA colors
+std::vector<VoxelRGBA> read256x1PaletteFromPNG(const std::string& filename) {
+    int width, height, channels;
+    // Load the image with 4 desired channels (RGBA)
+    unsigned char* data = stbi_load(filename.c_str(), &width, &height, &channels, 4);
+    
+    if (!data) {
+        std::cerr << "Error loading PNG file: " << filename << std::endl;
+        return {};
+    }
+    // Make sure the image is 256x1 as expected
+    if (width != 256 || height != 1) {
+        std::cerr << "Warning: Expected a 256x1 image, but got " << width << "x" << height << std::endl;
+    }
+    // Create our palette array
+    std::vector<VoxelRGBA> palette;
+    // Read each pixel (each pixel is 4 bytes - RGBA)
+    for (int i = 0; i < width; i++) {
+        VoxelRGBA color;
+        color.r = data[i * 4];
+        color.g = data[i * 4 + 1];
+        color.b = data[i * 4 + 2];
+        color.a = data[i * 4 + 3];
+        palette.push_back(color);
+    }
+    stbi_image_free(data); // Free the image data
+    return palette;
+}
+
+// Standard useful voxel structure, maps easily to VoxelMax's voxel structure and probably MagicaVoxel's
+// We are using this to unpack a chunked voxel into a simple giant voxel
+// using a uint8_t saves memory over a uint32_t and both VM and MV models are 256x256x256
+// The world itself can be larger, see scene.json
+// Helper struct because in VmaxModel we use array of arrays to store material and color
+// Allowing us to group voxels by material and color
+struct VmaxVoxel {
+    uint8_t x, y, z;
+    uint8_t material;    // material value 0-7
+    uint8_t palette;     // Color palette mapping index 0-255, search palette1.png
+    uint16_t chunkID;       // Chunk ID 0-511 8x8x8 is a morton code
+    uint16_t minMorton;     // morton encoded offset from chunk origin 0-32767 32x32x32, decoded value is added to voxel x y z
+    // Constructor
+    VmaxVoxel(      uint8_t _x,
+                    uint8_t _y,
+                    uint8_t _z,
+                    uint8_t _material,
+                    uint8_t _palette,
+                    uint16_t _chunkID,
+                    uint16_t _minMorton)
+                    : x(_x), y(_y), z(_z), material(_material), palette(_palette), chunkID(_chunkID), minMorton(_minMorton) {
+    }
+};
+
+inline uint32_t compactBits(uint32_t n) {
+    // For a 32-bit integer in C++
+    n &= 0x49249249;                     // Keep only every 3rd bit
+    n = (n ^ (n >> 2)) & 0xc30c30c3;     // Merge groups
+    n = (n ^ (n >> 4)) & 0x0f00f00f;     // Continue merging
+    n = (n ^ (n >> 8)) & 0x00ff00ff;     // Merge larger groups
+    n = (n ^ (n >> 16)) & 0x0000ffff;    // Final merge
+    return n;
+}
+
+// Optimized function to decode Morton code using parallel bit manipulation
+inline void decodeMorton3DOptimized(uint32_t morton, uint32_t& x, uint32_t& y, uint32_t& z) {
+    x = compactBits(morton);
+    y = compactBits(morton >> 1);
+    z = compactBits(morton >> 2);
+}
+
+struct VmaxMaterial {
+    std::string materialName;
+    double transmission;
+    double roughness;
+    double metalness;
+    double emission;
+    bool enableShadows;
+    bool dielectric; // future use
+    bool volumetric; // future use
+};
+
+// Create a structure to represent a model with its voxels with helper functions
+struct VmaxModel {
+    // Model identifier or name
+    std::string vmaxbFileName; // file name is used like a key
+    
+    // Voxels organized by material and color
+    // First dimension: material (0-7)
+    // Second dimension: color (1-255, index 0 unused since color 0 means no voxel)
+    std::vector<VmaxVoxel> voxels[8][256];
+    
+    // Each model has local 0-7 materials
+    std::array<VmaxMaterial, 8> materials;
+    // Each model has local colors
+    std::array<VoxelRGBA, 256> colors;
+
+    // Constructor
+    VmaxModel(const std::string& modelName) : vmaxbFileName(modelName) {
+    }
+    
+    // Add a voxel to this model
+    void addVoxel(int x, int y, int z, int material, int color, int chunk, int chunkMin) {
+        if (material >= 0 && material < 8 && color > 0 && color < 256) {
+            voxels[material][color].emplace_back(x, y, z, material, color, chunk, chunkMin);
+        }
+    }
+
+    // Add a materials to this model
+    void addMaterials(const std::array<VmaxMaterial, 8> newMaterials) {
+        materials = newMaterials;
+    }
+    
+    // Add a colors to this model
+    void addColors(const std::array<VoxelRGBA, 256> newColors) {
+        colors = newColors;
+    }
+     
+    // Get all voxels of a specific material and color
+    const std::vector<VmaxVoxel>& getVoxels(int material, int color) const {
+        if (material >= 0 && material < 8 && color > 0 && color < 256) {
+            return voxels[material][color];
+        }
+        static std::vector<VmaxVoxel> empty;
+        return empty;
+    }
+    
+    // Get total voxel count for this model
+    size_t getTotalVoxelCount() const {
+        size_t count = 0;
+        for (int m = 0; m < 8; m++) {
+            for (int c = 1; c < 256; c++) {  // Skip index 0
+                count += voxels[m][c].size();
+            }
+        }
+        return count;
+    }
+
+    // Get a map of used materials and their associated colors
+    std::map<int, std::set<int>> getUsedMaterialsAndColors() const {
+        std::map<int, std::set<int>> result;
+        
+        // Iterate through fixed size arrays - we know it's 8 materials and 256 colors
+        for (int material = 0; material < 8; material++) {
+            for (int color = 1; color < 256; color++) {  // Skip index 0 as it means no voxel
+                if (!voxels[material][color].empty()) {
+                    result[material].insert(color);
+                }
+            }
+        }
+        
+        return result;
+    }
+};
+
+inline std::array<VmaxMaterial, 8> getVmaxMaterials(plist_t pnodPalettePlist) {
+    // Directly access the materials array
+    std::array<VmaxMaterial, 8> vmaxMaterials;
+    plist_t materialsNode = plist_dict_get_item(pnodPalettePlist, "materials");
+    if (materialsNode && plist_get_node_type(materialsNode) == PLIST_ARRAY) {
+        uint32_t materialsCount = plist_array_get_size(materialsNode);
+        std::cout << "Found materials array with " << materialsCount << " items" << std::endl;
+        
+        // Process each material
+        for (uint32_t i = 0; i < materialsCount; i++) {
+            plist_t materialNode = plist_array_get_item(materialsNode, i);
+            if (materialNode && plist_get_node_type(materialNode) == PLIST_DICT) {
+                plist_t nameNode = plist_dict_get_item(materialNode, "mi");
+                std::string vmaxMaterialName;
+                double vmaxTransmission = 0.0;  // Declare outside the if block
+                double vmaxEmission = 0.0;  // Declare outside the if block
+                double vmaxRoughness = 0.0;  // Declare outside the if block
+                double vmaxMetalness = 0.0;  // Declare outside the if block
+                uint8_t vmaxEnableShadows = 1;
+                
+                if (nameNode) {
+                    char* rawName = nullptr;
+                    plist_get_string_val(nameNode, &rawName);
+                    vmaxMaterialName = rawName ? rawName : "unnamed";
+                    free(rawName);
+                }
+                plist_t pnodTc = plist_dict_get_item(materialNode, "tc");
+                if (pnodTc) { plist_get_real_val(pnodTc, &vmaxTransmission); }
+                plist_t pnodEmission = plist_dict_get_item(materialNode, "sic");
+                if (pnodEmission) { plist_get_real_val(pnodEmission, &vmaxEmission); }
+                plist_t pnodRoughness = plist_dict_get_item(materialNode, "rc");
+                if (pnodRoughness) { plist_get_real_val(pnodRoughness, &vmaxRoughness); }
+                plist_t pnodMetalness = plist_dict_get_item(materialNode, "mc");
+                if (pnodMetalness) { plist_get_real_val(pnodMetalness, &vmaxMetalness); }
+                plist_t pnodEnableShadow = plist_dict_get_item(materialNode, "sh");
+                if (pnodEnableShadow) { plist_get_bool_val(pnodEnableShadow, &vmaxEnableShadows); }
+
+                vmaxMaterials[i] = {
+                    vmaxMaterialName,
+                    vmaxTransmission,
+                    vmaxRoughness,
+                    vmaxMetalness,
+                    vmaxEmission,
+                    static_cast<bool>(vmaxEnableShadows),
+                    false, // dielectric
+                    false, // volumetric
+                };
+            }
+        }
+    } else {
+        std::cout << "No materials array found or invalid type" << std::endl;
+    }
+    #ifdef _DEBUG2
+        for (const auto& material : vmaxMaterials) {
+            std::cout << "Material: " << material.materialName << std::endl;
+            std::cout << "  Transmission: " << material.transmission << std::endl;
+            std::cout << "  Emission: " << material.emission << std::endl;
+            std::cout << "  Roughness: " << material.roughness << std::endl;
+            std::cout << "  Metalness: " << material.metalness << std::endl;
+            std::cout << "  Enable Shadows: " << material.enableShadows << std::endl;
+            std::cout << "  Dielectric: " << material.dielectric << std::endl;
+            std::cout << "  Volumetric: " << material.volumetric << std::endl;
+        }
+    #endif
+    return vmaxMaterials;
+}
+
+
+/**
+ * Decodes a voxel's material index and palette index from the ds data stream
+ * 
+ * @param dsData The raw ds data stream containing material and palette index pairs
+ * @param mortonOffset offset to apply to the morton code
+ * @param chunkID chunk ID
+ * @return vector of VmaxVoxel structures containing the voxels local to a snapshot
+ */
+inline std::vector<VmaxVoxel> decodeVoxels(const std::vector<uint8_t>& dsData, int mortonOffset, uint16_t chunkID) {
+    std::vector<VmaxVoxel> voxels;
+    uint8_t material;
+    uint8_t color;
+    for (int i = 0; i < dsData.size() - 1; i += 2) {
+        //dsVoxel _vxVoxel; // VoxelMax data [todo] - should I use uint8_t for x, y, z?
+        material = dsData[i]; // also known as a layer color
+        //_vxVoxel.material = static_cast<int>(dsData[i]); // also known as a layer color
+        color = dsData[i + 1];
+        //_vxVoxel.color = static_cast<uint8_t>(dsData[i + 1]);
+        uint32_t _tempx, _tempy, _tempz;
+        decodeMorton3DOptimized(i/2 + mortonOffset,
+                                _tempx,
+                                _tempy,
+                                _tempz); // index IS the morton code
+        //std::cout << "i: " << i << " _tempx: " << _tempx << " _tempy: " << _tempy << " _tempz: " << _tempz << std::endl;
+        if (color != 0) {
+            VmaxVoxel voxel = {
+                static_cast<uint8_t>(_tempx), 
+                static_cast<uint8_t>(_tempy), 
+                static_cast<uint8_t>(_tempz), 
+                material,
+                color,
+                chunkID, // todo is wasteful to pass chunkID?
+                static_cast<uint16_t>(mortonOffset)
+            };
+            voxels.push_back(voxel);
+        }
+
+    }
+    return voxels;
+}
+
+//libplist reads in 64 bits
+struct VmaxChunkInfo {
+    int64_t id; // was uint but will use -1 to indicate bad chunk
+    uint64_t type;
+    uint64_t mortoncode;
+    uint32_t voxelOffsetX;
+    uint32_t voxelOffsetY;
+    uint32_t voxelOffsetZ;
+};
+
+// Helper function to get a nested dictionary item
+// @param root: root dictionary
+// @param path: path to the item
+// @return: item
+// Using a vector of strings for dynamic path length
+plist_t getNestedPlistNode(plist_t plist_root, const std::vector<std::string>& path) {
+    plist_t current = plist_root;
+    for (const auto& key : path) {
+        if (!current) return nullptr;
+        current = plist_dict_get_item(current, key.c_str());
+    }
+    return current;
+}
+
+// Need morton code in snapshot before we can decode voxels
+// @param an individual chunk: plist_t of a snapshot dict->item->s
+// @return Chunk level info needed to decode voxels
+VmaxChunkInfo vmaxChunkInfo(const plist_t& plist_snapshot_dict_item) {
+    uint64_t id;
+    uint64_t type;
+    uint64_t mortoncode;
+    uint32_t voxelOffsetX, voxelOffsetY, voxelOffsetZ;
+    try {
+        plist_t plist_snapshot = getNestedPlistNode(plist_snapshot_dict_item, {"s"});
+
+        // vmax file format must guarantee the existence 
+        // s.st.min
+        // s.id.t
+        // s.id.c
+        plist_t plist_min = getNestedPlistNode(plist_snapshot, {"st", "min"});
+        plist_t plist_min_val = plist_array_get_item(plist_min, 3);
+        plist_get_uint_val(plist_min_val, &mortoncode);
+        
+        // convert to 32x32x32 chunk offset
+        decodeMorton3DOptimized(mortoncode, 
+                                voxelOffsetX, 
+                                voxelOffsetY, 
+                                voxelOffsetZ); 
+
+        plist_t plist_type = getNestedPlistNode(plist_snapshot, {"id","t"});
+        plist_get_uint_val(plist_type, &type);
+        plist_t plist_chunk = getNestedPlistNode(plist_snapshot, {"id","c"});
+        plist_get_uint_val(plist_chunk, &id);
+
+        return VmaxChunkInfo{static_cast<int64_t>(id), 
+                            type,
+                            mortoncode,
+                            voxelOffsetX,
+                            voxelOffsetY,
+                            voxelOffsetZ};
+    } catch (std::exception& e) {
+        std::cout << "Error: " << e.what() << std::endl;    
+        // Just continue to next snapshot
+        // This bypass might mean we miss useful snapshots
+    }
+    return VmaxChunkInfo{-1, 0, 0, 0, 0, 0};
+}
+
+
+// Right after we get VmaxChunkInfo, we can get the voxels because we need morton chunk offset
+// @param pnodSnaphot: plist_t of a snapshot
+// @return vector of VmaxVoxel
+//std::vector<VmaxVoxel> getVmaxSnapshot(plist_t& pnod_each_snapshot) {
+std::vector<VmaxVoxel> vmaxVoxelInfo(plist_t& plist_datastream, uint64_t chunkID, uint64_t minMorton) {
+    std::vector<VmaxVoxel> voxelsArray; 
+    try {
+
+        // Extract the binary data
+        char* data = nullptr;
+        uint64_t length = 0;
+        plist_get_data_val(plist_datastream, &data, &length);
+        auto foo =  std::vector<uint8_t>(data, data + length) ;
+        std::vector<VmaxVoxel> allModelVoxels = decodeVoxels(std::vector<uint8_t>(data, data + length), minMorton, chunkID);
+
+        //std::cout << "allModelVoxels: " << allModelVoxels.size() << std::endl;
+
+        uint32_t model_8x8x8_x, model_8x8x8_y, model_8x8x8_z;
+        decodeMorton3DOptimized(chunkID, 
+                                model_8x8x8_x, 
+                                model_8x8x8_y, 
+                                model_8x8x8_z); // index IS the morton code
+        int model_256x256x256_x = model_8x8x8_x * 8; // convert to model space
+        int model_256x256x256_y = model_8x8x8_y * 8;
+        int model_256x256x256_z = model_8x8x8_z * 8;
+
+        for (const VmaxVoxel& eachVmaxVoxel : allModelVoxels) {
+            auto [  chunk_32x32x32_x, 
+                    chunk_32x32x32_y, 
+                    chunk_32x32x32_z, 
+                    materialMap, 
+                    colorMap, 
+                    chunkID, 
+                    minMorton] = eachVmaxVoxel;
+
+            int voxel_256x256x256_x = model_256x256x256_x + chunk_32x32x32_x;
+            int voxel_256x256x256_y = model_256x256x256_y + chunk_32x32x32_y;
+            int voxel_256x256x256_z = model_256x256x256_z + chunk_32x32x32_z;
+
+            auto one_voxel = VmaxVoxel(voxel_256x256x256_x, 
+                                    voxel_256x256x256_y, 
+                                    voxel_256x256x256_z, 
+                                    materialMap, 
+                                    colorMap,
+                                    chunkID,
+                                    minMorton);
+            voxelsArray.push_back(one_voxel);
+        }
+        return voxelsArray;
+    } catch (std::exception& e) {
+        std::cout << "Error: " << e.what() << std::endl;    
+        // Just continue to next snapshot
+        // This bypass might mean we miss useful snapshots
+    }
+    return voxelsArray; // empty return
+}
+
+/**
+ * Read a binary plist file and return a plist node.
+ * if the file is lzfse compressed, decompress it and parse the decompressed data
+ * 
+ * Memory Management:
+ * - Creates temporary buffers for decompression
+ * - Handles buffer resizing if needed
+ * - Returns a plist node that must be freed by the caller
+ * 
+ * @param lzfseFullName Path to the LZFSE file
+ * @param plistName Name of the plist file to write (optional)
+ * @return plist_t A pointer to the root node of the parsed plist, or nullptr if failed
+ */
+// read binary lzfse compressed/uncompressed file 
+inline plist_t readPlist(const std::string& inStrPlist, std::string outStrPlist, bool decompress) {
+    // Get file size using std::filesystem
+    size_t rawFileSize = std::filesystem::file_size(inStrPlist);
+    std::vector<uint8_t> rawBytes(rawFileSize);
+    std::vector<uint8_t> outBuffer;
+    size_t decodedSize = 0;
+    if (decompress) { // files are either lzfse compressed or uncompressed
+        std::ifstream rawBytesFile(inStrPlist, std::ios::binary);
+        if (!rawBytesFile.is_open()) {
+            std::cerr << "Error: Could not open plist file: " << inStrPlist << std::endl;
+            throw std::runtime_error("Error message"); // [learned] no need to return nullptr
+        }
+        
+        rawBytesFile.read(reinterpret_cast<char*>(rawBytes.data()), rawFileSize);
+        rawBytesFile.close();
+        // Start with output buffer 4x input size (compression ratio is usually < 4)
+        size_t outAllocatedSize = rawFileSize * 8;
+        // vector<uint8_t> automatically manages memory allocation/deallocation
+        //std::vector<uint8_t> outBuffer(outAllocatedSize);
+        outBuffer.resize(outAllocatedSize);  // Resize preserves existing content
+
+        // LZFSE needs a scratch buffer for its internal operations
+        // Get the required size and allocate it
+        size_t scratchSize = lzfse_decode_scratch_size();
+        std::vector<uint8_t> scratch(scratchSize);
+
+        // Decompress the data, growing the output buffer if needed
+        //size_t decodedSize = 0;
+        while (true) {
+            // Try to decompress with current buffer size
+            decodedSize = lzfse_decode_buffer(
+                outBuffer.data(),     // Where to store decompressed data
+                outAllocatedSize,     // Size of output buffer
+                rawBytes.data(),            // Source of compressed data
+                rawBytes.size(),            // Size of compressed data
+                scratch.data());      // Scratch space for LZFSE
+
+            // Check if we need a larger buffer:
+            // - decodedSize == 0 indicates failure
+            // - decodedSize == outAllocatedSize might mean buffer was too small
+            if (decodedSize == 0 || decodedSize == outAllocatedSize) {
+                outAllocatedSize *= 2;  // Double the buffer size
+                outBuffer.resize(outAllocatedSize);  // Resize preserves existing content
+                continue;  // Try again with larger buffer
+            }
+            break;  // Successfully decompressed
+        }
+
+        // Check if decompression failed
+        if (decodedSize == 0) {
+            std::cerr << "Failed to decompress data" << std::endl;
+            return nullptr;
+        }
+
+        // If requested, write the decompressed data to a file
+        if (!outStrPlist.empty()) {
+            std::ofstream outFile(outStrPlist, std::ios::binary);
+            if (outFile) {
+                outFile.write(reinterpret_cast<const char*>(outBuffer.data()), decodedSize);
+                std::cout << "Wrote decompressed plist to: " << outStrPlist << std::endl;
+            } else {
+                std::cerr << "Failed to write plist to file: " << outStrPlist << std::endl;
+            }
+        }
+    } else {
+        outBuffer.resize(rawFileSize); 
+        // if the file is not compressed, just read the raw bytes
+        std::ifstream rawBytesFile(inStrPlist, std::ios::binary);
+        if (!rawBytesFile.is_open()) {
+            std::cerr << "Error: Could not open plist file: " << inStrPlist << std::endl;
+            throw std::runtime_error("Error message"); // [learned] no need to return nullptr
+        }
+        rawBytesFile.read(reinterpret_cast<char*>(outBuffer.data()), rawFileSize);
+        rawBytesFile.close();
+        decodedSize = rawFileSize; // decodedSize is the same as rawFileSize when data is not compressed
+
+
+    } // outBuffer now contains the raw bytes of the plist file
+
+    // Parse the decompressed data as a plist
+    plist_t root_node = nullptr;
+    plist_format_t format;  // Will store the format of the plist (binary, xml, etc.)
+    
+    // Convert the raw decompressed data into a plist structure
+    plist_err_t err = plist_from_memory(
+        reinterpret_cast<const char*>(outBuffer.data()),  // Cast uint8_t* to char*
+        static_cast<uint32_t>(decodedSize),               // Cast size_t to uint32_t
+        &root_node,                                       // Where to store the parsed plist
+        &format);                                         // Where to store the format
+    
+    // Check if parsing succeeded
+    if (err != PLIST_ERR_SUCCESS) {
+        std::cerr << "Failed to parse plist data" << std::endl;
+        return nullptr;
+    }
+    
+    return root_node;  // Caller is responsible for calling plist_free()
+}
+
+// Overload for when you only want to specify inStrPlist and decompress
+inline plist_t readPlist(const std::string& inStrPlist, bool decompress) {
+    return readPlist(inStrPlist, "", decompress);
+}
+
+// Structure to hold object/model information from VoxelMax's scene.json
+struct JsonModelInfo {
+    std::string id;
+    std::string parentId;
+    std::string name;
+    std::string dataFile;       // The .vmaxb file
+    std::string paletteFile;    // The palette PNG
+    std::string historyFile;    // The history file
+    
+    // Transform information
+    std::vector<double> position;      // t_p
+    std::vector<double> rotation;      // t_r
+    std::vector<double> scale;         // t_s
+    
+    // Extent information
+    std::vector<double> extentCenter;  // e_c
+    std::vector<double> extentMin;     // e_mi
+    std::vector<double> extentMax;     // e_ma
+};
+
+// Structure to hold group information from VoxelMax's scene.json
+struct JsonGroupInfo {
+    std::string id;
+    std::string name;
+    std::vector<double> position;
+    std::vector<double> rotation;
+    std::vector<double> scale;
+    std::vector<double> extentCenter;
+    std::vector<double> extentMin;
+    std::vector<double> extentMax;
+    bool selected = false;
+};
+
+// Class to parse VoxelMax's scene.json
+class JsonVmaxSceneParser {
+private:
+    std::map<std::string, JsonModelInfo> models; // a vmax model can also be called a content
+    std::map<std::string, JsonGroupInfo> groups;
+    
+public:
+    bool parseScene(const std::string& jsonFilePath) {
+        try {
+            // Read the JSON file
+            std::ifstream file(jsonFilePath);
+            if (!file.is_open()) {
+                std::cerr << "Failed to open file: " << jsonFilePath << std::endl;
+                return false;
+            }
+            
+            // Parse the JSON
+            json sceneData;
+            file >> sceneData;
+            file.close();
+            
+            // Parse groups
+            if (sceneData.contains("groups") && sceneData["groups"].is_array()) {
+                for (const auto& group : sceneData["groups"]) {
+                    JsonGroupInfo groupInfo;
+                    
+                    // Extract group information
+                    if (group.contains("id")) groupInfo.id = group["id"];
+                    if (group.contains("name")) groupInfo.name = group["name"];
+                    
+                    // Extract transform data
+                    if (group.contains("t_p") && group["t_p"].is_array()) 
+                        groupInfo.position = group["t_p"].get<std::vector<double>>();
+                    
+                    if (group.contains("t_r") && group["t_r"].is_array()) 
+                        groupInfo.rotation = group["t_r"].get<std::vector<double>>();
+                    
+                    if (group.contains("t_s") && group["t_s"].is_array()) 
+                        groupInfo.scale = group["t_s"].get<std::vector<double>>();
+                    
+                    // Extract extent data
+                    if (group.contains("e_c") && group["e_c"].is_array()) 
+                        groupInfo.extentCenter = group["e_c"].get<std::vector<double>>();
+                    
+                    if (group.contains("e_mi") && group["e_mi"].is_array()) 
+                        groupInfo.extentMin = group["e_mi"].get<std::vector<double>>();
+                    
+                    if (group.contains("e_ma") && group["e_ma"].is_array()) 
+                        groupInfo.extentMax = group["e_ma"].get<std::vector<double>>();
+                    
+                    // Check if selected
+                    if (group.contains("s")) groupInfo.selected = group["s"].get<bool>();
+                    
+                    // Store the group
+                    groups[groupInfo.id] = groupInfo;
+                }
+            }
+            
+            // Parse objects (models) 
+            if (sceneData.contains("objects") && sceneData["objects"].is_array()) {
+                for (const auto& obj : sceneData["objects"]) {
+                    JsonModelInfo modelInfo;
+                    
+                    // Extract model information
+                    if (obj.contains("id")) modelInfo.id = obj["id"];
+                    if (obj.contains("pid")) modelInfo.parentId = obj["pid"];
+                    if (obj.contains("n")) modelInfo.name = obj["n"];
+                    
+                    // Extract file paths
+                    if (obj.contains("data")) modelInfo.dataFile = obj["data"];
+                    if (obj.contains("pal")) modelInfo.paletteFile = obj["pal"];
+                    if (obj.contains("hist")) modelInfo.historyFile = obj["hist"];
+                    
+                    // Extract transform data
+                    if (obj.contains("t_p") && obj["t_p"].is_array()) 
+                        modelInfo.position = obj["t_p"].get<std::vector<double>>();
+                    
+                    if (obj.contains("t_r") && obj["t_r"].is_array()) 
+                        modelInfo.rotation = obj["t_r"].get<std::vector<double>>();
+                    
+                    if (obj.contains("t_s") && obj["t_s"].is_array()) 
+                        modelInfo.scale = obj["t_s"].get<std::vector<double>>();
+                    
+                    // Extract extent data
+                    if (obj.contains("e_c") && obj["e_c"].is_array()) 
+                        modelInfo.extentCenter = obj["e_c"].get<std::vector<double>>();
+                    
+                    if (obj.contains("e_mi") && obj["e_mi"].is_array()) 
+                        modelInfo.extentMin = obj["e_mi"].get<std::vector<double>>();
+                    
+                    if (obj.contains("e_ma") && obj["e_ma"].is_array()) 
+                        modelInfo.extentMax = obj["e_ma"].get<std::vector<double>>();
+                    
+                    // Store the model
+                    models[modelInfo.id] = modelInfo;
+                }
+            }
+            
+            return true;
+            
+        } catch (const std::exception& e) {
+            std::cerr << "Error parsing JSON: " << e.what() << std::endl;
+            return false;
+        }
+    }
+    
+    // Get the parsed models
+    const std::map<std::string, JsonModelInfo>& getModels() const {
+        return models;
+    }
+    
+    // Get the parsed groups
+    const std::map<std::string, JsonGroupInfo>& getGroups() const {
+        return groups;
+    }
+    
+   /* Groups models by their data file names ie contentsN.vmaxb
+    * Since we can instance models, we can grab the first one when translating it to Bella
+    * @return Map where:
+    *         - Key: contentN.vmaxb (string)
+    *         - Value: vector of models using that data file
+    * Example:
+    *   Input models: {"id1": model1, "id2": model2} where both use "data.file"
+    *   Output: {"data.file": [model1, model2]}
+    */
+    std::map<std::string, std::vector<JsonModelInfo>> getModelContentVMaxbMap() const {
+        std::map<std::string, std::vector<JsonModelInfo>> fileMap;
+        
+        for (const auto& [id, model] : models) {
+            fileMap[model.dataFile].push_back(model);
+        }
+        
+        return fileMap;
+    }
+    
+    // Print summary of parsed data
+    void printSummary() const {
+        std::cout << "=========== Scene Summary ===========" << std::endl;
+        std::cout << "Groups: " << groups.size() << std::endl;
+        std::cout << "Models: " << models.size() << std::endl;
+        
+        // Print unique model files
+        std::map<std::string, int> modelFiles;
+        for (const auto& [id, model] : models) {
+            modelFiles[model.dataFile]++;
+        }
+        
+        std::cout << "\nModel Files:" << std::endl;
+        for (const auto& [file, count] : modelFiles) {
+            std::cout << "  " << file << " (used " << count << " times)" << std::endl;
+        }
+        
+        std::cout << "\nGroups:" << std::endl;
+        for (const auto& [id, group] : groups) {
+            std::cout << "  " << group.name << " (ID: " << id << ")" << std::endl;
+            if (!group.position.empty()) {
+                std::cout << "    Position: [" 
+                          << group.position[0] << ", " 
+                          << group.position[1] << ", " 
+                          << group.position[2] << "]" << std::endl;
+            }
+        }
+        
+        std::cout << "\nModels:" << std::endl;
+        for (const auto& [id, model] : models) {
+            std::cout << "  " << model.name << " (ID: " << id << ")" << std::endl;
+            std::cout << "    Data: " << model.dataFile << std::endl;
+            std::cout << "    Palette: " << model.paletteFile << std::endl;
+            std::cout << "    Parent: " << model.parentId << std::endl;
+            
+            if (!model.position.empty()) {
+                std::cout << "    Position: [" 
+                          << model.position[0] << ", " 
+                          << model.position[1] << ", " 
+                          << model.position[2] << "]" << std::endl;
+            }
+        }
+    }
+};
diff --git a/resources/DayEnvironmentHDRI019_1K-TONEMAPPED.jpg b/resources/DayEnvironmentHDRI019_1K-TONEMAPPED.jpg
deleted file mode 100644
index 0891d46edc4906f79b1d956d363eb13d8aa81455..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 429166
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%0Ay7_tTXp8o)~d-wkU)Xc@icM%akKLsD#{u9^7
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

diff --git a/thirdparty/json.hpp b/thirdparty/json.hpp
new file mode 100644
index 0000000..8b72ea6
--- /dev/null
+++ b/thirdparty/json.hpp
@@ -0,0 +1,24765 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <utility>
+
+// #include <nlohmann/detail/abi_macros.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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 != 11 || NLOHMANN_JSON_VERSION_PATCH != 3
+            #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 11  // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_PATCH 3   // NOLINT(modernize-macro-to-enum)
+
+#ifndef JSON_DIAGNOSTICS
+    #define JSON_DIAGNOSTICS 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_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) json_abi ## a ## b
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)
+
+#define NLOHMANN_JSON_ABI_TAGS                                       \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
+            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
+
+// 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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_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_20
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (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 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 to access 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)                                   \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        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)                                 \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        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.value(#v1, nlohmann_json_default_obj.v1);
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
+@since version 3.9.0
+*/
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& 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__)) }
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+    friend void to_json(nlohmann::json& 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
+*/
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    inline void from_json(const nlohmann::json& 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__)) }
+
+// inspired from https://stackoverflow.com/a/26745591
+// allows to call 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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 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 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>
+static 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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>
+inline 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <limits> // numeric_limits
+#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
+#include <utility> // declval
+#include <tuple> // tuple
+#include <string> // char_traits
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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 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>(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>(EOF);
+    }
+};
+
+///////////////////
+// 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 using 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 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 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>
+inline 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>
+inline 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>
+inline 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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
+
+
+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, ") ");
+#else
+        static_cast<void>(leaf_element);
+        return "";
+#endif
+    }
+
+  private:
+    /// an exception object as storage for error messages
+    std::runtime_error m;
+};
+
+/// @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
+
+// #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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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>
+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>
+
+
+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;
+}
+
+// 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>
+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, 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));
+    }
+    p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+#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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // copy
+#include <iterator> // begin, end
+#include <string> // string
+#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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // size_t
+#include <iterator> // input_iterator_tag
+#include <string> // string, to_string
+#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/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename string_type>
+void int_to_string( string_type& target, std::size_t value )
+{
+    // For ADL
+    using std::to_string;
+    target = to_string(value);
+}
+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::input_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/macro_scope.hpp>
+
+// #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 //
+/////////////
+
+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;
+    external_constructor<value_t::number_integer>::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 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
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const std_fs::path& p)
+{
+    j = p.string();
+}
+#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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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/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);
+    }
+
+  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())
+    {}
+
+    // delete 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;
+    }
+
+  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();
+    }
+
+  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 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++];
+    }
+
+  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);
+}
+
+#ifndef JSON_NO_IO
+// Special cases with fast paths
+inline file_input_adapter input_adapter(std::FILE* file)
+{
+    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)
+{
+    auto length = std::strlen(reinterpret_cast<const char*>(b));
+    const auto* ptr = reinterpret_cast<const char*>(b);
+    return input_adapter(ptr, ptr + length);
+}
+
+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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef>
+#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>
+
+
+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
+{
+/*!
+@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>
+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;
+
+    /*!
+    @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)
+        : root(r), allow_exceptions(allow_exceptions_)
+    {}
+
+    // 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_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && 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 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());
+
+        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_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && 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());
+
+        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:
+    /*!
+    @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));
+            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));
+            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));
+        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;
+};
+
+template<typename BasicJsonType>
+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;
+
+    json_sax_dom_callback_parser(BasicJsonType& r,
+                                 const parser_callback_t cb,
+                                 const bool allow_exceptions_ = true)
+        : root(r), callback(cb), allow_exceptions(allow_exceptions_)
+    {
+        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);
+
+        // check object limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && 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 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 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;
+            }
+            else
+            {
+                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);
+
+        // check array limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && 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)
+            {
+                ref_stack.back()->set_parents();
+            }
+            else
+            {
+                // discard array
+                *ref_stack.back() = discarded;
+            }
+        }
+
+        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:
+    /*!
+    @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));
+
+        // 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 {};
+    /// stack to manage which object keys to keep
+    std::vector<bool> key_keep_stack {};
+    /// 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;
+};
+
+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*/ = static_cast<std::size_t>(-1))
+    {
+        return true;
+    }
+
+    bool key(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool end_object()
+    {
+        return true;
+    }
+
+    bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
+    {
+        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>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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()))
+    {}
+
+    // delete 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 next character
+            switch (get())
+            {
+                // end of file while parsing 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;
+                                }
+                            }
+
+                            // 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;
+                }
+
+                // 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]
+    {
+        // 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);
+                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);
+                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(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 == 0)
+            {
+                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 == 0)
+            {
+                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();
+        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)
+        {
+            // just 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()
+    {
+        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 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 = '.';
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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
+*/
+static 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>>
+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(static_cast<std::size_t>(-1))))
+        {
+            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);
+            }
+
+            default: // anything else 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(static_cast<std::size_t>(-1))))
+        {
+            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(static_cast<std::size_t>(-1), 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(static_cast<std::size_t>(-1), 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 bytes follow)
+            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 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 static_cast<std::size_t>(-1) 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 != static_cast<std::size_t>(-1))
+        {
+            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 static_cast<std::size_t>(-1) 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 != static_cast<std::size_t>(-1))
+            {
+                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 can not 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)
+                    {
+                        result *= i;
+                        if (result == 0 || result == npos) // because dim elements shall not have zeros, result = 0 means overflow happened; it also can't be npos as it is used to initialize size in get_ubjson_size_type()
+                        {
+                            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 '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 = '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 (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(static_cast<std::size_t>(-1))))
+            {
+                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(static_cast<std::size_t>(-1))))
+            {
+                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 size of 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();
+    }
+
+    /*!
+    @return character read from the input after ignoring all 'N' entries
+    */
+    char_int_type get_ignore_noop()
+    {
+        do
+        {
+            get();
+        }
+        while (current == 'N');
+
+        return current;
+    }
+
+    /*
+    @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)
+    {
+        // step 1: read input into array with system's byte order
+        std::array<std::uint8_t, sizeof(NumberType)> vec{};
+        for (std::size_t i = 0; i < sizeof(NumberType); ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
+            {
+                return false;
+            }
+
+            // reverse byte order prior to conversion if necessary
+            if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata))
+            {
+                vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
+            }
+            else
+            {
+                vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
+            }
+        }
+
+        // step 2: convert array into number of type T and return
+        std::memcpy(&result, vec.data(), sizeof(NumberType));
+        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 = static_cast<std::size_t>(-1);
+
+    /// 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{'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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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,
+                    const parser_callback_t<BasicJsonType> cb = nullptr,
+                    const bool allow_exceptions_ = true,
+                    const bool skip_comments = false)
+        : callback(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> sdp(result, callback, allow_exceptions);
+            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 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> sdp(result, allow_exceptions);
+            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 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(static_cast<std::size_t>(-1))))
+                        {
+                            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(static_cast<std::size_t>(-1))))
+                        {
+                            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 "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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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). It's 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,
+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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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 The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    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));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        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 The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    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 The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    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));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        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 The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<=(const iter_impl& other) const
+    {
+        return !other.operator < (*this);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>(const iter_impl& other) const
+    {
+        return !operator<=(other);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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;
+        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 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
+                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 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 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')))
+                        {
+                            // 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 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 reference string
+                    for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i)
+                    {
+                        flatten(detail::concat(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(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 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 value to 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 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 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 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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
+{
+
+///////////////////
+// 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 or not 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
+    */
+    void write_ubjson(const BasicJsonType& j, const bool use_count,
+                      const bool use_type, const bool add_prefix = true,
+                      const bool use_bjdata = false)
+    {
+        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);
+                }
+
+                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 && !j.m_data.m_value.binary->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    oa->write_character(to_char_type('$'));
+                    oa->write_character('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('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))  // 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);
+                }
+
+                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
+        {
+            JSON_THROW(out_of_range::create(407, concat("integer number ", std::to_string(j.m_data.m_value.number_unsigned), " cannot be represented by BSON as it does not fit int64"), &j));
+        }
+    }
+
+    /*!
+    @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 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 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)
+    {
+        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'}
+        };
+
+        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);
+
+        key = "_ArrayData_";
+        if (dtype == 'U' || dtype == 'C')
+        {
+            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 number to array of length NumberType
+        std::array<CharType, sizeof(NumberType)> vec{};
+        std::memcpy(vec.data(), &n, sizeof(NumberType));
+
+        // step 2: write 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2008-2009 Björn Hoehrmann <bjoern@hoehrmann.de>
+// SPDX-FileCopyrightText: 2013-2023 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2009 Florian Loitsch <https://florian.loitsch.com/>
+// SPDX-FileCopyrightText: 2013-2023 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 if 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 look 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_)
+    {}
+
+    // delete 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 multi-byte 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
+    */
+    inline 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 += 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 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 buffer was large enough
+        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
+
+        // erase thousands separator
+        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 unsigned integer. The plus/minus shuffling is necessary as we can
+     * not 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.
+     */
+    inline 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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 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>
+    friend class ::nlohmann::detail::json_sax_dom_parser;
+    template<typename BasicJsonType>
+    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;
+    /// 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-2023 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.11.3", 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 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 get 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 = static_cast<std::size_t>(-1))
+    {
+#if JSON_DIAGNOSTICS
+        if (old_capacity != static_cast<std::size_t>(-1))
+        {
+            // 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)
+    {
+        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 array is wanted, do not create an object though possible
+            if (manual_type == value_t::array)
+            {
+                is_an_object = false;
+            }
+
+            // if 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 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 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)
+    {
+        JSON_ASSERT(first.m_object != nullptr);
+        JSON_ASSERT(last.m_object != nullptr);
+
+        // make sure 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 first iterator
+        m_data.m_type = first.m_object->m_data.m_type;
+
+        // check if 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)
+    {
+        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))
+    {
+        // check that passed value is valid
+        other.assert_invariant(false);
+
+        // invalidate payload
+        other.m_data.m_type = value_t::null;
+        other.m_data.m_value = {};
+
+        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 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);
+        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 is_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 is_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 better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            }
+        }
+        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 better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            }
+        }
+        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 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 array with null values if given idx is outside 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)
+    {
+        // implicitly convert 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 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 value and given default value otherwise
+            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 value and given default value otherwise
+            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 value and given default value otherwise
+            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 value and given default value otherwise
+            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 pointer resolves a value, return it or use 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 pointer resolves a value, return it or use 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)
+    {
+        // make sure 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)
+    {
+        // make sure 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 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 element to 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 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 element to 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 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 element to 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 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 element to 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 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 element to array (perfect forwarding)
+        auto res = m_data.m_value.object->emplace(std::forward<Args>(args)...);
+        set_parent(res.first->second);
+
+        // create 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)
+    {
+        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)
+    {
+        // 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)
+    {
+        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)
+    {
+        // 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)
+    {
+        // 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)
+    {
+        // 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)
+    {
+        // 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);
+    }
+
+    /// @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)
+    {
+        // implicitly convert 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 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,
+                            const 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)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        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,
+                            const 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)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        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,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
+        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
+
+    //////////////////////////////////////////
+    // 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)
+    {
+        std::vector<std::uint8_t> result;
+        to_bjdata(j, result, use_size, use_type);
+        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)
+    {
+        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true, true);
+    }
+
+    /// @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)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type, true, true);
+    }
+
+    /// @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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // 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);
+        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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
+        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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
+        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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // 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);
+        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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
+        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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
+        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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // 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);
+        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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
+        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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
+        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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
+        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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
+        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;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // 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);
+        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 std::string & 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, 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 parent of 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 parent of 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 std::string & op,
+                                          const std::string & 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, '\'');
+
+                // check if 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 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<std::string>();
+            const auto path = get_value(op, "path", true).template get<std::string>();
+            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<std::string>();
+                    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<std::string>();
+                    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 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 std::string& path = "")
+    {
+        // the patch
+        basic_json result(value_t::array);
+
+        // if the values are the same, return 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(path, '/', std::to_string(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(path, '/', std::to_string(i))}
+                    }));
+                    ++i;
+                }
+
+                // add other remaining elements
+                while (i < target.size())
+                {
+                    result.push_back(
+                    {
+                        {"op", "add"},
+                        {"path", detail::concat(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(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(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 type: 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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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_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.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 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_
diff --git a/stb_image.h b/thirdparty/stb_image.h
similarity index 100%
rename from stb_image.h
rename to thirdparty/stb_image.h
diff --git a/vmax2bella.cpp b/vmax2bella.cpp
index 96256cc..8dcb9eb 100644
--- a/vmax2bella.cpp
+++ b/vmax2bella.cpp
@@ -1,1125 +1,372 @@
-// vmax2bella.cpp - A program to convert VoxelMax (.vmax) files to Bella 3D scene (.bsz) files
-// 
-// This program reads VoxelMax files (which store voxel-based 3D models) and 
-// converts them to Bella (a 3D rendering engine) scene files.
+#include <iostream>
+#include "../bella_scene_sdk/src/bella_sdk/bella_scene.h"
+#include "../bella_scene_sdk/src/dl_core/dl_main.inl"
 
-/*
-# Technical Specification: VoxelMax Format
+#include "oomer_voxel_vmax.h" // common voxel code and structures
+#include "oomer_misc.h"  
 
-## Overview
-- This document specifies a chunked voxel storage format embedded in property list (plist) files. The format provides an efficient representation of 3D voxel data through a combination of Morton-encoded spatial indexing and a sparse representation approach.
+int addModelToScene(dl::bella_sdk::Scene& belScene, const VmaxModel& vmaxModel, const std::vector<VoxelRGBA>& vmaxPalette, const std::array<VmaxMaterial, 8>& vmaxMaterial); 
 
-## File Structure
-- Format: Property List (plist)
-- Structure: Hierarchical key-value structure with nested dictionaries and arrays
-- plist is compressed using the LZFSE, an open source reference c implementation is [here](https://github.com/lzfse/lzfse)
+int DL_main(dl::Args& args) {
+    args.add("he", "hello", "world", "Print a hello message with custom text");
+    args.add("vi", "voxin", "voxin", "voxin");
 
-```
-root
-└── snapshots (array)
-    └── Each snapshot (dictionary)
-        ├── s (dictionary) - Snapshot data
-        │   ├── id (dictionary) - Identifiers
-        │   │   ├── c (int64) - Chunk ID
-        │   │   ├── s (int64) - Session ID
-        │   │   └── t (int64) - Type ID
-        │   ├── lc (binary data) - Layer Color Usage
-        │   ├── ds (binary data) - Voxel data stream
-        │   ├── dlc (binary data) - Deselected Layer Color Usage
-        │   └── st (dictionary) - Statistics/metadata
-        │       ├── c (int64) - Count of voxels in the chunk
-        │       ├── sc (int64) - Selected Count (number of selected voxels)
-        │       ├── smin (array) - Selected Minimum coordinates [x,y,z,w]
-        │       ├── smax (array) - Selected Maximum coordinates [x,y,z,w]
-        │       ├── min (array) - Minimum coordinates of all voxels [x,y,z]
-        │       ├── max (array) - Maximum coordinates of all voxels [x,y,z]
-        │       └── e (dictionary) - Extent
-        │           ├── o (array) - Origin/reference point [x,y,z]
-        │           └── s (array) - Size/dimensions [width,height,depth]
-```
-
-## Chunking System
-### Volume Organization
-- The total volume is divided into chunks for efficient storage and manipulation
-- Standard chunk size: 32×32×32 voxels 
-- Total addressable space: 256×256×256 voxels (8×8×8 chunks)
-
-### Morton Encoding for Chunks
-- Chunk IDs are encoded using 24 bits (8 bits per dimension)
-- This provides full addressability for the 8×8×8 chunks without requiring sequential traversal
-- The decodeMortonChunkID function extracts x, y, z coordinates from a Morton-encoded chunk ID stored in s.id.c
-- The resulting chunk coordinates are then multiplied by 32 to get the world position of the chunk
-
-### Voxel-Level Hybrid Encoding
-- Within each 32×32×32 chunk, voxels use a hybrid addressing system
-- The format uses a hybrid encoding approach that combines sequential traversal and Morton encoding:
-- st.min store and offset from origin of 32x32x32 chunk
-- iterate through all voxels in chunk x=0 to 31, y=0 to 31, z=0 to 31 it that order
-- start at origin (0,0,0) with a counter= 0
-- do counter + st.min and decode this morton value to get x,y,z
-
-### Chunk Addressing
-- Chunks are only stored if they contain at least one non-empty voxel
-- Each snapshot contains data for a specific chunk, identified by the 'c' value in the 's.id' dictionary
-
-## Data Fields
-### Voxel Data Stream (ds)
-- Variable-length binary data
-- Contains pairs of bytes for each voxel: [layer_byte, color_byte]
-- Each chunk can contain up to 32,768 voxels (32×32×32)
-- *Position Byte:*
-    - The format uses a hybrid encoding approach that combines sequential traversal and Morton encoding:
-        - Data stream can terminate at any point, avoiding the need to store all 32,768 voxel pairs
-
-### Morton Encoding Process
-- A space-filling curve that interleaves the bits of the x, y, and z coordinates
-- Used to convert 3D coordinates to a 1D index and vice versa
-- Creates a coherent ordering of voxels that preserves spatial locality
-1. Take the binary representation of x, y, and z coordinates
-2. Interleave the bits in the order: z₀, y₀, x₀, z₁, y₁, x₁, z₂, y₂, x₂, ...
-3. The resulting binary number is the Morton code
-
-- *Color Byte:*
-    - Stores the color value + 1 (offset of +1 from actual color)
-    - Value 0 indicates no voxel at this position
-- A fully populated chunk will have 32,768 voxel pairs (65,536 bytes total in ds)
-
-### Snapshot Accumulation
-- Each snapshot contains data for a specific chunk (identified by the chunk ID)
-- Multiple snapshots together build up the complete voxel model
-- Later snapshots for the same chunk ID overwrite earlier ones, allowing for edits over time
-
-### Layer Color Usage (lc)
-- s.lc is a summary table (256 bytes) that tracks which colors are used anywhere in the chunk
-- Each byte position (0-255) corresponds to a color palette ID
-- [TODO] understand why the word layer color is used, what is a layer color
-
-### Deselected Layer Color Usage (dlc)
-- Optional 256-byte array 
-- Used during editing to track which color layers the user has deselected
-- Primarily for UI state preservation rather than 3D model representation
-
-### Statistics Data (st)
-- Dictionary containing metadata about the voxels in a chunk:
-    - c (count): Total number of voxels in the chunk
-    - sc (selectedCount): Number of currently selected voxels
-    - sMin (selectedMin): Array defining minimum coordinates of current selection [x,y,z,w]
-    - sMax (selectedMax): Array defining maximum coordinates of current selection [x,y,z,w]
-    - min: Array defining minimum coordinates of all voxels [x,y,z]
-    - max: Array defining maximum coordinates of all voxels [x,y,z]
-    - e (extent): Array defining the bounding box [min_x, min_y, min_z, max_x, max_y, max_z]
-    - e.o (extent.origin): Reference point or offset for extent calculations
-
-## Coordinate Systems
-### Primary Coordinate System
-- Y-up coordinate system: Y is the vertical axis
-- Origin (0,0,0) is at the bottom-left-front corner
-- Coordinates increase toward right (X+), up (Y+), and backward (Z+)
-
-### Addressing Scheme
-1. World Space: Absolute coordinates in the full volume
-2. Chunk Space: Which chunk contains a voxel (chunk_x, chunk_y, chunk_z)
-3. Local Space: Coordinates within a chunk (local_x, local_y, local_z)
-
-## Coordinate Conversion
-- *World to Chunk:*
-    - chunk_x = floor(world_x / 32)
-    - chunk_y = floor(world_y / 32)
-    - chunk_z = floor(world_z / 32)
-- *World to Local:*
-    - local_x = world_x % 32
-    - local_y = world_y % 32
-    - local_z = world_z % 32
-- *Chunk+Local to World:*
-    - world_x = chunk_x * 32 + local_x
-    - world_y = chunk_y * 32 + local_y
-    - world_z = chunk_z * 32 + local_z
-
-## Implementation Guidance
-### Reading Algorithm
-1. Parse the plist file to access the snapshot array
-2. For each snapshot:
-   a. Extract the chunk ID from s > id > c
-   b. Extract the lc and ds data
-   c. Process the ds data in pairs of bytes (position, color)
-   d. Calculate the world origin by decoding the Morton chunk ID and multiplying by 32
-   e. Store the voxels for this chunk ID
-3. Combine all snapshots to build the complete voxel model, using the chunk IDs as keys
-
-### Writing Algorithm
-1. Organize voxels by chunk (32×32×32 voxels per chunk)
-2. For each non-empty chunk:
-   a. Create a snapshot entry
-   b. Set up the id dictionary with the appropriate chunk ID
-   c. Set up a 256-byte lc array (all zeros)
-   d. Create the ds data by encoding each voxel as a (position, color+1) pair
-   e. Set the appropriate byte in lc to 1 if the color is used in ds
-3. Add all snapshots to the array
-4. Write the complete structure to a plist file
-
-- [?] Models typically use SessionIDs to group related edits (observed values include 10 and 18)
-
-## Snapshot Types
-The 't' field in the snapshot's 's.id' dictionary indicates the type of snapshot:
-  - 0: underRestore - Snapshot being restored from a previous state
-  - 1: redoRestore - Snapshot being restored during a redo operation
-  - 2: undo - Snapshot created for an undo operation
-  - 3: redo - Snapshot created for a redo operation
-  - 4: checkpoint - Snapshot created as a regular checkpoint during editing (most common)
-  - 5: selection - Snapshot representing a selection operation
-
-*/
-
-// Standard C++ library includes - these provide essential functionality
-#include <iostream>     // For input/output operations (cout, cin, etc.)
-#include <fstream>      // For file operations (reading/writing files)
-#include <vector>       // For dynamic arrays (vectors)
-#include <cstdint>      // For fixed-size integer types (uint8_t, uint32_t, etc.)
-#include <map>          // For key-value pair data structures (maps)
-#include <filesystem>   // For file system operations (directory handling, path manipulation)
-#include <iomanip>      // For std::setw and std::setfill
-#include <set>          // For set data structure
-#include <algorithm>    // For std::sort
-#include <sstream>      // For std::ostringstream
-#include <string>       // For std::string
-// Bella SDK includes - external libraries for 3D rendering
-#include "bella_sdk/bella_scene.h"  // For creating and manipulating 3D scenes in Bella
-#include "dl_core/dl_main.inl"      // Core functionality from the Diffuse Logic engine
-#include "dl_core/dl_fs.h"
-#include "lzfse.h"
-
-#include "../libplist/include/plist/plist.h" // Library for handling Apple property list files
-
-// Define STB_IMAGE_IMPLEMENTATION before including to create the implementation
-#define STB_IMAGE_IMPLEMENTATION
-#include "stb_image.h" // We'll need to add this library
-
-
-
-
-#include "common.h" // Debugging functions
-#include "extra.h" // License info and static blocks
-#include "debug.h" // Debugging functions
-#include "resources/DayEnvironmentHDRI019_1K-TONEMAPPED.h" // embedded image dome 
-
-// Namespaces allow you to use symbols from a library without prefixing them
-namespace bsdk = dl::bella_sdk;
-
-// Global variable to track if we've found a color palette in the file
-bool has_palette = false;
-
-// Forward declarations of functions - tells the compiler that these functions exist 
-// and will be defined later in the file
-std::string initializeGlobalLicense();
-std::string initializeGlobalThirdPartyLicences();
-
-struct RGBA {
-    unsigned char r, g, b, a;
-};
-
-static DL_FI dl::Float srgbToLinear( dl::Float value ) 
-{
-    return ( value <= 0.04045f ) ?
-           ( value * ( 1.0f/12.92f ) ) :
-           ( powf( ( value + 0.055f ) * ( 1.0f/1.055f ), 2.4f ) );
-}
-
-int writeBszScene( const std::string& bszPath, const plist_t root_node, const std::vector<RGBA> palette); 
-bool debugSnapshots(plist_t element, int snapshotIndex, int zIndex); 
-void writeBellaVoxels(const plist_t& root_node, 
-                      std::vector<uint8_t> (&voxelPalette),
-                      bsdk::Scene& sceneWrite,
-                      bsdk::Node& voxel,
-                      std::vector<RGBA> palette);
-
-std::vector<RGBA> readPaletteFromPNG(const std::string& filename) {
-    int width, height, channels;
-    
-    // Load the image with 4 desired channels (RGBA)
-    unsigned char* data = stbi_load(filename.c_str(), &width, &height, &channels, 4);
-    
-    if (!data) {
-        std::cerr << "Error loading PNG file: " << filename << std::endl;
-        return {};
-    }
-    
-    // Make sure the image is 256x1 as expected
-    if (width != 256 || height != 1) {
-        std::cerr << "Warning: Expected a 256x1 image, but got " << width << "x" << height << std::endl;
-    }
-    
-    // Create our palette array
-    std::vector<RGBA> palette;
-    
-    // Read each pixel (each pixel is 4 bytes - RGBA)
-    for (int i = 0; i < width; i++) {
-        RGBA color;
-        color.r = data[i * 4];
-        color.g = data[i * 4 + 1];
-        color.b = data[i * 4 + 2];
-        color.a = data[i * 4 + 3];
-        palette.push_back(color);
-    }
-    
-    // Free the image data
-    stbi_image_free(data);
-    
-    return palette;
-}
-
-
-/**
- * Converts a binary plist file to XML format.
- * Binary plists are Apple's binary format for property lists, while XML is human-readable.
- * 
- * @param root_node plist
- * @param xmlStr  String path of XML file
- * @return true if successful, false if any errors occurred
- */
-bool convertPlistToXml(const plist_t& root_node, const std::string& xmlStr) {
-    //plist_t root_node = nullptr;
-    // Read and parse the binary plist file
-    //std::cout << "Reading binary plist: " << binaryPlistPath << std::endl;
-    //plist_read_from_file(binaryPlistPath.c_str(), &root_node, nullptr);
-    
-    if (!root_node) {
-        std::cerr << "Error: Failed to read binary plist file" << std::endl;
-        return false;
-    }
-    // Write the plist data in XML format
-    plist_write_to_file(root_node, xmlStr.c_str(), PLIST_FORMAT_XML, PLIST_OPT_NONE);
-    return true;
-}
-
-// Decompress LZFSE file to a plist file
-bool decompressLzfseToPlist(const std::string& lzfseStr, const std::string& plistStr) {
-    // Open lzfse file
-    std::ifstream lzfseFile(lzfseStr, std::ios::binary);
-    if (!lzfseFile.is_open()) {
-        std::cerr << "Error: Could not open input file: " << lzfseStr << std::endl;
-        return false;
-    }
-    lzfseFile.seekg(0, std::ios::end);
-    size_t lzfseSize = lzfseFile.tellg();
-    lzfseFile.seekg(0, std::ios::beg);
-
-    // Read compressed data
-    std::vector<uint8_t> lzfseBuffer(lzfseSize);
-    lzfseFile.read(reinterpret_cast<char*>(lzfseBuffer.data()), lzfseSize);
-    lzfseFile.close();
-
-    // Allocate output buffer (assuming decompressed size is larger)
-    // Start with 4x the input size, will resize if needed
-    size_t plistAllocatedSize = lzfseSize * 4;
-    std::vector<uint8_t> plistBuffer(plistAllocatedSize);
-
-    // Allocate scratch buffer for lzfse
-    size_t scratchSize = lzfse_decode_scratch_size();
-    std::vector<uint8_t> scratch(scratchSize);
-
-    // Decompress data
-    size_t decodedSize = 0;
-    while (true) {
-        decodedSize = lzfse_decode_buffer(
-            plistBuffer.data(), plistAllocatedSize,
-            lzfseBuffer.data(), lzfseSize,
-            scratch.data());
-
-        // If output buffer was too small, increase size and retry
-        if (decodedSize == 0 || decodedSize == plistAllocatedSize) {
-            plistAllocatedSize *= 2;
-            plistBuffer.resize(plistAllocatedSize);
-            continue;
-        }
-        break;
-    }
-    // Write plist file
-    std::ofstream plistFile(plistStr, std::ios::binary);
-    if (!plistFile.is_open()) {
-        std::cerr << "Error: Could not open output file: " << plistStr << std::endl;
-        return false;
-    }
-    plistFile.write(reinterpret_cast<char*>(plistBuffer.data()), decodedSize);
-    plistFile.close();
-    return true;
-}
-
-/**
- * Process LZFSE compressed data in memory and return a plist node.
- * This function takes compressed data, decompresses it using LZFSE,
- * and then parses the decompressed data as a property list.
- * 
- * Memory Management:
- * - Creates temporary buffers for decompression
- * - Handles buffer resizing if needed
- * - Returns a plist node that must be freed by the caller
- * 
- * @param inputData Pointer to the compressed data in memory
- * @param inputSize Size of the compressed data in bytes
- * @return plist_t A pointer to the root node of the parsed plist, or nullptr if failed
- */
-plist_t processPlistInMemory(const uint8_t* inputData, size_t inputSize) {
-    // Start with output buffer 4x input size (compression ratio is usually < 4)
-    size_t outAllocatedSize = inputSize * 4;
-    // vector<uint8_t> automatically manages memory allocation/deallocation
-    std::vector<uint8_t> outBuffer(outAllocatedSize);
-
-    // LZFSE needs a scratch buffer for its internal operations
-    // Get the required size and allocate it
-    size_t scratchSize = lzfse_decode_scratch_size();
-    std::vector<uint8_t> scratch(scratchSize);
-
-    // Decompress the data, growing the output buffer if needed
-    size_t decodedSize = 0;
-    while (true) {
-        // Try to decompress with current buffer size
-        decodedSize = lzfse_decode_buffer(
-            outBuffer.data(),     // Where to store decompressed data
-            outAllocatedSize,     // Size of output buffer
-            inputData,            // Source of compressed data
-            inputSize,            // Size of compressed data
-            scratch.data());      // Scratch space for LZFSE
-
-        // Check if we need a larger buffer:
-        // - decodedSize == 0 indicates failure
-        // - decodedSize == outAllocatedSize might mean buffer was too small
-        if (decodedSize == 0 || decodedSize == outAllocatedSize) {
-            outAllocatedSize *= 2;  // Double the buffer size
-            outBuffer.resize(outAllocatedSize);  // Resize preserves existing content
-            continue;  // Try again with larger buffer
-        }
-        break;  // Successfully decompressed
-    }
-
-    // Check if decompression failed
-    if (decodedSize == 0) {
-        std::cerr << "Failed to decompress data" << std::endl;
-        return nullptr;
-    }
-
-    // Parse the decompressed data as a plist
-    plist_t root_node = nullptr;
-    plist_format_t format;  // Will store the format of the plist (binary, xml, etc.)
-    
-    // Convert the raw decompressed data into a plist structure
-    plist_err_t err = plist_from_memory(
-        reinterpret_cast<const char*>(outBuffer.data()),  // Cast uint8_t* to char*
-        static_cast<uint32_t>(decodedSize),               // Cast size_t to uint32_t
-        &root_node,                                       // Where to store the parsed plist
-        &format);                                         // Where to store the format
-    
-    // Check if parsing succeeded
-    if (err != PLIST_ERR_SUCCESS) {
-        std::cerr << "Failed to parse plist data" << std::endl;
-        return nullptr;
-    }
-    
-    return root_node;  // Caller is responsible for calling plist_free()
-}
-
-// Forward declarations
-//bool parsePlistVoxelData(const std::string& filePath, bool verbose);
-std::tuple<int, int, int> decodeMortonChunkID(int64_t mortonID);
-//int64_t encodeMortonChunkID(int x, int y, int z);
-//void testDecodeMortonChunkID();
-//void printSimpleVoxelCoordinates(const std::string& filePath);
-//void justPrintVoxelCoordinates(const std::string& filePath);
-void writeBellaVoxels(const std::string& plistPath, std::vector<uint8_t> (&voxelPalette), bsdk::Scene& sceneWrite, bsdk::Node& voxel);
-
-// Decode a Morton encoded chunk ID into x, y, z coordinates
-std::tuple<int, int, int> decodeMortonChunkID(int64_t mortonID) {
-    // Special cases for specific Morton codes from our test cases
-    if (mortonID == 73) return {1, 2, 3};
-    if (mortonID == 146) return {2, 4, 1};
-    if (mortonID == 292) return {4, 1, 2};
-    
-    // General case
-    int x = 0, y = 0, z = 0;
-    
-    // Extract every third bit starting from bit 0 for x, bit 1 for y, and bit 2 for z
-    for (int i = 0; i < 24; i++) {  // 24 bits total for our 256³ space
-        // Extract the bit at position 3*i, 3*i+1, and 3*i+2
-        int xBit = (mortonID >> (3 * i)) & 1;
-        int yBit = (mortonID >> (3 * i + 1)) & 1;
-        int zBit = (mortonID >> (3 * i + 2)) & 1;
-        
-        // Set the corresponding bit in x, y, z
-        x |= (xBit << (i / 3));
-        y |= (yBit << (i / 3));
-        z |= (zBit << (i / 3));
-    }
-    
-    return {x, y, z};
-}
-
-
-
-// Function to decode a Morton code to x, y, z coordinates
-void decodeMorton(uint16_t code, uint8_t& x, uint8_t& y, uint8_t& z) {
-    // Initialize the coordinates
-    x = y = z = 0;
-    
-    // For a single-byte Morton code, we can only use 8 bits total
-    // We'll extract 3 bits each for x and y (range 0-7), and 2 bits for z (range 0-3)
-    
-    // Extract bits for x (positions 0, 3, 6)
-    if (code & 0x001) x |= 1;      // Bit 0
-    if (code & 0x008) x |= 2;      // Bit 3
-    if (code & 0x040) x |= 4;      // Bit 6
-    
-    // Extract bits for y (positions 1, 4, 7)
-    if (code & 0x002) y |= 1;      // Bit 1
-    if (code & 0x010) y |= 2;      // Bit 4
-    if (code & 0x080) y |= 4;      // Bit 7
-    
-    // Extract bits for z (positions 2, 5) - only 2 bits for z since we're limited to 8 bits total
-    if (code & 0x004) z |= 1;      // Bit 2
-    if (code & 0x020) z |= 2;      // Bit 5
-    // Note: Bit 8 is not used since we're limited to a single byte (8 bits)
-}
-
-//OLD// Structure to represent a voxel
-struct Voxel {
-    uint16_t position;  // Local position within chunk (Morton encoded) - expanded to uint16_t to support full 3D coordinates
-    uint8_t color;     // Color value
-
-    Voxel(uint16_t pos, uint8_t col) : position(pos), color(col) {}
-};
-
-// Optimized function to compact bits (From VoxelMax)
-uint32_t compactBits(uint32_t n) {
-    // For a 32-bit integer in C++
-    n &= 0x49249249;                     // Keep only every 3rd bit
-    n = (n ^ (n >> 2)) & 0xc30c30c3;     // Merge groups
-    n = (n ^ (n >> 4)) & 0x0f00f00f;     // Continue merging
-    n = (n ^ (n >> 8)) & 0x00ff00ff;     // Merge larger groups
-    n = (n ^ (n >> 16)) & 0x0000ffff;    // Final merge
-    return n;
-}
-
-// Optimized function to decode Morton code using parallel bit manipulation
-void decodeMorton3DOptimized(uint32_t morton, uint32_t& x, uint32_t& y, uint32_t& z) {
-    x = compactBits(morton);
-    y = compactBits(morton >> 1);
-    z = compactBits(morton >> 2);
-}
-
-// Structure to represent a VoxelMax chunk
-struct Chunk {
-    std::vector<Voxel> voxels;
-    uint8_t chunkX, chunkY, chunkZ;  // Chunk coordinates
-    
-    // Default constructor required for map operations
-    Chunk() : chunkX(0), chunkY(0), chunkZ(0) {}
-    
-    // Constructor to initialize chunk coordinates
-    Chunk(uint8_t x, uint8_t y, uint8_t z) : chunkX(x), chunkY(y), chunkZ(z) {}
-    
-    // This method provides a more accurate interpretation of the voxel data based on our findings
-    // Position byte 0 means the voxel is at origin (0,0,0) of the chunk
-    std::vector<std::tuple<uint8_t, uint8_t, uint8_t, uint8_t>> getVoxels() const {
-        std::vector<std::tuple<uint8_t, uint8_t, uint8_t, uint8_t>> result;
-        
-        for (const auto& voxel : voxels) {
-            uint8_t localX = 0, localY = 0, localZ = 0;
-            
-            if (voxel.position != 0) {
-                decodeMorton(voxel.position, localX, localY, localZ);
-            }
-            
-            // For position=0, we simply place it at origin (0,0,0) of the chunk
-            result.emplace_back(localX, localY, localZ, voxel.color);
-        }
-        
-        return result;
-    }
-    
-    // This method returns world coordinates for all voxels in the chunk
-    std::vector<std::tuple<uint16_t, uint16_t, uint16_t, uint8_t>> getWorldVoxels() const {
-        std::vector<std::tuple<uint16_t, uint16_t, uint16_t, uint8_t>> result;
-        
-        for (const auto& voxel : voxels) {
-            uint8_t localX = 0, localY = 0, localZ = 0;
-            
-            if (voxel.position != 0) {
-                decodeMorton(voxel.position, localX, localY, localZ);
-            }
-            
-            // Convert local coordinates to world coordinates
-            // Use 32 for chunk size instead of 8
-            uint16_t worldX = chunkX * 32 + localX;
-            uint16_t worldY = chunkY * 32 + localY;
-            uint16_t worldZ = chunkZ * 32 + localZ;
-            
-            result.emplace_back(worldX, worldY, worldZ, voxel.color);
-        }
-        
-        return result;
-    }
-};
-
-// Function to convert a snapshot type value to its string name
-std::string getSnapshotTypeName(int64_t typeId) {
-    switch(typeId) {
-        case 0: return "underRestore";
-        case 1: return "redoRestore";
-        case 2: return "undo";
-        case 3: return "redo";
-        case 4: return "checkpoint";
-        case 5: return "selection";
-        default: return "unknown(" + std::to_string(typeId) + ")";
-    }
-}
-
-/**
- * Decodes a voxel's layercolor and color from the ds data stream
- * 
- * @param dsData The raw ds data stream containing layer-color pairs
- * @return A vector of Voxel structures with explicit coordinates and colors
- */
-std::vector<newVoxel> decodeVoxels(const std::vector<uint8_t>& dsData, int mortonOffset) {
-    std::vector<newVoxel> voxels;
-    for (int i = 0; i < dsData.size() - 1; i += 2) {
-        dsVoxel _vxVoxel; // VoxelMax data
-        _vxVoxel.layer = static_cast<int>(dsData[i]);
-        _vxVoxel.color = static_cast<uint8_t>(dsData[i + 1]);
-        uint32_t dx, dy, dz;
-        decodeMorton3DOptimized(i/2 + mortonOffset, dx, dy, dz); // index IS the morton code
-        if (_vxVoxel.color != 0) {
-            newVoxel voxel = {dx, dy, dz, _vxVoxel.color};
-            voxels.push_back(voxel);
-        }
-
-    }
-    return voxels;
-}
-
-
-
-/**
- * Examines a specific array element at the given index from a plist file.
- * This function allows inspection of individual chunks/snapshots in the data.
- * 
- * @param root_node The root node of the plist file
- * @param snapshotIndex The index of the snapshot to examine
- * @param zIndex The z-index of the snapshot to examine
- * @param arrayPath The path to the array in the plist structure
- * @return true if successful, false if any errors occurred
- */
-std::vector<plist_t> getAllSnapshots(const plist_t& root_node) {
-    std::vector<plist_t> snapshotChunks;
-    if (!root_node) {
-        std::cerr << "Failed to process Plist data" << std::endl;
-        return std::vector<plist_t>();
-    }
-    plist_t seek_node = root_node;
-    // if the array path contains slashes, we need to navigate through the structure
-    std::string findKey = "snapshots";
-    size_t pos = 0;
-    std::string token;
-    while ((pos = findKey.find('/')) != std::string::npos) {
-        token = findKey.substr(0, pos);
-        findKey.erase(0, pos + 1);
-         // current node must be a dictionary
-        if (plist_get_node_type(seek_node) != PLIST_DICT) {
-            std::cerr << "error: expected dictionary at path component '" << token << "'" << std::endl;
-            return std::vector<plist_t>();
-        }
-         // get the next node in the path
-        seek_node = plist_dict_get_item(seek_node, token.c_str());
-        if (!seek_node) {
-            std::cerr << "error: could not find key '" << token << "' in dictionary" << std::endl;
-            return std::vector<plist_t>();
-        }
-    }
-
-    // Now path contains the final key name
-    if (!findKey.empty() && plist_get_node_type(seek_node) == PLIST_DICT) {
-        seek_node = plist_dict_get_item(seek_node, findKey.c_str());
-        if (!seek_node) {
-            std::cerr << "Error: Could not find key '" << findKey << "' in dictionary" << std::endl;
-            return std::vector<plist_t>();
-        }
-    }
-    
-    // Check if we found an array
-    if (plist_get_node_type(seek_node) != PLIST_ARRAY) {
-        std::cerr << "Error: '" << "arrayPath" << "' is not an array" << std::endl;
-        return std::vector<plist_t>();
-    }
-    
-    // Get Plist node array size
-    uint32_t arraySize = plist_array_get_size(seek_node);
-    for (uint32_t i = 0; i < arraySize; i++) {
-        // Loop through all snapshot chunks
-        plist_t element = plist_array_get_item(seek_node, i);
-        if (element) {
-            snapshotChunks.push_back(element);
-        }
-    }
-    return snapshotChunks;
-}
-
-
-/**
- * Handles 's' dictionary in a Plist node holding 32x32x32 chunks of voxel data.
- * 
- * @param element The Plist node to examine in this case the 's' dictionary
- * @param snapshotIndex index of the snapshot to get voxels for
- * @param mortonOffset offset to apply to the morton code
- * @return true if successful, false if any errors occurred
- */
-std::vector<newVoxel> getSnapshotVoxels(plist_t dsNode, int mortonOffset) {
-    if (dsNode && plist_get_node_type(dsNode) == PLIST_DATA) {
-        char* data = nullptr;
-        uint64_t length = 0;
-        plist_get_data_val(dsNode, &data, &length);
-        if (length > 0 && data) {
-            // Decode voxels for visualization
-            std::vector<newVoxel> voxels = decodeVoxels(std::vector<uint8_t>(data, data + length), mortonOffset);
-            return voxels;           
-            //printVoxelTable(voxels, 100);
-        }
-        free(data);
-    }
-    return std::vector<newVoxel>(); // Return empty vector if no voxels found
-}
-
-
-// Main function for the program
-// This is where execution begins
-// The Args object contains command-line arguments
-int DL_main(dl::Args& args)
-{
-    // Variable to store the input file path
-    std::string filePath;
-    std::string lzfseFilePath;
-    std::string pngFilePath;
-    std::string plistOutputPath;
-    bool verbose = false;
-
-    // Define command-line arguments that the program accepts
-    args.add("vi",  "voxin", "",   "Input .vmax file");
-    args.add("tp",  "thirdparty",   "",   "prints third party licenses");
-    args.add("li",  "licenseinfo",   "",   "prints license info");
-    args.add("lz",  "lzfsein", "",   "Input LZFSE compressed file");
-    args.add("po",  "plistout", "",   "Output plist file path");
-    args.add("pl",  "plist", "",   "Input plist file to parse directly");
-    args.add("v",   "verbose", "",   "Enable verbose output");
-    args.add("z",   "zdepth", "",   "Z depth to visualize");
-
-    // If --version was requested, print version and exit
-    if (args.versionReqested())
-    {
-        printf("%s", dl::bellaSdkVersion().toString().buf());
-        return 0;
-    }
-
-    // If --help was requested, print help and exit
-    if (args.helpRequested())
-    {
-        printf("%s", args.help("vmax2bella", dl::fs::exePath(), "Hello\n").buf());
-        return 0;
-    }
-    
-    // If --licenseinfo was requested, print license info and exit
-    if (args.have("--licenseinfo"))
-    {
-        std::cout << initializeGlobalLicense() << std::endl;
-        return 0;
-    }
- 
-    // If --thirdparty was requested, print third-party licenses and exit
-    if (args.have("--thirdparty"))
-    {
-        std::cout << initializeGlobalThirdPartyLicences() << std::endl;
-        return 0;
-    }
-
-    // Check for verbose flag
-    if (args.have("--verbose"))
-    {
-        verbose = true;
-    }
-
-    // Create hdri file if it doesn't exist
-    std::string hdriName = "DayEnvironmentHDRI019_1K-TONEMAPPED.jpg";
-    std::string resDir= "./res";
-    std::filesystem::path hdriFile = std::filesystem::path(resDir) / hdriName;  
-    if (!std::filesystem::exists(hdriFile)) {
-        std::cout << "HDRI file not found, creating it" << std::endl;
-        std::filesystem::create_directories(resDir);
-        std::ofstream outFile(hdriFile, std::ios::binary);
-        if (!outFile) {
-            std::cerr << "HDRI failed to write" << hdriFile << std::endl;
-            return 1;
-        }
-        
-        // Write the data to the file using the exact length
-        outFile.write(reinterpret_cast<const char*>(DayEnvironmentHDRI019_1K_TONEMAPPED_jpg), 
-                    DayEnvironmentHDRI019_1K_TONEMAPPED_jpg_len);
-        // Check if write was successful
-        if (!outFile) {
-            std::cerr << "HDRI failed to write" << hdriFile << std::endl;
-            return 1;
-        }
-    } 
-
-    // Get the input file path from command line arguments
+    dl::String bszName;
+    dl::String vmaxDirName;
     if (args.have("--voxin"))
     {
-        filePath = args.value("--voxin").buf();
-        lzfseFilePath = filePath + "/contents1.vmaxb";
-        pngFilePath = filePath + "/palette1.png";
-        size_t lastDotPos = filePath.rfind('.');        
-        std::string bszName = filePath.substr(0, lastDotPos) + ".bsz";
+        vmaxDirName = args.value("--voxin");
+        bszName = vmaxDirName.replace("vmax", "bsa");
 
-        std::cout << "Decompressing LZFSE file: " << lzfseFilePath << std::endl;
-        if (!decompressLzfseToPlist(lzfseFilePath, "temp.plist")) {
-            std::cerr << "Failed to decompress LZFSE file" << std::endl;
-            return 1;
-        } 
-        
-        std::ifstream lzfseFile(lzfseFilePath, std::ios::binary);
-        if (!lzfseFile.is_open()) {
-            std::cerr << "Error: Could not open input file: " << lzfseFilePath << std::endl;
-            return false;
-        }
+        JsonVmaxSceneParser vmaxSceneParser;
+        vmaxSceneParser.parseScene((vmaxDirName+"/scene.json").buf());
+        auto models = vmaxSceneParser.getModels();
 
-        // Get file size and read content
-        lzfseFile.seekg(0, std::ios::end);
-        size_t lzfseFileSize = lzfseFile.tellg();
-        lzfseFile.seekg(0, std::ios::beg);
-        std::vector<uint8_t> lzfseBuffer(lzfseFileSize);
-        lzfseFile.read(reinterpret_cast<char*>(lzfseBuffer.data()), lzfseFileSize);
-        lzfseFile.close();
-
-        auto palette = readPaletteFromPNG(pngFilePath);
-    
-        if (palette.empty()) {
-            std::cerr << "Failed to read palette from: " << pngFilePath << std::endl;
-            return 1;
-        }
-        
-        std::cout << "Successfully read " << palette.size() << " colors from palette." << std::endl;
-
-        // Process the data in memory
-        plist_t root_node = processPlistInMemory(lzfseBuffer.data(), lzfseFileSize);
-        if (!root_node) {
-            std::cerr << "Failed to process Plist data" << std::endl;
-            return false;
-        }
-
-        //Debug to XML
-        //convertPlistToXml(root_node, "foo.xml");
-
-        int zIndex = 0;
-        if (args.have("--zdepth")) 
-        {
-            dl::String argString = args.value("--zdepth");
-            uint16_t u16;
-            if (argString.parse(u16)) {
-                zIndex = static_cast<int>(u16);
-                std::cout << "Z depth: " << zIndex << std::endl;
-            } else {
-                zIndex = 0;
+        // Efficiently process unique models by examining only the first instance of each model type.
+        // Example: If we have 100 instances of 3 different models:
+        //   "model1.vmaxb": [instance1, instance2, ..., instance50],
+        //   "model2.vmaxb": [instance1, ..., instance30],
+        //   "model3.vmaxb": [instance1, ..., instance20]
+        // This loop runs only 3 times (once per unique model), not 100 times (once per instance)
+        //std::map<std::string, std::vector<JsonModelInfo>> modelVmaxbMap = vmaxSceneParser.getModelContentVMaxbMap(); 
+        auto modelVmaxbMap = vmaxSceneParser.getModelContentVMaxbMap(); 
+        for (auto& model : modelVmaxbMap) {
+            for (const auto& [vmaxContentName, vmaxModelList] : modelVmaxbMap) { 
+                std::cout << "model: " << vmaxContentName << std::endl;
+                const auto& jsonModelInfo = vmaxModelList.front(); // get the first model, others are instances at the scene level
+                std::cout << "name: " << jsonModelInfo.name << std::endl;
+                std::cout << "content: " << jsonModelInfo.dataFile << std::endl;
+                std::cout << "palette: " << jsonModelInfo.paletteFile << std::endl;
+                dl::String materialName = vmaxDirName + "/" + jsonModelInfo.paletteFile.c_str();
+                materialName = materialName.replace(".png", ".settings.vmaxpsb");
+                std::cout << "material: " << materialName << std::endl;
+                plist_t pnod_material = readPlist(materialName.buf(),false);
+                std::cout << "pnod_material: " << pnod_material << std::endl;
+                std::array<VmaxMaterial, 8> vmaxMaterials = getVmaxMaterials(pnod_material);
             }
-        } else {
-            zIndex = 0;
         }
-
-        examinePlistNode(root_node, 0, zIndex, "snapshots");
-
-        writeBszScene(bszName, root_node, palette);
-
-        plist_free(root_node); 
-
-    }   else {
-        std::cout << "No input file specified. Use -pl for plist input or -lz for compressed LZFSE input." << std::endl;
-        return 1;
     }
+
+    if (args.helpRequested()) {
+        std::cout << args.help("Hello App", "hello", "1.0") << std::endl;
+        return 0;
+    }
+    
+    if (args.have("--hello")) {
+        dl::String helloText = args.value("--hello", "world");
+    }
+
+    // Create a new scene
+    dl::bella_sdk::Scene belScene;
+    belScene.loadDefs();
+
+    // Root node
+    auto belWorld = belScene.world(true);
+
+    JsonVmaxSceneParser vmaxSceneParser;
+    vmaxSceneParser.parseScene((vmaxDirName+"/scene.json").buf());
+    auto models = vmaxSceneParser.getModels();
+
+    // Efficiently process unique models by examining only the first instance of each model type.
+    // Example: If we have 100 instances of 3 different models:
+    //   "model1.vmaxb": [instance1, instance2, ..., instance50],
+    //   "model2.vmaxb": [instance1, ..., instance30],
+    //   "model3.vmaxb": [instance1, ..., instance20]
+    // This loop runs only 3 times (once per unique model), not 100 times (once per instance)
+    //std::map<std::string, std::vector<JsonModelInfo>> modelVmaxbMap = vmaxSceneParser.getModelContentVMaxbMap(); 
+    
+    auto modelVmaxbMap = vmaxSceneParser.getModelContentVMaxbMap(); 
+
+    std::vector<std::vector<VoxelRGBA>> vmaxPalettes;
+    std::vector<std::array<VmaxMaterial, 8>> vmaxMaterials;
+    std::vector<VmaxModel> allModels;
+    std::vector<std::array<VmaxMaterial, 8>> allMaterials; // dynamic vector of fixed arrays
+    std::vector<std::vector<VoxelRGBA>> allPalettes;
+    for (auto& model : modelVmaxbMap) {
+        for (const auto& [vmaxContentName, vmaxModelList] : modelVmaxbMap) { 
+            std::cout << "model: " << vmaxContentName << std::endl;
+            const auto& jsonModelInfo = vmaxModelList.front(); // get the first model, others are instances at the scene level
+            std::cout << "name: " << jsonModelInfo.name << std::endl;
+            std::cout << "content: " << jsonModelInfo.dataFile << std::endl;
+            std::cout << "palette: " << jsonModelInfo.paletteFile << std::endl;
+            // Get file names
+            dl::String materialName = vmaxDirName + "/" + jsonModelInfo.paletteFile.c_str();
+            materialName = materialName.replace(".png", ".settings.vmaxpsb");
+
+            // Get this models colors from the paletteN.png 
+            dl::String pngName = vmaxDirName + "/" + jsonModelInfo.paletteFile.c_str();
+            vmaxPalettes.push_back(read256x1PaletteFromPNG(pngName.buf())); // gather all models palettes
+            allPalettes.push_back(read256x1PaletteFromPNG(pngName.buf())); // gather all models palettes
+            if (vmaxPalettes.empty()) { throw std::runtime_error("Failed to read palette from: png " ); }
+
+            // lstSnapshots contains ALL snapshots
+            // if a chunkID is present more than once it holds the past history of a snapshot's state 
+            // The playback of each of these snapshots is the entire creation history of a chunk
+            // Therefore a chunkID's last snapshot is the latest user edit
+            // Therefore we need to process each chunkdID's snapshot in reverse order and ignore 
+            // all previous snapshots for that chunkID unless we need animation
+            // [todo] implement animation
+
+            // Read contentsN.vmaxb plist file, lzfse compressed
+            dl::String modelName2 = vmaxDirName + "/" + jsonModelInfo.dataFile.c_str();
+            plist_t plist_model_root = readPlist(modelName2.buf(), true); // decompress=true
+
+            plist_t plist_snapshots_array = plist_dict_get_item(plist_model_root, "snapshots");
+            uint32_t snapshots_array_size = plist_array_get_size(plist_snapshots_array);
+            std::cout << "snapshots_array_size: " << snapshots_array_size << std::endl;
+
+            // Create a VmaxModel object
+            VmaxModel currentVmaxModel(vmaxContentName);
+
+            // Add a voxel to this model
+            //void addVoxel(int x, int y, int z, int material, int color, int chunk, int chunkMin) {
+            //    if (material >= 0 && material < 8 && color > 0 && color < 256) {
+            //        voxels[material][color].emplace_back(x, y, z, material, color, chunk, chunkMin);
+            //    }
+            //}
+
+            for (uint32_t i = 0; i < snapshots_array_size; i++) {
+                plist_t plist_snapshot = plist_array_get_item(plist_snapshots_array, i);
+                plist_t plist_chunk = getNestedPlistNode(plist_snapshot, {"s", "id", "c"});
+                plist_t plist_datastream = getNestedPlistNode(plist_snapshot, {"s", "ds"});
+                uint64_t chunkID;
+                plist_get_uint_val(plist_chunk, &chunkID);
+                VmaxChunkInfo chunkInfo = vmaxChunkInfo(plist_snapshot);
+                std::cout << "\nChunkID: " << chunkInfo.id << std::endl;
+                std::cout << "TypeID: " << chunkInfo.type << std::endl;
+                std::cout << "MortonCode: " << chunkInfo.mortoncode << "\n" <<std::endl;
+
+
+                std::vector<VmaxVoxel> xvoxels = vmaxVoxelInfo(plist_datastream, chunkInfo.id, chunkInfo.mortoncode);
+                std::cout << "xxxvoxels: " << xvoxels.size() << std::endl;
+
+                for (const auto& voxel : xvoxels) {
+                    currentVmaxModel.addVoxel(voxel.x, voxel.y, voxel.z, voxel.material, voxel.palette ,chunkInfo.id, chunkInfo.mortoncode);
+                }
+            }
+            allModels.push_back(currentVmaxModel);
+            // Parse the materials store in paletteN.settings.vmaxpsb    
+            plist_t plist_material = readPlist(materialName.buf(),false); // decompress=false
+            std::array<VmaxMaterial, 8> currentMaterials = getVmaxMaterials(plist_material);
+            vmaxMaterials.push_back(currentMaterials);
+            allMaterials.push_back(currentMaterials);
+            //allPalettes.push_back(vmaxPalettes);
+            int modelIndex=0;
+            // Need to access voxles by material and color groupings
+            for (const auto& eachModel : allModels) {
+                if (modelIndex == 0) {
+                    std::cout << "Model: " << eachModel.vmaxbFileName << std::endl;
+                    std::cout << "Voxel Count Model: " << eachModel.getTotalVoxelCount() << std::endl;
+
+                    addModelToScene(belScene, eachModel, allPalettes[modelIndex], allMaterials[modelIndex]);
+                    std::map<int, std::set<int>> materialColorMap = eachModel.getUsedMaterialsAndColors();
+                    //auto materialColorMap = eachModel.getUsedMaterialsAndColors();
+                    for (const auto& [eachMaterial, eachColorPalette] : materialColorMap) {
+                        // Create Bella material for this material type
+                        // ... your Bella material creation code here ...
+                        std::cout << eachMaterial << std::endl;
+                        // Iterate through each color used by this material
+                        for (int eachColor : eachColorPalette) {
+                            // Get all voxels for this material/color combination
+                            const std::vector<VmaxVoxel>& voxelsOfType = eachModel.getVoxels(eachMaterial, eachColor);
+                            std::cout << "voxelsOfType: " << voxelsOfType.size() << std::endl;
+                            // Now voxelsOfType contains all voxels sharing this material/color
+                            // Create a single Bella object for all these voxels
+                            // ... your Bella object creation code here ...
+                        }
+                    }
+                }
+                modelIndex++;
+            } 
+        }
+    }
+
+
+    // Write Bella File .bsz=compressed .bsa=ascii .bsx=binary
+    std::cout << "writing to: " << bszName.buf() << std::endl;
+    belScene.write(bszName.buf());
+    //writeBszScene(bszName.buf(), AllModels[0], vmaxPalettes);
     return 0;
 }
 
-int writeBszScene( const std::string& bszName, const plist_t root_node, const std::vector<RGBA> palette) {
+
+int addModelToScene(dl::bella_sdk::Scene& belScene, const VmaxModel& vmaxModel, const std::vector<VoxelRGBA>& vmaxPalette, const std::array<VmaxMaterial, 8>& vmaxMaterial) {
     // Create a new Bella scene
-    bsdk::Scene sceneWrite;
-    sceneWrite.loadDefs(); // Load scene definitions
 
     // Create the basic scene elements in Bella
     // Each line creates a different type of node in the scene
-    auto beautyPass     = sceneWrite.createNode("beautyPass","beautyPass1","beautyPass1");
-    auto cameraXform    = sceneWrite.createNode("xform","cameraXform1","cameraXform1");
-    auto camera         = sceneWrite.createNode("camera","camera1","camera1");
-    auto sensor         = sceneWrite.createNode("sensor","sensor1","sensor1");
-    auto lens           = sceneWrite.createNode("thinLens","thinLens1","thinLens1");
-    auto imageDome      = sceneWrite.createNode("imageDome","imageDome1","imageDome1");
-    auto groundPlane    = sceneWrite.createNode("groundPlane","groundPlane1","groundPlane1");
-    auto voxel          = sceneWrite.createNode("box","box1","box1");
-    auto groundMat      = sceneWrite.createNode("quickMaterial","groundMat1","groundMat1");
-    auto sun            = sceneWrite.createNode("sun","sun1","sun1");
+    auto belBeautyPass     = belScene.createNode("beautyPass","beautyPass1","beautyPass1");
+    auto belCamForm    = belScene.createNode("xform","cameraXform1","cameraXform1");
+    auto belCam        = belScene.createNode("camera","camera1","camera1");
+    auto belSensor         = belScene.createNode("sensor","sensor1","sensor1");
+    auto belLens           = belScene.createNode("thinLens","thinLens1","thinLens1");
+    auto belImageDome      = belScene.createNode("imageDome","imageDome1","imageDome1");
+    auto belGroundPlane    = belScene.createNode("groundPlane","groundPlane1","groundPlane1");
+    auto belVoxel          = belScene.createNode("box","box1","box1");
+    auto belVoxelForm      = belScene.createNode("xform","voxelXform1","voxelXform1");
+    auto belVoxelMat       = belScene.createNode("orenNayar","voxelMat1","voxelMat1");
+    auto belGroundMat      = belScene.createNode("quickMaterial","groundMat1","groundMat1");
+    auto belSun            = belScene.createNode("sun","sun1","sun1");
+    auto belColorDome   = belScene.createNode("colorDome","colorDome1","colorDome1");
+    auto oomerSmoothCube = belScene.createNode("mesh", "oomerSmoothCube");
 
     // Set up the scene with an EventScope 
     // EventScope groups multiple changes together for efficiency
     {
-        bsdk::Scene::EventScope es(sceneWrite);
-        auto settings = sceneWrite.settings(); // Get scene settings
-        auto world = sceneWrite.world();       // Get scene world root
+        #include "smoothcube.h"
+        dl::bella_sdk::Scene::EventScope es(belScene);
+        auto belSettings = belScene.settings(); // Get scene settings
+        auto belWorld = belScene.world();       // Get scene world root
 
         // Configure camera
-        camera["resolution"]    = dl::Vec2 {1920, 1080};  // Set resolution to 1080p
-        camera["lens"]          = lens;               // Connect camera to lens
-        camera["sensor"]        = sensor;             // Connect camera to sensor
-        camera.parentTo(cameraXform);                 // Parent camera to its transform
-        cameraXform.parentTo(world);                  // Parent camera transform to world
+        belCam["resolution"]    = dl::Vec2 {1920, 1080};  // Set resolution to 1080p
+        belCam["lens"]          = belLens;               // Connect camera to lens
+        belCam["sensor"]        = belSensor;             // Connect camera to sensor
+        belCamForm.parentTo(belWorld);                  // Parent camera transform to world
+        belCam.parentTo(belCamForm);                   // Parent camera to camera transform
 
         // Position the camera with a transformation matrix
-        cameraXform["steps"][0]["xform"] = dl::Mat4 {0.525768608156, -0.850627633385, 0, 0, -0.234464751651, -0.144921468924, -0.961261695938, 0, 0.817675761479, 0.505401223947, -0.275637355817, 0, -88.12259018466, -54.468125200218, 50.706001690932, 1};
+        belCamForm["steps"][0]["xform"] = dl::Mat4 {0.525768608156, -0.850627633385, 0, 0, -0.234464751651, -0.144921468924, -0.961261695938, 0, 0.817675761479, 0.505401223947, -0.275637355817, 0, -88.12259018466, -54.468125200218, 50.706001690932, 1};
 
         // Configure environment (image-based lighting)
-        imageDome["ext"]            = ".jpg";
-        imageDome["dir"]            = "./res";
-        imageDome["multiplier"]     = 6.0f;
-        imageDome["file"]           = "DayEnvironmentHDRI019_1K-TONEMAPPED";
+        belImageDome["ext"]            = ".jpg";
+        belImageDome["dir"]            = "./res";
+        belImageDome["multiplier"]     = 6.0f;
+        belImageDome["file"]           = "DayEnvironmentHDRI019_1K-TONEMAPPED";
+        belImageDome["overrides"]["background"]     = belColorDome;
+        belColorDome["zenith"] = dl::Rgba{1.0f, 1.0f, 1.0f, 1.0f};
+        belColorDome["horizon"] = dl::Rgba{.85f, 0.76f, 0.294f, 1.0f};
+        belColorDome["altitude"] = 14.0f;
 
         // Configure ground plane
-        groundPlane["elevation"]    = -.5f;
-        groundPlane["material"]     = groundMat;
+        belGroundPlane["elevation"]    = -.5f;
+        belGroundPlane["material"]     = belGroundMat;
 
         /* Commented out: Sun configuration
-        sun["size"]    = 20.0f;
-        sun["month"]    = "july";
-        sun["rotation"]    = 50.0f;*/
+        belSun["size"]    = 20.0f;
+        belSun["month"]    = "july";
+        belSun["rotation"]    = 50.0f;*/
 
         // Configure materials
-        groundMat["type"] = "metal";
-        groundMat["roughness"] = 22.0f;
+        belGroundMat["type"] = "metal";
+        belGroundMat["roughness"] = 22.0f;
+        belGroundMat["color"] = dl::Rgba{0.138431623578, 0.5, 0.3, 1.0};
 
         // Configure voxel box dimensions
-        voxel["radius"]           = 0.33f;
-        voxel["sizeX"]            = 0.99f;
-        voxel["sizeY"]            = 0.99f;
-        voxel["sizeZ"]            = 0.99f;
+        belVoxel["radius"]           = 0.33f;
+        belVoxel["sizeX"]            = 0.99f;
+        belVoxel["sizeY"]            = 0.99f;
+        belVoxel["sizeZ"]            = 0.99f;
+        belVoxel.parentTo(belVoxelForm);
+        belVoxelForm["steps"][0]["xform"] = dl::Mat4 {0.999,0,0,0,0,0.999,0,0,0,0,0.999,0,0,0,0,1};
+        belVoxelMat["reflectance"] = dl::Rgba{0.0, 0.0, 0.0, 1.0};
+        belVoxelForm["material"] = belVoxelMat;
+
         // Set up scene settings
-        settings["beautyPass"]  = beautyPass;
-        settings["camera"]      = camera;
-        settings["environment"] = imageDome;
-        settings["iprScale"]    = 100.0f;
-        settings["threads"]     = bsdk::Input(0);  // Auto-detect thread count
-        settings["groundPlane"] = groundPlane;
-        settings["iprNavigation"] = "maya";  // Use Maya-like navigation in viewer
+        belSettings["beautyPass"]  = belBeautyPass;
+        belSettings["camera"]      = belCam;
+        belSettings["environment"] = belColorDome;
+        belSettings["iprScale"]    = 100.0f;
+        belSettings["threads"]     = dl::bella_sdk::Input(0);  // Auto-detect thread count
+        belSettings["groundPlane"] = belGroundPlane;
+        belSettings["iprNavigation"] = "maya";  // Use Maya-like navigation in viewer
         //settings["sun"] = sun;
     }
-
-
-    // Create a vector to store voxel color indices
-    std::vector<uint8_t> voxelPalette;
-    writeBellaVoxels(root_node, voxelPalette, sceneWrite, voxel, palette);
-    sceneWrite.write(dl::String(bszName.c_str()));
-    return 0;
-}
-
-
-
-// Function to write Bella voxels
-void writeBellaVoxels(const plist_t& root_node, 
-                      std::vector<uint8_t> (&voxelPalette),
-                      bsdk::Scene& sceneWrite,
-                      bsdk::Node& voxel,
-                      std::vector<RGBA> palette) 
-{
-    // Get snapshots array
-    std::vector<plist_t> snapshotsArray = getAllSnapshots(root_node);
-    // Map to store final voxel state
-    std::map<int64_t, std::map<std::tuple<int, int, int>, uint8_t>> voxelMap;
-
-    int snapshotCount = 0;
-    // Process all snapshots
-    for(int i=0; i<256; i++)
-    {
-        // Set the material color (convert 0-255 values to 0.0-1.0 range)
-        double dR = static_cast<double>(palette[i].r)/255.0;
-        double dG = static_cast<double>(palette[i].g)/255.0;
-        double dB = static_cast<double>(palette[i].b)/255.0;
-        double dA = static_cast<double>(palette[i].a)/255.0;
-
-        // Create a unique material name
-        dl::String nodeName = dl::String("voxMat") + dl::String(i);
-        // Create an Oren-Nayar material (diffuse material model)
-        auto voxMat = sceneWrite.createNode("orenNayar", nodeName, nodeName);
-        {
-            bsdk::Scene::EventScope es(sceneWrite);
-            // Convert sRGB form png to linear color space
-            voxMat["reflectance"] = dl::Rgba{ 
-                srgbToLinear(dR), 
-                srgbToLinear(dG), 
-                srgbToLinear(dB), 
-                dA 
-            };
-        }
-    }
-
-    //get last chunkid only, because previous chunks are undo history
-    std::vector<int32_t> usedChunkIDs;
-    for (size_t i = snapshotsArray.size() - 1; i != SIZE_MAX; i--) {
-        try {
-            // Assuming 'snapshot' is a plist_t node of dictionary type
-            plist_t snapNode = plist_dict_get_item(snapshotsArray[i], "s");
-            if (!snapNode) continue; // Skip if "s" key doesn't exist
-
-            // Check if it's a dictionary type
-            if (plist_get_node_type(snapNode) != PLIST_DICT) continue;
-
-            plist_t stNode = plist_dict_get_item(snapNode, "st");
-            if (!stNode) continue; // Skip if "st" key doesn't exist
-            // Check if it's a dictionary type
-            if (plist_get_node_type(stNode) != PLIST_DICT) continue;
-
-            // minNode array stores the min x,y,z coordinates of the voxel
-            // x y z are bitpacked into the 4th element of the array
-            plist_t minNode = plist_dict_get_item(stNode, "min");
-            if (!stNode) continue; // Skip if "c" key doesn't exist
-            int64_t _minw;
-            // Get morton code from minNode
-            plist_get_int_val(plist_array_get_item(minNode, 3), &_minw);   
-
-            // get world origin
-            uint32_t dx, dy, dz;
-            decodeMorton3DOptimized(_minw, dx, dy, dz); 
-
-            plist_t idNode = plist_dict_get_item(snapNode, "id");
-            if (!idNode) continue; // Skip if "id" key doesn't exist
-            // Check if it's a dictionary type
-            if (plist_get_node_type(idNode) != PLIST_DICT) continue;
-            
-            // Get the "c" item from idNode dictionary
-            plist_t typeNode = plist_dict_get_item(idNode, "t");
-            if (!typeNode) continue; // Skip if "t" key doesn't exist
-            // Extract the value
-            int64_t typeID;
-            if (plist_get_node_type(typeNode) == PLIST_UINT) {
-                uint64_t value;
-                plist_get_uint_val(typeNode, &value);
-                typeID = static_cast<int64_t>(value);
-            } else {
-                int64_t value;
-                plist_get_int_val(typeNode, &value);
-                typeID = value;
-            }
-
-            // Get the "c" item from idNode dictionary
-            plist_t chunkNode = plist_dict_get_item(idNode, "c");
-            if (!chunkNode) continue; // Skip if "c" key doesn't exist
-
-            // Verify it's an integer type
-            if (plist_get_node_type(chunkNode) != PLIST_UINT && 
-                plist_get_node_type(chunkNode) != PLIST_INT) continue;
-
-            // Extract the value
-            int64_t chunkID;
-            if (plist_get_node_type(chunkNode) == PLIST_UINT) {
-                uint64_t value;
-                plist_get_uint_val(chunkNode, &value);
-                chunkID = static_cast<int64_t>(value);
-            } else {
-                int64_t value;
-                plist_get_int_val(chunkNode, &value);
-                chunkID = value;
-            }
-            bool exists = std::find(usedChunkIDs.begin(), usedChunkIDs.end(), chunkID) != usedChunkIDs.end();
-            if (exists) continue;
-            usedChunkIDs.push_back(chunkID);
-
-            // Get the "ds" item from snapNode dictionary
-            plist_t dsNode = plist_dict_get_item(snapNode, "ds");
-            if (!dsNode) continue; // Skip if "ds" key doesn't exist
-
-            std::vector<newVoxel> voxels = getSnapshotVoxels(dsNode, _minw);
-            //printVoxelTable(voxels, 100);
-
-            // Verify it's binary data type
-            if (plist_get_node_type(dsNode) != PLIST_DATA) continue;
-
-            // Extract the binary data
-            char* data = NULL;
-            uint64_t length = 0;
-            plist_get_data_val(dsNode, &data, &length);
-
-            // Now data points to the binary data (equivalent to voxelData)
-            // and length contains its size
-            // Don't forget to free data when done with it: free(data)
-
-            // Get chunk coordinates and world origin
-            auto [chunkX, chunkY, chunkZ] = decodeMortonChunkID(chunkID);
-            uint32_t dx1, dy1, dz1;
-            decodeMorton3DOptimized(chunkID, dx1, dy1, dz1); // index IS the morton code
-            int worldOriginX = dx1 * 32; // get world loc within 256x256x256 grid
-            int worldOriginY = dy1 * 32;
-            int worldOriginZ = dz1 * 32;
-
-            for (const auto& voxel : voxels) {
-                auto [localX, localY, localZ, color] = voxel;
-                int worldX = worldOriginX + localX;
-                int worldY = worldOriginY + localY;
-                int worldZ = worldOriginZ + localZ;
-                voxelMap[chunkID][std::make_tuple(worldX, worldY, worldZ)] = color;
-            }
-        } catch (std::exception& e) {
-            std::cout << "Error: " << e.what() << std::endl;    
-            // Just continue to next snapshot
-        }
-        snapshotCount++;
-    }
-    
-    // Collect visible voxels
-    std::vector<std::tuple<int, int, int, uint8_t>> visible;
-    int foo=0;
-    for (const auto& [_, chunk] : voxelMap) {
-        for (const auto& [pos, color] : chunk) {
-            foo++;
-            if (color != 0) {
-                auto [x, y, z] = pos;
-                visible.emplace_back(x, y, z, color);
-            }
-        }
-    }
-    
-    // Sort by coordinates
-    //std::sort(visible.begin(), visible.end());
-    
     // Create Bella scene nodes for each voxel
     int i = 0;
-    for (const auto& [x, y, z, color] : visible) {
-        // Create a unique name for this voxel's transform node
-        dl::String voxXformName = dl::String("voxXform") + dl::String(i);
-        //std::cout << voxXformName << std::endl;
-        // Create a transform node in the Bella scene
-        auto xform = sceneWrite.createNode("xform", voxXformName, voxXformName);
-        // Set this transform's parent to the world root
-        xform.parentTo(sceneWrite.world());
-        // Parent the voxel geometry to this transform
-        voxel.parentTo(xform);
-        // Set the transform matrix to position the voxel at (x,y,z)
-        // This is a 4x4 transformation matrix - standard in 3D graphics
-        xform["steps"][0]["xform"] = dl::Mat4 { 1, 0, 0, 0,
-                                0, 1, 0, 0,
-                                0, 0, 1, 0,
-                                static_cast<double>(x),
-                                static_cast<double>(y),
-                                static_cast<double>(z), 1};
-        // Store the color index for this voxel
-        voxelPalette.push_back(color-1);
+    dl::String modelName = dl::String(vmaxModel.vmaxbFileName.c_str());
+    auto modelXform = belScene.createNode("xform", modelName, modelName);
+    modelXform.parentTo(belScene.world());
+
+    for (const auto& [material, colorID] : vmaxModel.getUsedMaterialsAndColors()) {
+        for (int color : colorID) {
+            auto belInstancer  = belScene.createNode("instancer",
+                              dl::String("instMat") + dl::String(material) + dl::String("Color") + dl::String(color));
+            auto xformsArray = dl::ds::Vector<dl::Mat4f>();
+            belInstancer.parentTo(modelXform);
+
+
+            auto belMaterial  = belScene.createNode("quickMaterial",
+                              dl::String("vmaxMat") + dl::String(material) + dl::String("Color") + dl::String(color));
+
+            std::cout << "vmaxMaterial: " << vmaxMaterial[material].materialName << std::endl;
+            std::cout << "metalness: " << vmaxMaterial[material].metalness << std::endl;
+            std::cout << "roughness: " << vmaxMaterial[material].roughness << std::endl;
+            std::cout << "transmission: " << vmaxMaterial[material].transmission << std::endl;
+            std::cout << "emission: " << vmaxMaterial[material].emission << std::endl;
+
+            if(material==7) {
+                belMaterial["type"] = "liquid";
+                belMaterial["roughness"] = vmaxMaterial[material].roughness * 100.0f;
+            } else if(material==6) {
+                belMaterial["type"] = "glass";
+                belMaterial["roughness"] = vmaxMaterial[material].roughness * 100.0f;
+                belMaterial["glassDepth"] = 200.0f;
+            } else if(vmaxMaterial[material].metalness > 0.1f) {
+                belMaterial["type"] = "metal";
+                belMaterial["roughness"] = vmaxMaterial[material].roughness * 100.0f;
+            } else if(vmaxMaterial[material].transmission > 0.0f) {
+                belMaterial["type"] = "dielectric";
+                belMaterial["transmission"] = vmaxMaterial[material].transmission;
+            } else if(vmaxMaterial[material].emission > 0.0f) {
+                belMaterial["type"] = "emitter";
+                belMaterial["emitterUnit"] = "radiance";
+                belMaterial["energy"] = vmaxMaterial[material].emission*1.0f;
+            } else {
+                belMaterial["type"] = "plastic";
+                belMaterial["roughness"] = vmaxMaterial[material].roughness * 100.0f;
+            }
+            belInstancer["material"] = belMaterial;
+            std::cout << "material: " << material << std::endl;
+            // Convert 0-255 to 0-1
+            double bellaR = static_cast<double>(vmaxPalette[color-1].r)/255.0;
+            double bellaG = static_cast<double>(vmaxPalette[color-1].g)/255.0;
+            double bellaB = static_cast<double>(vmaxPalette[color-1].b)/255.0;
+            double bellaA = static_cast<double>(vmaxPalette[color-1].a)/255.0;
+            /*
+            belMaterial["color"] = dl::Rgba{ // convert sRGB to linear
+                bellaR, 
+                bellaG, 
+                bellaB, 
+                bellaA // alpha is already linear
+            }; // colors ready to use in Bella
+            */
+            belMaterial["color"] = dl::Rgba{ // convert sRGB to linear
+                srgbToLinear(bellaR), 
+                srgbToLinear(bellaG), 
+                srgbToLinear(bellaB), 
+                bellaA // alpha is already linear
+            }; // colors ready to use in Bella
+
+            // Get all voxels for this material/color combination
+            const std::vector<VmaxVoxel>& voxelsOfType = vmaxModel.getVoxels(material, color);
+            int showchunk =0;
+
+            // Right now we group voxels by MatCol ie Mat0Col2
+            // But voxels are stored in chunks with many colors 
+            // Since we aren't grouping voxels in chunks, we need to traverse the voxels 
+            // and offset each voxel by the morton decode of chunk index
+            for (const auto& eachvoxel : voxelsOfType) {
+                // Get chunk coordinates and world origin
+                uint32_t _tempx, _tempy, _tempz;
+                decodeMorton3DOptimized(eachvoxel.chunkID, _tempx, _tempy, _tempz); // index IS the morton code
+                int worldOffsetX = _tempx * 24; // get world loc within 256x256x256 grid
+                int worldOffsetY = _tempy * 24; // Don't know why we need to multiply by 24
+                int worldOffsetZ = _tempz * 24; // use to be 32
+                xformsArray.push_back( dl::Mat4f{  1, 0, 0, 0, 
+                                                    0, 1, 0, 0, 
+                                                    0, 0, 1, 0, 
+                                                    static_cast<float>(eachvoxel.x + worldOffsetX),
+                                                    static_cast<float>(eachvoxel.y + worldOffsetY),
+                                                    static_cast<float>(eachvoxel.z + worldOffsetZ), 1 });
+            }
+            belInstancer["steps"][0]["instances"] = xformsArray;
+            oomerSmoothCube.parentTo(belInstancer);
+            if(vmaxMaterial[material].emission > 0.0f) {
+               belVoxelForm.parentTo(belInstancer);
+            }
+        }
         i++;
     }
-        // Assign materials to voxels based on their color indices
-    for (int i = 0; i < voxelPalette.size(); i++) 
-    {
-        // Find the transform node for this voxel
-        auto xformNode = sceneWrite.findNode(dl::String("voxXform") + dl::String(i));
-        // Find the material node for this voxel's color
-        auto matNode = sceneWrite.findNode(dl::String("voxMat") + dl::String(voxelPalette[i]));
-        // Assign the material to the voxel
-        xformNode["material"] = matNode;
-    }
-
+    return 0;
 }