diff --git a/LICENSE b/LICENSE index ded78bb..a505139 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2025 oomer +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 diff --git a/README.md b/README.md index e105cef..8fa85db 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,92 @@ # vmaxtui -Command line VoxelMax to Bella converter and render queue + +Command line rendererer [VoxelMax](https://voxelmax.com) .vmax to Diffuse Logic Bella Render + +![example](resources/example.jpg) + + + +# Build + +Download SDK for your OS and move **bella_engine_sdk** into your **workdir**. On Windows rename unzipped folder by removing version ie bella_engine_sdk-24.6.0 -> bella_engine_sdk +https://bellarender.com/builds/ + + +``` +workdir/ +├── bella_engine_sdk/ +├── libplist/ +├── lzfse/ +├── efsw/ +└── vox2bella/ +``` + +# MacOS + +``` +mkdir workdir +git clone https://github.com/lzfse/lzfse +mkdir -p lzfse/build +cd lzfse/build +/Applications/CMake.app/Contents/bin/cmake -DCMAKE_OSX_ARCHITECTURES="x86_64;arm64" .. +make -j4 +cd ../.. +mkdir homebrew +curl -L https://github.com/Homebrew/brew/tarball/master | tar xz --strip-components 1 -C homebrew +eval "$(homebrew/bin/brew shellenv)" +brew update --force --quiet +brew install libtool autoconf automake +git clone https://github.com/libimobiledevice/libplist +cd libplist +./autogen.sh --prefix=$PWD/install --without-cython +make -j4 +install_name_tool -id @rpath/libplist-2.0.4.dylib src/.libs/libplist-2.0.4.dylib +cd .. +git clone https://github.com/SpartanJ/efsw.git +mkdir -p efsw/build +cd efsw/build +/Applications/CMake.app/Contents/bin/cmake .. +make -j4 +cd ../.. +git clone https://github.com/oomer/vmax2bella.git +cd vmax2bella +make +``` + +# Linux [NOT READY] + +``` +mkdir workdir +git clone https://github.com/lzfse/lzfse +mkdir lzfse/build +cd lzfse/build +cmake .. +make -j4 +cd ../.. +git clone https://github.com/libimobiledevice/libplist +cd libplist +./autogen.sh --prefix=$PWD/install --without-cython +make -j4 +cd .. +git clone https://github.com/SpartanJ/efsw.git +mkdir -p efsw/build +cd efsw/build +cmake .. +make -j4 +git clone https://github.com/oomer/vmax2bella.git +cd vmax2bella +make +``` + +# Windows [NOT READY] +- Install Visual Studio Community 2022 +- Add Desktop development with C++ workload +- Launch x64 Native tools Command Prompt for VS2022 +``` +mkdir workdir +git clone https://github.com/lzfse/lzfse + +git clone https://github.com/oomer/vmax2bella.git +cd vmax2bella +msbuild vox2bella.vcxproj /p:Configuration=release /p:Platform=x64 /p:PlatformToolset=v143 +``` diff --git a/makefile b/makefile new file mode 100644 index 0000000..4a3ea91 --- /dev/null +++ b/makefile @@ -0,0 +1,133 @@ +# Project configuration +BELLA_SDK_NAME = bella_engine_sdk +EXECUTABLE_NAME = vmaxtui +PLATFORM = $(shell uname) +BUILD_TYPE ?= release# Default to release build if not specified + +# Common paths +BELLA_SDK_PATH = ../bella_engine_sdk +LZFSE_PATH = ../lzfse +LIBPLIST_PATH = ../libplist +EFSW_PATH = ../efsw +OBJ_DIR = obj/$(PLATFORM)/$(BUILD_TYPE) +BIN_DIR = bin/$(PLATFORM)/$(BUILD_TYPE) +OUTPUT_FILE = $(BIN_DIR)/$(EXECUTABLE_NAME) + +# Platform-specific configuration +ifeq ($(PLATFORM), Darwin) + # macOS configuration + SDK_LIB_EXT = dylib + LZFSE_LIB_NAME = liblzfse.$(SDK_LIB_EXT) + PLIST_LIB_NAME = libplist-2.0.4.$(SDK_LIB_EXT) + EFSW_LIB_NAME = libefsw.$(SDK_LIB_EXT) + MACOS_SDK_PATH = /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk + + # Compiler settings + CC = clang + CXX = clang++ + + # Architecture flags + ARCH_FLAGS = -arch arm64 -mmacosx-version-min=11.0 -isysroot $(MACOS_SDK_PATH) + + # Linking flags - Use multiple rpath entries to look in executable directory + LINKER_FLAGS = $(ARCH_FLAGS) -framework Cocoa -framework IOKit -fvisibility=hidden -O5 \ + -rpath @executable_path \ + -rpath . + + # Platform-specific libraries + PLIST_LIB = -lplist-2.0 + +else + # Linux configuration + SDK_LIB_EXT = so + LZFSE_LIB_NAME = liblzfse.$(SDK_LIB_EXT) + PLIST_LIB_NAME = libplist.$(SDK_LIB_EXT) + EFSW_LIB_NAME = libefsw.$(SDK_LIB_EXT) + + # Compiler settings + CC = gcc + CXX = g++ + + # Architecture flags + ARCH_FLAGS = -m64 -D_FILE_OFFSET_BITS=64 + + # Linking flags + LINKER_FLAGS = $(ARCH_FLAGS) -fvisibility=hidden -O3 -Wl,-rpath,'$$ORIGIN' -Wl,-rpath,'$$ORIGIN/lib' + + # Platform-specific libraries + PLIST_LIB = -lplist +endif + +# Common include and library paths +INCLUDE_PATHS = -I$(BELLA_SDK_PATH)/src -I$(LZFSE_PATH)/src -I$(LIBPLIST_PATH)/include -I$(EFSW_PATH)/include -I$(EFSW_PATH)/src +SDK_LIB_PATH = $(BELLA_SDK_PATH)/lib +SDK_LIB_FILE = lib$(BELLA_SDK_NAME).$(SDK_LIB_EXT) +LZFSE_BUILD_DIR = $(LZFSE_PATH)/build +PLIST_LIB_DIR = $(LIBPLIST_PATH)/src/.libs +EFSW_LIB_DIR = $(EFSW_PATH)/build + +# Library flags +LIB_PATHS = -L$(SDK_LIB_PATH) -L$(LZFSE_BUILD_DIR) -L$(PLIST_LIB_DIR) -L$(EFSW_LIB_DIR) +LIBRARIES = -l$(BELLA_SDK_NAME) -lm -ldl -llzfse $(PLIST_LIB) -lefsw + +# Build type specific flags +ifeq ($(BUILD_TYPE), debug) + CPP_DEFINES = -D_DEBUG -DDL_USE_SHARED + COMMON_FLAGS = $(ARCH_FLAGS) -fvisibility=hidden -g -O0 $(INCLUDE_PATHS) +else + CPP_DEFINES = -DNDEBUG=1 -DDL_USE_SHARED + COMMON_FLAGS = $(ARCH_FLAGS) -fvisibility=hidden -O3 $(INCLUDE_PATHS) +endif + +# Language-specific flags +C_FLAGS = $(COMMON_FLAGS) -std=c17 +CXX_FLAGS = $(COMMON_FLAGS) -std=c++17 -Wno-deprecated-declarations + +# Objects +OBJECTS = $(EXECUTABLE_NAME).o +OBJECT_FILES = $(patsubst %,$(OBJ_DIR)/%,$(OBJECTS)) + +# Build rules +$(OBJ_DIR)/$(EXECUTABLE_NAME).o: $(EXECUTABLE_NAME).cpp + @mkdir -p $(@D) + $(CXX) -c -o $@ $< $(CXX_FLAGS) $(CPP_DEFINES) + +$(OUTPUT_FILE): $(OBJECT_FILES) + @mkdir -p $(@D) + $(CXX) -o $@ $(OBJECT_FILES) $(LINKER_FLAGS) $(LIB_PATHS) $(LIBRARIES) + @echo "Copying libraries to $(BIN_DIR)..." + @cp $(SDK_LIB_PATH)/$(SDK_LIB_FILE) $(BIN_DIR)/$(SDK_LIB_FILE) + @cp $(LZFSE_BUILD_DIR)/$(LZFSE_LIB_NAME) $(BIN_DIR)/$(LZFSE_LIB_NAME) + @cp $(PLIST_LIB_DIR)/$(PLIST_LIB_NAME) $(BIN_DIR)/ + @if [ -f $(EFSW_LIB_DIR)/$(EFSW_LIB_NAME) ]; then cp $(EFSW_LIB_DIR)/$(EFSW_LIB_NAME) $(BIN_DIR)/; fi + @echo "Build complete: $(OUTPUT_FILE)" + +# Add default target +all: $(OUTPUT_FILE) + +.PHONY: clean cleanall all +clean: + rm -f $(OBJ_DIR)/$(EXECUTABLE_NAME).o + rm -f $(OUTPUT_FILE) + rm -f $(BIN_DIR)/$(SDK_LIB_FILE) + rm -f $(BIN_DIR)/*.dylib + rmdir $(OBJ_DIR) 2>/dev/null || true + rmdir $(BIN_DIR) 2>/dev/null || true + +cleanall: + rm -f obj/*/release/*.o + rm -f obj/*/debug/*.o + rm -f bin/*/release/$(EXECUTABLE_NAME) + rm -f bin/*/debug/$(EXECUTABLE_NAME) + rm -f bin/*/release/$(SDK_LIB_FILE) + rm -f bin/*/debug/$(SDK_LIB_FILE) + rm -f bin/*/release/*.dylib + rm -f bin/*/debug/*.dylib + rmdir obj/*/release 2>/dev/null || true + rmdir obj/*/debug 2>/dev/null || true + rmdir bin/*/release 2>/dev/null || true + rmdir bin/*/debug 2>/dev/null || true + rmdir obj/* 2>/dev/null || true + rmdir bin/* 2>/dev/null || true + rmdir obj 2>/dev/null || true + rmdir bin 2>/dev/null || true diff --git a/oomer_filequeue.h b/oomer_filequeue.h new file mode 100644 index 0000000..1d5ed9d --- /dev/null +++ b/oomer_filequeue.h @@ -0,0 +1,236 @@ +#pragma once +#include // For std::string +#include + +#include // For file watching +#include // For file watching +#include // For file watching + +//UpdateListener* global_ul = nullptr; // Global pointer to UpdateListener +bool STOP = false; + +class FileQueue; // Forward declaration of FileQueue class + +bool endsWith(const std::string& str, const std::string& suffix); + + +efsw::WatchID handleWatchID( efsw::WatchID watchid ) { + switch ( watchid ) { + case efsw::Errors::FileNotFound: + case efsw::Errors::FileRepeated: + case efsw::Errors::FileOutOfScope: + case efsw::Errors::FileRemote: + case efsw::Errors::WatcherFailed: + case efsw::Errors::Unspecified: { + std::cout << efsw::Errors::Log::getLastErrorLog().c_str() << std::endl; + break; + } + default: { + std::cout << "Added WatchID: " << watchid << std::endl; + } + } + return watchid; +} + +/// A class that manages a queue of files added/modified or deleted fromthe filesystem +/// with both FIFO order and fast lookups +class FileQueue { + public: + // Default constructor + FileQueue() = default; + + // Move constructor + FileQueue(FileQueue&& other) noexcept { + std::lock_guard lock(other.mutex); + pathVector = std::move(other.pathVector); + pathMap = std::move(other.pathMap); + } + + // Move assignment operator + FileQueue& operator=(FileQueue&& other) noexcept { + if (this != &other) { + std::lock_guard lock1(mutex); + std::lock_guard lock2(other.mutex); + pathVector = std::move(other.pathVector); + pathMap = std::move(other.pathMap); + } + return *this; + } + + // Delete copy operations since mutexes can't be copied + FileQueue(const FileQueue&) = delete; + FileQueue& operator=(const FileQueue&) = delete; + + // Add a file to the queue if it's not already there + bool push(const std::string& path) { + std::lock_guard lock(mutex); + if (pathMap.find(path) == pathMap.end()) { + pathVector.push_back(path); + pathMap[path] = true; + return true; + } + return false; + } + + // Get the next file to process (FIFO order) + bool pop(std::string& outPath) { + std::lock_guard lock(mutex); + if (!pathVector.empty()) { + outPath = pathVector.front(); + pathVector.erase(pathVector.begin()); + pathMap.erase(outPath); + return true; + } + return false; + } + + // Get the next file to process (FIFO order) + bool probe(std::string& outPath) { + std::lock_guard lock(mutex); + if (!pathVector.empty()) { + outPath = pathVector.front(); + return true; + } + return false; + } + + // Remove a specific file by name + bool remove(const std::string& path) { + std::lock_guard lock(mutex); + if (pathMap.find(path) != pathMap.end()) { + // Remove from vector using erase-remove idiom + pathVector.erase( + std::remove(pathVector.begin(), pathVector.end(), path), + pathVector.end() + ); + // Remove from map + pathMap.erase(path); + return true; + } + return false; + } + + // Check if a file exists in the queue + bool contains(const std::string& path) const { + std::lock_guard lock(mutex); + return pathMap.find(path) != pathMap.end(); + } + + // Get the number of files in the queue + size_t size() const { + std::lock_guard lock(mutex); + return pathVector.size(); + } + + // Check if the queue is empty + bool empty() const { + std::lock_guard lock(mutex); + return pathVector.empty(); + } + + // Clear all files from the queue + void clear() { + std::lock_guard lock(mutex); + pathVector.clear(); + pathMap.clear(); + } + + private: + std::vector pathVector; // Maintains FIFO order + std::map pathMap; // Enables fast lookups + mutable std::mutex mutex; // Thread safety + }; + + +/// Processes a file action libefsw +class UpdateListener : public efsw::FileWatchListener { + public: + // Modified constructor to take references to all FileQueue instances and mutexes + UpdateListener(FileQueue& fileQueue, FileQueue& unfileQueue, FileQueue& processQueue, + std::mutex& fileQueueMutex, std::mutex& unfileQueueMutex, + std::mutex& processQueueMutex) + : fileQueue_(fileQueue), + unfileQueue_(unfileQueue), + processQueue_(processQueue), + fileQueueMutex_(fileQueueMutex), + unfileQueueMutex_(unfileQueueMutex), + processQueueMutex_(processQueueMutex), + should_stop_(false) {} + + void stop() { + should_stop_ = true; + } + + std::string getActionName( efsw::Action action ) { + switch ( action ) { + case efsw::Actions::Add: + return "Add"; + case efsw::Actions::Modified: + return "Modified"; + case efsw::Actions::Delete: + return "Delete"; + case efsw::Actions::Moved: + return "Moved"; + default: + return "Bad Action"; + } + } + + void handleFileAction( efsw::WatchID watchid, + const std::string& dir, + const std::string& filename, + efsw::Action action, + std::string oldFilename = "" ) override { + if (should_stop_) return; // Early exit if we're stopping + + std::string actionName = getActionName( action ); + if (actionName == "Delete") { // always push to unfile queue, cpp will handle the rest + std::string belPath = dir + filename; + if (endsWith(belPath, ".bsz")) { + std::cout << "\n==" << "DELETE: " << dir + filename << "\n==" << std::endl; + { + std::lock_guard lock(unfileQueueMutex_); + if (!unfileQueue_.contains(belPath)) { + unfileQueue_.push(belPath); + std::cout << "\n==" << "STOP PROCESSING: " << belPath << "\n==" << std::endl; + } + } + } + } + if (actionName == "Add" || actionName == "Modified") { + std::string belPath = dir + filename; + std::string parentPath = dir; + //std::cout << "parentPath: " << parentPath << std::endl; + if (should_stop_) return; // Check again before starting render + + if (endsWith(belPath, ".vmax") || endsWith(belPath, ".bsz") || endsWith(belPath, ".zip") && !endsWith(parentPath, "download/")) { + { + std::lock_guard lock(fileQueueMutex_); + if (!fileQueue_.contains(belPath)) { + fileQueue_.push(belPath); + #ifdef _DEBUG + std::cout << "\n==" << "QUEUED: " << belPath << "\n==" << std::endl; + #endif + } + } + } + } + } + private: + // Store references to all queues and mutexes + FileQueue& fileQueue_; + FileQueue& unfileQueue_; + FileQueue& processQueue_; + std::mutex& fileQueueMutex_; + std::mutex& unfileQueueMutex_; + std::mutex& processQueueMutex_; + std::atomic should_stop_; // ctrl-c was not working, so we use this to stop the thread + }; + +// Utility function to check if a string ends with a specific suffix +inline bool endsWith(const std::string& str, const std::string& suffix) { + if (str.length() < suffix.length()) { + return false; + } + return str.compare(str.length() - suffix.length(), suffix.length(), suffix) == 0; +} \ No newline at end of file diff --git a/oomer_misc.h b/oomer_misc.h new file mode 100644 index 0000000..a15398e --- /dev/null +++ b/oomer_misc.h @@ -0,0 +1,1588 @@ +#pragma once +#include // For std::string +#include +#include // For std::ofstream +#include // For std::filesystem +//#include "DayEnvironmentHDRI019_1K-TONEMAPPED.h" // embedded image dome light +#include // 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 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 lzfseArray(lzfseFileSize); + lzfseFile.read(reinterpret_cast(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 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 lzfseBuffer(lzfseFileSize); + lzfseFile.read(reinterpret_cast(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(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 initializeMyLicense() { + // R"(...)" is a C++ raw string literal - allows multi-line strings with preserved formatting + return R"( +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 initializeThirdPartyLicences() { + 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. + +=== + +DayEnvironmentHDRI019_1K-TONEMAPPED.jpg from ambientCG.com, +licensed under the Creative Commons CC0 1.0 Universal License. + +=== +https://github.com/libimobiledevice/libplist + +This software uses libraries from the libplist project under the LGPL version 2.1. + +)"; +} + +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..248ada3 --- /dev/null +++ b/oomer_voxel_vmax.h @@ -0,0 +1,860 @@ +#pragma once + +// This is a set of common oomer utilities for Vmax models +// Will avoid using bella_sdk + +// Standard C++ library includes - these provide essential functionality +#include // For key-value pair data structures (maps) +#include // For set data structure +#include // For dynamic arrays (vectors) +#include // For std::string +#include // For fixed-size integer types (uint8_t, uint32_t, etc.) +#include // For file operations (reading/writing files) +#include // For input/output operations (cout, cin, etc.) +#include // For file system operations (directory handling, path manipulation) + +#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 + +// Structure to represent a 4x4 matrix for 3D transformations +// The matrix is stored as a 2D array where m[i][j] represents row i, column j +struct VmaxMatrix4x4 { + double m[4][4]; + // Constructor: Creates an identity matrix (1's on diagonal, 0's elsewhere) + VmaxMatrix4x4() { + for(int i = 0; i < 4; i++) { + for(int j = 0; j < 4; j++) { + m[i][j] = (i == j) ? 1.0 : 0.0; // 1.0 on diagonal, 0.0 elsewhere + } + } + } + + // Matrix multiplication operator to combine transformations + // Returns: A new matrix that represents the combined transformation + VmaxMatrix4x4 operator*(const VmaxMatrix4x4& other) const { + VmaxMatrix4x4 result; + for(int i = 0; i < 4; i++) { + for(int j = 0; j < 4; j++) { + result.m[i][j] = 0.0; + for(int k = 0; k < 4; k++) { + result.m[i][j] += m[i][k] * other.m[k][j]; + } + } + } + return result; + } + + // Helper function to create a translation matrix + static VmaxMatrix4x4 createTranslation(double x, double y, double z) { + VmaxMatrix4x4 result; + result.m[3][0] = x; // Translation in X (bottom row) + result.m[3][1] = y; // Translation in Y (bottom row) + result.m[3][2] = z; // Translation in Z (bottom row) + return result; + } + + // Helper function to create a scale matrix + static VmaxMatrix4x4 createScale(double x, double y, double z) { + VmaxMatrix4x4 result; + result.m[0][0] = x; // Scale in X + result.m[1][1] = y; // Scale in Y + result.m[2][2] = z; // Scale in Z + return result; + } +}; + +// Converts axis-angle rotation to a 4x4 rotation matrix +// Parameters: +// ax, ay, az: The axis vector to rotate around (doesn't need to be normalized) +// angle: The angle to rotate by (in radians) +// Returns: A 4x4 rotation matrix that can be used to transform vectors +VmaxMatrix4x4 axisAngleToMatrix4x4(double ax, double ay, double az, double angle) { + // Step 1: Normalize the axis vector to make it a unit vector + // This is required for the rotation formula to work correctly + double length = sqrt(ax*ax + ay*ay + az*az); + if (length != 0) { + ax /= length; + ay /= length; + az /= length; + } + + // Step 2: Calculate trigonometric values needed for the rotation + double s = sin(angle); // sine of angle + double c = cos(angle); // cosine of angle + double t = 1.0 - c; // 1 - cos(angle), used in formula + + // Step 3: Create rotation matrix using Rodrigues' rotation formula + // This formula converts an axis-angle rotation into a 3x3 matrix + // We'll embed it in the upper-left corner of our 4x4 matrix + VmaxMatrix4x4 result; + + // First row of rotation matrix (upper-left 3x3 portion) + result.m[0][0] = t*ax*ax + c; // First column + result.m[0][1] = t*ax*ay + s*az; // Second column (changed sign) + result.m[0][2] = t*ax*az - s*ay; // Third column (changed sign) + + // Second row of rotation matrix + result.m[1][0] = t*ax*ay - s*az; // First column (changed sign) + result.m[1][1] = t*ay*ay + c; // Second column + result.m[1][2] = t*ay*az + s*ax; // Third column (changed sign) + + // Third row of rotation matrix + result.m[2][0] = t*ax*az + s*ay; // First column (changed sign) + result.m[2][1] = t*ay*az - s*ax; // Second column (changed sign) + result.m[2][2] = t*az*az + c; // Third column + + // Fourth row and column remain unchanged (0,0,0,1) + // This is already set by the constructor + return result; +} + +// Combine a rotation, translation, and scale into a single 4x4 matrix +// Parameters: +// rotx, roty, rotz: The axis vector to rotate around (doesn't need to be normalized) +// rota: The angle to rotate by (in radians) +// posx, posy, posz: The position to translate to +// scalex, scaley, scalez: The scale to apply to the object +// Returns: A 4x4 matrix that represents the combined transformation +VmaxMatrix4x4 combineVmaxTransforms(double rotx, double roty, double rotz, double rota, double posx, double posy, double posz, double scalex, double scaley, double scalez) { + VmaxMatrix4x4 rotMat4 = axisAngleToMatrix4x4(rotx, + roty, + rotz, + rota); + VmaxMatrix4x4 transMat4 = VmaxMatrix4x4(); + transMat4 = transMat4.createTranslation(posx, + posy, + posz); + VmaxMatrix4x4 scaleMat4 = VmaxMatrix4x4(); + scaleMat4 = scaleMat4.createScale(scalex, + scaley, + scalez); + VmaxMatrix4x4 resultMat4 = scaleMat4 * rotMat4 * transMat4; + return resultMat4; +} + +struct VmaxRGBA { + uint8_t r, g, b, a; +}; + +// Read a 256x1 PNG file and return a vector of VmaxRGBA colors +std::vector 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 palette; + // Read each pixel (each pixel is 4 bytes - RGBA) + for (int i = 0; i < width; i++) { + VmaxRGBA 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 voxels[8][256]; + + // Each model has local 0-7 materials + std::array materials; + // Each model has local colors + std::array 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 newMaterials) { + materials = newMaterials; + } + + // Add a colors to this model + void addColors(const std::array newColors) { + colors = newColors; + } + + // Get all voxels of a specific material and color + const std::vector& getVoxels(int material, int color) const { + if (material >= 0 && material < 8 && color > 0 && color < 256) { + return voxels[material][color]; + } + static std::vector 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> getUsedMaterialsAndColors() const { + std::map> 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 getVmaxMaterials(plist_t pnodPalettePlist) { + // Directly access the materials array + std::array 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(vmaxEnableShadows), + false, // dielectric + false, // volumetric + }; + } + } + } else { + std::cout << "No materials array found or invalid type" << std::endl; + } + #ifdef _DEBUG + 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 decodeVoxels(const std::vector& dsData, int mortonOffset, uint16_t chunkID) { + std::vector voxels; + uint8_t material; + uint8_t color; + for (int i = 0; i < dsData.size() - 1; i += 2) { + material = dsData[i]; // also known as a layer color + color = dsData[i + 1]; + uint32_t _tempx, _tempy, _tempz; + decodeMorton3DOptimized(i/2 + mortonOffset, + _tempx, + _tempy, + _tempz); // index IS the morton code + if (color != 0) { + VmaxVoxel voxel = { + static_cast(_tempx), + static_cast(_tempy), + static_cast(_tempz), + material, + color, + chunkID, // todo is wasteful to pass chunkID? + static_cast(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& 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(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 getVmaxSnapshot(plist_t& pnod_each_snapshot) { +std::vector vmaxVoxelInfo(plist_t& plist_datastream, uint64_t chunkID, uint64_t minMorton) { + std::vector 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(data, data + length) ; + std::vector allModelVoxels = decodeVoxels(std::vector(data, data + length), minMorton, chunkID); + + + 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 rawBytes(rawFileSize); + std::vector 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(rawBytes.data()), rawFileSize); + rawBytesFile.close(); + // Start with output buffer 4x input size (compression ratio is usually < 4) + size_t outAllocatedSize = rawFileSize * 8; + // vector automatically manages memory allocation/deallocation + //std::vector 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 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(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(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(outBuffer.data()), // Cast uint8_t* to char* + static_cast(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, not sure what this is + + // Transform information + std::vector position; // t_p + std::vector rotation; // t_r + std::vector scale; // t_s + + // Extent information + std::vector extentCenter; // e_c + std::vector extentMin; // e_mi + std::vector extentMax; // e_ma +}; + +// Structure to hold group information from VoxelMax's scene.json +struct JsonGroupInfo { + std::string id; + std::string name; + std::vector position; + std::vector rotation; + std::vector scale; + std::vector extentCenter; + std::vector extentMin; + std::vector extentMax; + bool selected = false; + std::string parentId; +}; + +// Class to parse VoxelMax's scene.json +class JsonVmaxSceneParser { +private: + std::map models; // a vmax model can also be called a content + std::map 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>(); + + if (group.contains("t_r") && group["t_r"].is_array()) + groupInfo.rotation = group["t_r"].get>(); + + if (group.contains("t_s") && group["t_s"].is_array()) + groupInfo.scale = group["t_s"].get>(); + + // Extract extent data + if (group.contains("e_c") && group["e_c"].is_array()) + groupInfo.extentCenter = group["e_c"].get>(); + + if (group.contains("e_mi") && group["e_mi"].is_array()) + groupInfo.extentMin = group["e_mi"].get>(); + + if (group.contains("e_ma") && group["e_ma"].is_array()) + groupInfo.extentMax = group["e_ma"].get>(); + + // Check if selected + if (group.contains("s")) groupInfo.selected = group["s"].get(); + + if (group.contains("pid")) groupInfo.parentId = group["pid"]; + // Store the group + groups[groupInfo.id] = groupInfo; + } + } + + // Parse objects (models) , objects are instances of models + // Maybe rename this objects, will leave for now + 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"];// This is the canonical model + 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>(); + + if (obj.contains("t_r") && obj["t_r"].is_array()) + modelInfo.rotation = obj["t_r"].get>(); + + if (obj.contains("t_s") && obj["t_s"].is_array()) + modelInfo.scale = obj["t_s"].get>(); + + // Extract extent data + if (obj.contains("e_c") && obj["e_c"].is_array()) + modelInfo.extentCenter = obj["e_c"].get>(); + + if (obj.contains("e_mi") && obj["e_mi"].is_array()) + modelInfo.extentMin = obj["e_mi"].get>(); + + if (obj.contains("e_ma") && obj["e_ma"].is_array()) + modelInfo.extentMax = obj["e_ma"].get>(); + + // 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& getModels() const { + return models; + } + + // Get the parsed groups + const std::map& 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> getModelContentVMaxbMap() const { + std::map> 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 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/example.jpg b/resources/example.jpg new file mode 100644 index 0000000..de15e9d Binary files /dev/null and b/resources/example.jpg differ diff --git a/resources/smoothcube.h b/resources/smoothcube.h new file mode 100644 index 0000000..724ad83 --- /dev/null +++ b/resources/smoothcube.h @@ -0,0 +1,1966 @@ + + belMeshVoxel["name"] = "oomerMeshVoxel"; + belMeshVoxel["channels"][0] = "st"; + belMeshVoxel["optimized"] = false; + + dl::ds::Vector polygons; + polygons.push_back(dl::Vec4u{0, 1, 2, 3}); + polygons.push_back(dl::Vec4u{4, 5, 6, 7}); + polygons.push_back(dl::Vec4u{8, 9, 10, 11}); + polygons.push_back(dl::Vec4u{12, 13, 14, 15}); + polygons.push_back(dl::Vec4u{16, 17, 18, 19}); + polygons.push_back(dl::Vec4u{20, 21, 22, 23}); + polygons.push_back(dl::Vec4u{24, 25, 26, 27}); + polygons.push_back(dl::Vec4u{28, 29, 30, 31}); + polygons.push_back(dl::Vec4u{32, 33, 34, 35}); + polygons.push_back(dl::Vec4u{36, 37, 38, 39}); + polygons.push_back(dl::Vec4u{40, 41, 42, 43}); + polygons.push_back(dl::Vec4u{44, 45, 46, 47}); + polygons.push_back(dl::Vec4u{48, 49, 50, 51}); + polygons.push_back(dl::Vec4u{52, 53, 54, 55}); + polygons.push_back(dl::Vec4u{56, 57, 58, 59}); + polygons.push_back(dl::Vec4u{60, 61, 62, 63}); + polygons.push_back(dl::Vec4u{64, 65, 66, 67}); + polygons.push_back(dl::Vec4u{68, 69, 70, 71}); + polygons.push_back(dl::Vec4u{72, 73, 74, 75}); + polygons.push_back(dl::Vec4u{76, 77, 78, 79}); + polygons.push_back(dl::Vec4u{80, 81, 82, 83}); + polygons.push_back(dl::Vec4u{84, 85, 86, 87}); + polygons.push_back(dl::Vec4u{88, 89, 90, 91}); + polygons.push_back(dl::Vec4u{92, 93, 94, 95}); + polygons.push_back(dl::Vec4u{96, 97, 98, 99}); + polygons.push_back(dl::Vec4u{100, 101, 102, 103}); + polygons.push_back(dl::Vec4u{104, 105, 106, 107}); + polygons.push_back(dl::Vec4u{108, 109, 110, 111}); + polygons.push_back(dl::Vec4u{112, 113, 114, 115}); + polygons.push_back(dl::Vec4u{116, 117, 118, 119}); + polygons.push_back(dl::Vec4u{120, 121, 122, 123}); + polygons.push_back(dl::Vec4u{124, 125, 126, 127}); + polygons.push_back(dl::Vec4u{128, 129, 130, 131}); + polygons.push_back(dl::Vec4u{132, 133, 134, 135}); + polygons.push_back(dl::Vec4u{136, 137, 138, 139}); + polygons.push_back(dl::Vec4u{140, 141, 142, 143}); + polygons.push_back(dl::Vec4u{144, 145, 146, 147}); + polygons.push_back(dl::Vec4u{148, 149, 150, 151}); + polygons.push_back(dl::Vec4u{152, 153, 154, 155}); + polygons.push_back(dl::Vec4u{156, 157, 158, 159}); + polygons.push_back(dl::Vec4u{160, 161, 162, 163}); + polygons.push_back(dl::Vec4u{164, 165, 166, 167}); + polygons.push_back(dl::Vec4u{168, 169, 170, 171}); + polygons.push_back(dl::Vec4u{172, 173, 174, 175}); + polygons.push_back(dl::Vec4u{176, 177, 178, 179}); + polygons.push_back(dl::Vec4u{180, 181, 182, 183}); + polygons.push_back(dl::Vec4u{184, 185, 186, 187}); + polygons.push_back(dl::Vec4u{188, 189, 190, 191}); + polygons.push_back(dl::Vec4u{192, 193, 194, 195}); + polygons.push_back(dl::Vec4u{196, 197, 198, 199}); + polygons.push_back(dl::Vec4u{200, 201, 202, 203}); + polygons.push_back(dl::Vec4u{204, 205, 206, 207}); + polygons.push_back(dl::Vec4u{208, 209, 210, 211}); + polygons.push_back(dl::Vec4u{212, 213, 214, 215}); + polygons.push_back(dl::Vec4u{216, 217, 218, 219}); + polygons.push_back(dl::Vec4u{220, 221, 222, 223}); + polygons.push_back(dl::Vec4u{224, 225, 226, 227}); + polygons.push_back(dl::Vec4u{228, 229, 230, 231}); + polygons.push_back(dl::Vec4u{232, 233, 234, 235}); + polygons.push_back(dl::Vec4u{236, 237, 238, 239}); + polygons.push_back(dl::Vec4u{240, 241, 242, 243}); + polygons.push_back(dl::Vec4u{244, 245, 246, 247}); + polygons.push_back(dl::Vec4u{248, 249, 250, 251}); + polygons.push_back(dl::Vec4u{252, 253, 254, 255}); + polygons.push_back(dl::Vec4u{256, 257, 258, 259}); + polygons.push_back(dl::Vec4u{260, 261, 262, 263}); + polygons.push_back(dl::Vec4u{264, 265, 266, 267}); + polygons.push_back(dl::Vec4u{268, 269, 270, 271}); + polygons.push_back(dl::Vec4u{272, 273, 274, 275}); + polygons.push_back(dl::Vec4u{276, 277, 278, 279}); + polygons.push_back(dl::Vec4u{280, 281, 282, 283}); + polygons.push_back(dl::Vec4u{284, 285, 286, 287}); + polygons.push_back(dl::Vec4u{288, 289, 290, 291}); + polygons.push_back(dl::Vec4u{292, 293, 294, 295}); + polygons.push_back(dl::Vec4u{296, 297, 298, 299}); + polygons.push_back(dl::Vec4u{300, 301, 302, 303}); + polygons.push_back(dl::Vec4u{304, 305, 306, 307}); + polygons.push_back(dl::Vec4u{308, 309, 310, 311}); + polygons.push_back(dl::Vec4u{312, 313, 314, 315}); + polygons.push_back(dl::Vec4u{316, 317, 318, 319}); + polygons.push_back(dl::Vec4u{320, 321, 322, 323}); + polygons.push_back(dl::Vec4u{324, 325, 326, 327}); + polygons.push_back(dl::Vec4u{328, 329, 330, 331}); + polygons.push_back(dl::Vec4u{332, 333, 334, 335}); + polygons.push_back(dl::Vec4u{336, 337, 338, 339}); + polygons.push_back(dl::Vec4u{340, 341, 342, 343}); + polygons.push_back(dl::Vec4u{344, 345, 346, 347}); + polygons.push_back(dl::Vec4u{348, 349, 350, 351}); + polygons.push_back(dl::Vec4u{352, 353, 354, 355}); + polygons.push_back(dl::Vec4u{356, 357, 358, 359}); + polygons.push_back(dl::Vec4u{360, 361, 362, 363}); + polygons.push_back(dl::Vec4u{364, 365, 366, 367}); + polygons.push_back(dl::Vec4u{368, 369, 370, 371}); + polygons.push_back(dl::Vec4u{372, 373, 374, 375}); + polygons.push_back(dl::Vec4u{376, 377, 378, 379}); + polygons.push_back(dl::Vec4u{380, 381, 382, 383}); + polygons.push_back(dl::Vec4u{384, 385, 386, 387}); + polygons.push_back(dl::Vec4u{388, 389, 390, 391}); + polygons.push_back(dl::Vec4u{392, 393, 394, 395}); + polygons.push_back(dl::Vec4u{396, 397, 398, 399}); + polygons.push_back(dl::Vec4u{400, 401, 402, 403}); + polygons.push_back(dl::Vec4u{404, 405, 406, 407}); + polygons.push_back(dl::Vec4u{408, 409, 410, 411}); + polygons.push_back(dl::Vec4u{412, 413, 414, 415}); + polygons.push_back(dl::Vec4u{416, 417, 418, 419}); + polygons.push_back(dl::Vec4u{420, 421, 422, 423}); + polygons.push_back(dl::Vec4u{424, 425, 426, 427}); + polygons.push_back(dl::Vec4u{428, 429, 430, 431}); + polygons.push_back(dl::Vec4u{432, 433, 434, 435}); + polygons.push_back(dl::Vec4u{436, 437, 438, 439}); + polygons.push_back(dl::Vec4u{440, 441, 442, 443}); + polygons.push_back(dl::Vec4u{444, 445, 446, 447}); + polygons.push_back(dl::Vec4u{448, 449, 450, 451}); + polygons.push_back(dl::Vec4u{452, 453, 454, 455}); + polygons.push_back(dl::Vec4u{456, 457, 458, 459}); + polygons.push_back(dl::Vec4u{460, 461, 462, 463}); + polygons.push_back(dl::Vec4u{464, 465, 466, 467}); + polygons.push_back(dl::Vec4u{468, 469, 470, 471}); + polygons.push_back(dl::Vec4u{472, 473, 474, 475}); + polygons.push_back(dl::Vec4u{476, 477, 478, 479}); + polygons.push_back(dl::Vec4u{480, 481, 482, 483}); + polygons.push_back(dl::Vec4u{484, 485, 486, 487}); + polygons.push_back(dl::Vec4u{488, 489, 490, 491}); + polygons.push_back(dl::Vec4u{492, 493, 494, 495}); + polygons.push_back(dl::Vec4u{496, 497, 498, 499}); + polygons.push_back(dl::Vec4u{500, 501, 502, 503}); + polygons.push_back(dl::Vec4u{504, 505, 506, 507}); + polygons.push_back(dl::Vec4u{508, 509, 510, 511}); + polygons.push_back(dl::Vec4u{512, 513, 514, 515}); + polygons.push_back(dl::Vec4u{516, 517, 518, 519}); + polygons.push_back(dl::Vec4u{520, 521, 522, 523}); + polygons.push_back(dl::Vec4u{524, 525, 526, 527}); + polygons.push_back(dl::Vec4u{528, 529, 530, 531}); + polygons.push_back(dl::Vec4u{532, 533, 534, 535}); + polygons.push_back(dl::Vec4u{536, 537, 538, 539}); + polygons.push_back(dl::Vec4u{540, 541, 542, 543}); + polygons.push_back(dl::Vec4u{544, 545, 546, 547}); + polygons.push_back(dl::Vec4u{548, 549, 550, 551}); + polygons.push_back(dl::Vec4u{552, 553, 554, 555}); + polygons.push_back(dl::Vec4u{556, 557, 558, 559}); + polygons.push_back(dl::Vec4u{560, 561, 562, 563}); + polygons.push_back(dl::Vec4u{564, 565, 566, 567}); + polygons.push_back(dl::Vec4u{568, 569, 570, 571}); + polygons.push_back(dl::Vec4u{572, 573, 574, 575}); + polygons.push_back(dl::Vec4u{576, 577, 578, 579}); + polygons.push_back(dl::Vec4u{580, 581, 582, 583}); + polygons.push_back(dl::Vec4u{584, 585, 586, 587}); + polygons.push_back(dl::Vec4u{588, 589, 590, 591}); + polygons.push_back(dl::Vec4u{592, 593, 594, 595}); + polygons.push_back(dl::Vec4u{596, 597, 598, 599}); + belMeshVoxel["polygons"] = polygons; + + dl::ds::Vector normals; + normals.push_back(dl::Vec3f{0, -1, 0}); + normals.push_back(dl::Vec3f{0, -1, 0}); + normals.push_back(dl::Vec3f{0, -1, 0}); + normals.push_back(dl::Vec3f{0, -1, 0}); + normals.push_back(dl::Vec3f{1, 0, 0}); + normals.push_back(dl::Vec3f{1, 0, 0}); + normals.push_back(dl::Vec3f{1, 0, 0}); + normals.push_back(dl::Vec3f{1, 0, 0}); + normals.push_back(dl::Vec3f{0, 0, 1}); + normals.push_back(dl::Vec3f{0, 0, 1}); + normals.push_back(dl::Vec3f{0, 0, 1}); + normals.push_back(dl::Vec3f{0, 0, 1}); + normals.push_back(dl::Vec3f{-1, 0, 0}); + normals.push_back(dl::Vec3f{-1, 0, 0}); + normals.push_back(dl::Vec3f{-1, 0, 0}); + normals.push_back(dl::Vec3f{-1, 0, 0}); + normals.push_back(dl::Vec3f{0, 1, 0}); + normals.push_back(dl::Vec3f{0, 1, 0}); + normals.push_back(dl::Vec3f{0, 1, 0}); + normals.push_back(dl::Vec3f{0, 1, 0}); + normals.push_back(dl::Vec3f{-0.00001, -0.000047, -1}); + normals.push_back(dl::Vec3f{-0.000062, -0.382654, -0.923892}); + normals.push_back(dl::Vec3f{-0.367325, -0.367291, -0.8545}); + normals.push_back(dl::Vec3f{-0.382636, -0.000045, -0.923899}); + normals.push_back(dl::Vec3f{-0, -0.38271, -0.923869}); + normals.push_back(dl::Vec3f{-0.000048, -0.707083, -0.707131}); + normals.push_back(dl::Vec3f{-0.334722, -0.66629, -0.666347}); + normals.push_back(dl::Vec3f{-0.367321, -0.367379, -0.854463}); + normals.push_back(dl::Vec3f{-0.38268, -0.000035, -0.923881}); + normals.push_back(dl::Vec3f{-0.367373, -0.367314, -0.854469}); + normals.push_back(dl::Vec3f{-0.6663, -0.3347, -0.66634}); + normals.push_back(dl::Vec3f{-0.707079, -0.000042, -0.707135}); + normals.push_back(dl::Vec3f{-0.367366, -0.36739, -0.85444}); + normals.push_back(dl::Vec3f{-0.334782, -0.666288, -0.66632}); + normals.push_back(dl::Vec3f{-0.577331, -0.577344, -0.577376}); + normals.push_back(dl::Vec3f{-0.666285, -0.334777, -0.666324}); + normals.push_back(dl::Vec3f{-0.000047, -1, -0.00001}); + normals.push_back(dl::Vec3f{-0.382654, -0.923892, -0.000062}); + normals.push_back(dl::Vec3f{-0.367291, -0.8545, -0.367325}); + normals.push_back(dl::Vec3f{-0.000045, -0.923899, -0.382636}); + normals.push_back(dl::Vec3f{-0.38271, -0.923869, -0}); + normals.push_back(dl::Vec3f{-0.707083, -0.707131, -0.000048}); + normals.push_back(dl::Vec3f{-0.66629, -0.666347, -0.334722}); + normals.push_back(dl::Vec3f{-0.367379, -0.854463, -0.367321}); + normals.push_back(dl::Vec3f{-0.000035, -0.923881, -0.38268}); + normals.push_back(dl::Vec3f{-0.367314, -0.854469, -0.367373}); + normals.push_back(dl::Vec3f{-0.3347, -0.66634, -0.6663}); + normals.push_back(dl::Vec3f{-0.000042, -0.707135, -0.707079}); + normals.push_back(dl::Vec3f{-0.36739, -0.85444, -0.367366}); + normals.push_back(dl::Vec3f{-0.666288, -0.66632, -0.334782}); + normals.push_back(dl::Vec3f{-0.577344, -0.577376, -0.577331}); + normals.push_back(dl::Vec3f{-0.334777, -0.666324, -0.666285}); + normals.push_back(dl::Vec3f{-1, -0.00001, -0.000047}); + normals.push_back(dl::Vec3f{-0.923892, -0.000062, -0.382654}); + normals.push_back(dl::Vec3f{-0.8545, -0.367325, -0.367291}); + normals.push_back(dl::Vec3f{-0.923899, -0.382636, -0.000045}); + normals.push_back(dl::Vec3f{-0.923869, -0, -0.38271}); + normals.push_back(dl::Vec3f{-0.707131, -0.000048, -0.707083}); + normals.push_back(dl::Vec3f{-0.666347, -0.334722, -0.66629}); + normals.push_back(dl::Vec3f{-0.854463, -0.367321, -0.367379}); + normals.push_back(dl::Vec3f{-0.923881, -0.38268, -0.000035}); + normals.push_back(dl::Vec3f{-0.854469, -0.367373, -0.367314}); + normals.push_back(dl::Vec3f{-0.66634, -0.6663, -0.3347}); + normals.push_back(dl::Vec3f{-0.707135, -0.707079, -0.000042}); + normals.push_back(dl::Vec3f{-0.85444, -0.367366, -0.36739}); + normals.push_back(dl::Vec3f{-0.66632, -0.334782, -0.666288}); + normals.push_back(dl::Vec3f{-0.577376, -0.577331, -0.577344}); + normals.push_back(dl::Vec3f{-0.666324, -0.666285, -0.334777}); + normals.push_back(dl::Vec3f{-0.00001, -1, 0.000046}); + normals.push_back(dl::Vec3f{-0.000063, -0.923892, 0.382654}); + normals.push_back(dl::Vec3f{-0.367325, -0.8545, 0.367291}); + normals.push_back(dl::Vec3f{-0.382636, -0.923899, 0.000045}); + normals.push_back(dl::Vec3f{-0, -0.923868, 0.38271}); + normals.push_back(dl::Vec3f{-0.000049, -0.70713, 0.707083}); + normals.push_back(dl::Vec3f{-0.334723, -0.666346, 0.66629}); + normals.push_back(dl::Vec3f{-0.367322, -0.854463, 0.36738}); + normals.push_back(dl::Vec3f{-0.38268, -0.923881, 0.000035}); + normals.push_back(dl::Vec3f{-0.367373, -0.854469, 0.367314}); + normals.push_back(dl::Vec3f{-0.6663, -0.666341, 0.3347}); + normals.push_back(dl::Vec3f{-0.707079, -0.707135, 0.000042}); + normals.push_back(dl::Vec3f{-0.367366, -0.854439, 0.36739}); + normals.push_back(dl::Vec3f{-0.334781, -0.66632, 0.666288}); + normals.push_back(dl::Vec3f{-0.577331, -0.577375, 0.577345}); + normals.push_back(dl::Vec3f{-0.666285, -0.666324, 0.334778}); + normals.push_back(dl::Vec3f{-0.000046, -0.00001, 1}); + normals.push_back(dl::Vec3f{-0.382654, -0.000063, 0.923892}); + normals.push_back(dl::Vec3f{-0.367291, -0.367325, 0.8545}); + normals.push_back(dl::Vec3f{-0.000045, -0.382636, 0.923899}); + normals.push_back(dl::Vec3f{-0.38271, -0, 0.923869}); + normals.push_back(dl::Vec3f{-0.707083, -0.000049, 0.70713}); + normals.push_back(dl::Vec3f{-0.666291, -0.334723, 0.666346}); + normals.push_back(dl::Vec3f{-0.36738, -0.367322, 0.854463}); + normals.push_back(dl::Vec3f{-0.000035, -0.38268, 0.923881}); + normals.push_back(dl::Vec3f{-0.367314, -0.367373, 0.854469}); + normals.push_back(dl::Vec3f{-0.3347, -0.6663, 0.666341}); + normals.push_back(dl::Vec3f{-0.000042, -0.707079, 0.707135}); + normals.push_back(dl::Vec3f{-0.36739, -0.367366, 0.854439}); + normals.push_back(dl::Vec3f{-0.666288, -0.334781, 0.66632}); + normals.push_back(dl::Vec3f{-0.577345, -0.577331, 0.577375}); + normals.push_back(dl::Vec3f{-0.334778, -0.666285, 0.666324}); + normals.push_back(dl::Vec3f{-1, -0.000046, 0.00001}); + normals.push_back(dl::Vec3f{-0.923892, -0.382654, 0.000062}); + normals.push_back(dl::Vec3f{-0.8545, -0.367291, 0.367325}); + normals.push_back(dl::Vec3f{-0.923899, -0.000045, 0.382636}); + normals.push_back(dl::Vec3f{-0.923868, -0.38271, 0}); + normals.push_back(dl::Vec3f{-0.70713, -0.707083, 0.000049}); + normals.push_back(dl::Vec3f{-0.666346, -0.66629, 0.334723}); + normals.push_back(dl::Vec3f{-0.854463, -0.36738, 0.367322}); + normals.push_back(dl::Vec3f{-0.923881, -0.000035, 0.38268}); + normals.push_back(dl::Vec3f{-0.854469, -0.367314, 0.367373}); + normals.push_back(dl::Vec3f{-0.666341, -0.3347, 0.6663}); + normals.push_back(dl::Vec3f{-0.707135, -0.000042, 0.707079}); + normals.push_back(dl::Vec3f{-0.854439, -0.36739, 0.367366}); + normals.push_back(dl::Vec3f{-0.66632, -0.666288, 0.334781}); + normals.push_back(dl::Vec3f{-0.577375, -0.577345, 0.577331}); + normals.push_back(dl::Vec3f{-0.666324, -0.334778, 0.666285}); + normals.push_back(dl::Vec3f{-0.000046, 0.00001, -1}); + normals.push_back(dl::Vec3f{-0.382654, 0.000063, -0.923892}); + normals.push_back(dl::Vec3f{-0.367291, 0.367325, -0.8545}); + normals.push_back(dl::Vec3f{-0.000045, 0.382636, -0.923899}); + normals.push_back(dl::Vec3f{-0.38271, 0, -0.923869}); + normals.push_back(dl::Vec3f{-0.707083, 0.000049, -0.70713}); + normals.push_back(dl::Vec3f{-0.666291, 0.334723, -0.666346}); + normals.push_back(dl::Vec3f{-0.36738, 0.367322, -0.854463}); + normals.push_back(dl::Vec3f{-0.000035, 0.38268, -0.923881}); + normals.push_back(dl::Vec3f{-0.367314, 0.367373, -0.854469}); + normals.push_back(dl::Vec3f{-0.3347, 0.6663, -0.666341}); + normals.push_back(dl::Vec3f{-0.000042, 0.707079, -0.707135}); + normals.push_back(dl::Vec3f{-0.36739, 0.367366, -0.854439}); + normals.push_back(dl::Vec3f{-0.666288, 0.334781, -0.66632}); + normals.push_back(dl::Vec3f{-0.577345, 0.577331, -0.577375}); + normals.push_back(dl::Vec3f{-0.334778, 0.666285, -0.666324}); + normals.push_back(dl::Vec3f{-1, 0.000046, -0.00001}); + normals.push_back(dl::Vec3f{-0.923892, 0.382654, -0.000062}); + normals.push_back(dl::Vec3f{-0.8545, 0.367291, -0.367325}); + normals.push_back(dl::Vec3f{-0.923899, 0.000045, -0.382636}); + normals.push_back(dl::Vec3f{-0.923868, 0.38271, -0}); + normals.push_back(dl::Vec3f{-0.70713, 0.707083, -0.000049}); + normals.push_back(dl::Vec3f{-0.666346, 0.66629, -0.334723}); + normals.push_back(dl::Vec3f{-0.854463, 0.36738, -0.367322}); + normals.push_back(dl::Vec3f{-0.923881, 0.000035, -0.38268}); + normals.push_back(dl::Vec3f{-0.854469, 0.367314, -0.367373}); + normals.push_back(dl::Vec3f{-0.666341, 0.3347, -0.6663}); + normals.push_back(dl::Vec3f{-0.707135, 0.000042, -0.707079}); + normals.push_back(dl::Vec3f{-0.854439, 0.36739, -0.367366}); + normals.push_back(dl::Vec3f{-0.66632, 0.666288, -0.334781}); + normals.push_back(dl::Vec3f{-0.577375, 0.577345, -0.577331}); + normals.push_back(dl::Vec3f{-0.666324, 0.334778, -0.666285}); + normals.push_back(dl::Vec3f{-0.00001, 1, -0.000046}); + normals.push_back(dl::Vec3f{-0.000063, 0.923892, -0.382654}); + normals.push_back(dl::Vec3f{-0.367325, 0.8545, -0.367291}); + normals.push_back(dl::Vec3f{-0.382636, 0.923899, -0.000045}); + normals.push_back(dl::Vec3f{-0, 0.923868, -0.38271}); + normals.push_back(dl::Vec3f{-0.000049, 0.70713, -0.707083}); + normals.push_back(dl::Vec3f{-0.334723, 0.666346, -0.66629}); + normals.push_back(dl::Vec3f{-0.367322, 0.854463, -0.36738}); + normals.push_back(dl::Vec3f{-0.38268, 0.923881, -0.000035}); + normals.push_back(dl::Vec3f{-0.367373, 0.854469, -0.367314}); + normals.push_back(dl::Vec3f{-0.6663, 0.666341, -0.3347}); + normals.push_back(dl::Vec3f{-0.707079, 0.707135, -0.000042}); + normals.push_back(dl::Vec3f{-0.367366, 0.854439, -0.36739}); + normals.push_back(dl::Vec3f{-0.334781, 0.66632, -0.666288}); + normals.push_back(dl::Vec3f{-0.577331, 0.577375, -0.577345}); + normals.push_back(dl::Vec3f{-0.666285, 0.666324, -0.334778}); + normals.push_back(dl::Vec3f{-0.00001, 0.000047, 1}); + normals.push_back(dl::Vec3f{-0.000062, 0.382654, 0.923892}); + normals.push_back(dl::Vec3f{-0.367325, 0.367291, 0.8545}); + normals.push_back(dl::Vec3f{-0.382636, 0.000045, 0.923899}); + normals.push_back(dl::Vec3f{-0, 0.38271, 0.923869}); + normals.push_back(dl::Vec3f{-0.000048, 0.707083, 0.707131}); + normals.push_back(dl::Vec3f{-0.334722, 0.66629, 0.666347}); + normals.push_back(dl::Vec3f{-0.367321, 0.367379, 0.854463}); + normals.push_back(dl::Vec3f{-0.38268, 0.000035, 0.923881}); + normals.push_back(dl::Vec3f{-0.367373, 0.367314, 0.854469}); + normals.push_back(dl::Vec3f{-0.6663, 0.3347, 0.66634}); + normals.push_back(dl::Vec3f{-0.707079, 0.000042, 0.707135}); + normals.push_back(dl::Vec3f{-0.367366, 0.36739, 0.85444}); + normals.push_back(dl::Vec3f{-0.334782, 0.666288, 0.66632}); + normals.push_back(dl::Vec3f{-0.577331, 0.577344, 0.577376}); + normals.push_back(dl::Vec3f{-0.666285, 0.334777, 0.666324}); + normals.push_back(dl::Vec3f{-0.000047, 1, 0.00001}); + normals.push_back(dl::Vec3f{-0.382654, 0.923892, 0.000062}); + normals.push_back(dl::Vec3f{-0.367291, 0.8545, 0.367325}); + normals.push_back(dl::Vec3f{-0.000045, 0.923899, 0.382636}); + normals.push_back(dl::Vec3f{-0.38271, 0.923869, 0}); + normals.push_back(dl::Vec3f{-0.707083, 0.707131, 0.000048}); + normals.push_back(dl::Vec3f{-0.66629, 0.666347, 0.334722}); + normals.push_back(dl::Vec3f{-0.367379, 0.854463, 0.367321}); + normals.push_back(dl::Vec3f{-0.000035, 0.923881, 0.38268}); + normals.push_back(dl::Vec3f{-0.367314, 0.854469, 0.367373}); + normals.push_back(dl::Vec3f{-0.3347, 0.66634, 0.6663}); + normals.push_back(dl::Vec3f{-0.000042, 0.707135, 0.707079}); + normals.push_back(dl::Vec3f{-0.36739, 0.85444, 0.367366}); + normals.push_back(dl::Vec3f{-0.666288, 0.66632, 0.334782}); + normals.push_back(dl::Vec3f{-0.577344, 0.577376, 0.577331}); + normals.push_back(dl::Vec3f{-0.334777, 0.666324, 0.666285}); + normals.push_back(dl::Vec3f{-1, 0.00001, 0.000047}); + normals.push_back(dl::Vec3f{-0.923892, 0.000062, 0.382654}); + normals.push_back(dl::Vec3f{-0.8545, 0.367325, 0.367291}); + normals.push_back(dl::Vec3f{-0.923899, 0.382636, 0.000045}); + normals.push_back(dl::Vec3f{-0.923869, 0, 0.38271}); + normals.push_back(dl::Vec3f{-0.707131, 0.000048, 0.707083}); + normals.push_back(dl::Vec3f{-0.666347, 0.334722, 0.66629}); + normals.push_back(dl::Vec3f{-0.854463, 0.367321, 0.367379}); + normals.push_back(dl::Vec3f{-0.923881, 0.38268, 0.000035}); + normals.push_back(dl::Vec3f{-0.854469, 0.367373, 0.367314}); + normals.push_back(dl::Vec3f{-0.66634, 0.6663, 0.3347}); + normals.push_back(dl::Vec3f{-0.707135, 0.707079, 0.000042}); + normals.push_back(dl::Vec3f{-0.85444, 0.367366, 0.36739}); + normals.push_back(dl::Vec3f{-0.66632, 0.334782, 0.666288}); + normals.push_back(dl::Vec3f{-0.577376, 0.577331, 0.577344}); + normals.push_back(dl::Vec3f{-0.666324, 0.666285, 0.334777}); + normals.push_back(dl::Vec3f{0.000046, -0.00001, -1}); + normals.push_back(dl::Vec3f{0.382654, -0.000063, -0.923892}); + normals.push_back(dl::Vec3f{0.367291, -0.367325, -0.8545}); + normals.push_back(dl::Vec3f{0.000045, -0.382636, -0.923899}); + normals.push_back(dl::Vec3f{0.38271, -0, -0.923869}); + normals.push_back(dl::Vec3f{0.707083, -0.000049, -0.70713}); + normals.push_back(dl::Vec3f{0.666291, -0.334723, -0.666346}); + normals.push_back(dl::Vec3f{0.36738, -0.367322, -0.854463}); + normals.push_back(dl::Vec3f{0.000035, -0.38268, -0.923881}); + normals.push_back(dl::Vec3f{0.367314, -0.367373, -0.854469}); + normals.push_back(dl::Vec3f{0.3347, -0.6663, -0.666341}); + normals.push_back(dl::Vec3f{0.000042, -0.707079, -0.707135}); + normals.push_back(dl::Vec3f{0.36739, -0.367366, -0.854439}); + normals.push_back(dl::Vec3f{0.666288, -0.334781, -0.66632}); + normals.push_back(dl::Vec3f{0.577345, -0.577331, -0.577375}); + normals.push_back(dl::Vec3f{0.334778, -0.666285, -0.666324}); + normals.push_back(dl::Vec3f{1, -0.000046, -0.00001}); + normals.push_back(dl::Vec3f{0.923892, -0.382654, -0.000062}); + normals.push_back(dl::Vec3f{0.8545, -0.367291, -0.367325}); + normals.push_back(dl::Vec3f{0.923899, -0.000045, -0.382636}); + normals.push_back(dl::Vec3f{0.923868, -0.38271, -0}); + normals.push_back(dl::Vec3f{0.70713, -0.707083, -0.000049}); + normals.push_back(dl::Vec3f{0.666346, -0.66629, -0.334723}); + normals.push_back(dl::Vec3f{0.854463, -0.36738, -0.367322}); + normals.push_back(dl::Vec3f{0.923881, -0.000035, -0.38268}); + normals.push_back(dl::Vec3f{0.854469, -0.367314, -0.367373}); + normals.push_back(dl::Vec3f{0.666341, -0.3347, -0.6663}); + normals.push_back(dl::Vec3f{0.707135, -0.000042, -0.707079}); + normals.push_back(dl::Vec3f{0.854439, -0.36739, -0.367366}); + normals.push_back(dl::Vec3f{0.66632, -0.666288, -0.334781}); + normals.push_back(dl::Vec3f{0.577375, -0.577345, -0.577331}); + normals.push_back(dl::Vec3f{0.666324, -0.334778, -0.666285}); + normals.push_back(dl::Vec3f{0.00001, -1, -0.000046}); + normals.push_back(dl::Vec3f{0.000063, -0.923892, -0.382654}); + normals.push_back(dl::Vec3f{0.367325, -0.8545, -0.367291}); + normals.push_back(dl::Vec3f{0.382636, -0.923899, -0.000045}); + normals.push_back(dl::Vec3f{0, -0.923868, -0.38271}); + normals.push_back(dl::Vec3f{0.000049, -0.70713, -0.707083}); + normals.push_back(dl::Vec3f{0.334723, -0.666346, -0.66629}); + normals.push_back(dl::Vec3f{0.367322, -0.854463, -0.36738}); + normals.push_back(dl::Vec3f{0.38268, -0.923881, -0.000035}); + normals.push_back(dl::Vec3f{0.367373, -0.854469, -0.367314}); + normals.push_back(dl::Vec3f{0.6663, -0.666341, -0.3347}); + normals.push_back(dl::Vec3f{0.707079, -0.707135, -0.000042}); + normals.push_back(dl::Vec3f{0.367366, -0.854439, -0.36739}); + normals.push_back(dl::Vec3f{0.334781, -0.66632, -0.666288}); + normals.push_back(dl::Vec3f{0.577331, -0.577375, -0.577345}); + normals.push_back(dl::Vec3f{0.666285, -0.666324, -0.334778}); + normals.push_back(dl::Vec3f{0.00001, -0.000047, 1}); + normals.push_back(dl::Vec3f{0.000062, -0.382654, 0.923892}); + normals.push_back(dl::Vec3f{0.367325, -0.367291, 0.8545}); + normals.push_back(dl::Vec3f{0.382636, -0.000045, 0.923899}); + normals.push_back(dl::Vec3f{0, -0.38271, 0.923869}); + normals.push_back(dl::Vec3f{0.000048, -0.707083, 0.707131}); + normals.push_back(dl::Vec3f{0.334722, -0.66629, 0.666347}); + normals.push_back(dl::Vec3f{0.367321, -0.367379, 0.854463}); + normals.push_back(dl::Vec3f{0.38268, -0.000035, 0.923881}); + normals.push_back(dl::Vec3f{0.367373, -0.367314, 0.854469}); + normals.push_back(dl::Vec3f{0.6663, -0.3347, 0.66634}); + normals.push_back(dl::Vec3f{0.707079, -0.000042, 0.707135}); + normals.push_back(dl::Vec3f{0.367366, -0.36739, 0.85444}); + normals.push_back(dl::Vec3f{0.334782, -0.666288, 0.66632}); + normals.push_back(dl::Vec3f{0.577331, -0.577344, 0.577376}); + normals.push_back(dl::Vec3f{0.666285, -0.334777, 0.666324}); + normals.push_back(dl::Vec3f{0.000047, -1, 0.00001}); + normals.push_back(dl::Vec3f{0.382654, -0.923892, 0.000062}); + normals.push_back(dl::Vec3f{0.367291, -0.8545, 0.367325}); + normals.push_back(dl::Vec3f{0.000045, -0.923899, 0.382636}); + normals.push_back(dl::Vec3f{0.38271, -0.923869, 0}); + normals.push_back(dl::Vec3f{0.707083, -0.707131, 0.000048}); + normals.push_back(dl::Vec3f{0.66629, -0.666347, 0.334722}); + normals.push_back(dl::Vec3f{0.367379, -0.854463, 0.367321}); + normals.push_back(dl::Vec3f{0.000035, -0.923881, 0.38268}); + normals.push_back(dl::Vec3f{0.367314, -0.854469, 0.367373}); + normals.push_back(dl::Vec3f{0.3347, -0.66634, 0.6663}); + normals.push_back(dl::Vec3f{0.000042, -0.707135, 0.707079}); + normals.push_back(dl::Vec3f{0.36739, -0.85444, 0.367366}); + normals.push_back(dl::Vec3f{0.666288, -0.66632, 0.334782}); + normals.push_back(dl::Vec3f{0.577344, -0.577376, 0.577331}); + normals.push_back(dl::Vec3f{0.334777, -0.666324, 0.666285}); + normals.push_back(dl::Vec3f{1, -0.00001, 0.000047}); + normals.push_back(dl::Vec3f{0.923892, -0.000062, 0.382654}); + normals.push_back(dl::Vec3f{0.8545, -0.367325, 0.367291}); + normals.push_back(dl::Vec3f{0.923899, -0.382636, 0.000045}); + normals.push_back(dl::Vec3f{0.923869, -0, 0.38271}); + normals.push_back(dl::Vec3f{0.707131, -0.000048, 0.707083}); + normals.push_back(dl::Vec3f{0.666347, -0.334722, 0.66629}); + normals.push_back(dl::Vec3f{0.854463, -0.367321, 0.367379}); + normals.push_back(dl::Vec3f{0.923881, -0.38268, 0.000035}); + normals.push_back(dl::Vec3f{0.854469, -0.367373, 0.367314}); + normals.push_back(dl::Vec3f{0.66634, -0.6663, 0.3347}); + normals.push_back(dl::Vec3f{0.707135, -0.707079, 0.000042}); + normals.push_back(dl::Vec3f{0.85444, -0.367366, 0.36739}); + normals.push_back(dl::Vec3f{0.66632, -0.334782, 0.666288}); + normals.push_back(dl::Vec3f{0.577376, -0.577331, 0.577344}); + normals.push_back(dl::Vec3f{0.666324, -0.666285, 0.334777}); + normals.push_back(dl::Vec3f{0.00001, 0.000047, -1}); + normals.push_back(dl::Vec3f{0.000062, 0.382654, -0.923892}); + normals.push_back(dl::Vec3f{0.367325, 0.367291, -0.8545}); + normals.push_back(dl::Vec3f{0.382636, 0.000045, -0.923899}); + normals.push_back(dl::Vec3f{0, 0.38271, -0.923869}); + normals.push_back(dl::Vec3f{0.000048, 0.707083, -0.707131}); + normals.push_back(dl::Vec3f{0.334722, 0.66629, -0.666347}); + normals.push_back(dl::Vec3f{0.367321, 0.367379, -0.854463}); + normals.push_back(dl::Vec3f{0.38268, 0.000035, -0.923881}); + normals.push_back(dl::Vec3f{0.367373, 0.367314, -0.854469}); + normals.push_back(dl::Vec3f{0.6663, 0.3347, -0.66634}); + normals.push_back(dl::Vec3f{0.707079, 0.000042, -0.707135}); + normals.push_back(dl::Vec3f{0.367366, 0.36739, -0.85444}); + normals.push_back(dl::Vec3f{0.334782, 0.666288, -0.66632}); + normals.push_back(dl::Vec3f{0.577331, 0.577344, -0.577376}); + normals.push_back(dl::Vec3f{0.666285, 0.334777, -0.666324}); + normals.push_back(dl::Vec3f{0.000047, 1, -0.00001}); + normals.push_back(dl::Vec3f{0.382654, 0.923892, -0.000062}); + normals.push_back(dl::Vec3f{0.367291, 0.8545, -0.367325}); + normals.push_back(dl::Vec3f{0.000045, 0.923899, -0.382636}); + normals.push_back(dl::Vec3f{0.38271, 0.923869, -0}); + normals.push_back(dl::Vec3f{0.707083, 0.707131, -0.000048}); + normals.push_back(dl::Vec3f{0.66629, 0.666347, -0.334722}); + normals.push_back(dl::Vec3f{0.367379, 0.854463, -0.367321}); + normals.push_back(dl::Vec3f{0.000035, 0.923881, -0.38268}); + normals.push_back(dl::Vec3f{0.367314, 0.854469, -0.367373}); + normals.push_back(dl::Vec3f{0.3347, 0.66634, -0.6663}); + normals.push_back(dl::Vec3f{0.000042, 0.707135, -0.707079}); + normals.push_back(dl::Vec3f{0.36739, 0.85444, -0.367366}); + normals.push_back(dl::Vec3f{0.666288, 0.66632, -0.334782}); + normals.push_back(dl::Vec3f{0.577344, 0.577376, -0.577331}); + normals.push_back(dl::Vec3f{0.334777, 0.666324, -0.666285}); + normals.push_back(dl::Vec3f{1, 0.00001, -0.000047}); + normals.push_back(dl::Vec3f{0.923892, 0.000062, -0.382654}); + normals.push_back(dl::Vec3f{0.8545, 0.367325, -0.367291}); + normals.push_back(dl::Vec3f{0.923899, 0.382636, -0.000045}); + normals.push_back(dl::Vec3f{0.923869, 0, -0.38271}); + normals.push_back(dl::Vec3f{0.707131, 0.000048, -0.707083}); + normals.push_back(dl::Vec3f{0.666347, 0.334722, -0.66629}); + normals.push_back(dl::Vec3f{0.854463, 0.367321, -0.367379}); + normals.push_back(dl::Vec3f{0.923881, 0.38268, -0.000035}); + normals.push_back(dl::Vec3f{0.854469, 0.367373, -0.367314}); + normals.push_back(dl::Vec3f{0.66634, 0.6663, -0.3347}); + normals.push_back(dl::Vec3f{0.707135, 0.707079, -0.000042}); + normals.push_back(dl::Vec3f{0.85444, 0.367366, -0.36739}); + normals.push_back(dl::Vec3f{0.66632, 0.334782, -0.666288}); + normals.push_back(dl::Vec3f{0.577376, 0.577331, -0.577344}); + normals.push_back(dl::Vec3f{0.666324, 0.666285, -0.334777}); + normals.push_back(dl::Vec3f{0.000046, 0.00001, 1}); + normals.push_back(dl::Vec3f{0.382654, 0.000063, 0.923892}); + normals.push_back(dl::Vec3f{0.367291, 0.367325, 0.8545}); + normals.push_back(dl::Vec3f{0.000045, 0.382636, 0.923899}); + normals.push_back(dl::Vec3f{0.38271, 0, 0.923869}); + normals.push_back(dl::Vec3f{0.707083, 0.000049, 0.70713}); + normals.push_back(dl::Vec3f{0.666291, 0.334723, 0.666346}); + normals.push_back(dl::Vec3f{0.36738, 0.367322, 0.854463}); + normals.push_back(dl::Vec3f{0.000035, 0.38268, 0.923881}); + normals.push_back(dl::Vec3f{0.367314, 0.367373, 0.854469}); + normals.push_back(dl::Vec3f{0.3347, 0.6663, 0.666341}); + normals.push_back(dl::Vec3f{0.000042, 0.707079, 0.707135}); + normals.push_back(dl::Vec3f{0.36739, 0.367366, 0.854439}); + normals.push_back(dl::Vec3f{0.666288, 0.334781, 0.66632}); + normals.push_back(dl::Vec3f{0.577345, 0.577331, 0.577375}); + normals.push_back(dl::Vec3f{0.334778, 0.666285, 0.666324}); + normals.push_back(dl::Vec3f{1, 0.000046, 0.00001}); + normals.push_back(dl::Vec3f{0.923892, 0.382654, 0.000062}); + normals.push_back(dl::Vec3f{0.8545, 0.367291, 0.367325}); + normals.push_back(dl::Vec3f{0.923899, 0.000045, 0.382636}); + normals.push_back(dl::Vec3f{0.923868, 0.38271, 0}); + normals.push_back(dl::Vec3f{0.70713, 0.707083, 0.000049}); + normals.push_back(dl::Vec3f{0.666346, 0.66629, 0.334723}); + normals.push_back(dl::Vec3f{0.854463, 0.36738, 0.367322}); + normals.push_back(dl::Vec3f{0.923881, 0.000035, 0.38268}); + normals.push_back(dl::Vec3f{0.854469, 0.367314, 0.367373}); + normals.push_back(dl::Vec3f{0.666341, 0.3347, 0.6663}); + normals.push_back(dl::Vec3f{0.707135, 0.000042, 0.707079}); + normals.push_back(dl::Vec3f{0.854439, 0.36739, 0.367366}); + normals.push_back(dl::Vec3f{0.66632, 0.666288, 0.334781}); + normals.push_back(dl::Vec3f{0.577375, 0.577345, 0.577331}); + normals.push_back(dl::Vec3f{0.666324, 0.334778, 0.666285}); + normals.push_back(dl::Vec3f{0.00001, 1, 0.000046}); + normals.push_back(dl::Vec3f{0.000063, 0.923892, 0.382654}); + normals.push_back(dl::Vec3f{0.367325, 0.8545, 0.367291}); + normals.push_back(dl::Vec3f{0.382636, 0.923899, 0.000045}); + normals.push_back(dl::Vec3f{0, 0.923868, 0.38271}); + normals.push_back(dl::Vec3f{0.000049, 0.70713, 0.707083}); + normals.push_back(dl::Vec3f{0.334723, 0.666346, 0.66629}); + normals.push_back(dl::Vec3f{0.367322, 0.854463, 0.36738}); + normals.push_back(dl::Vec3f{0.38268, 0.923881, 0.000035}); + normals.push_back(dl::Vec3f{0.367373, 0.854469, 0.367314}); + normals.push_back(dl::Vec3f{0.6663, 0.666341, 0.3347}); + normals.push_back(dl::Vec3f{0.707079, 0.707135, 0.000042}); + normals.push_back(dl::Vec3f{0.367366, 0.854439, 0.36739}); + normals.push_back(dl::Vec3f{0.334781, 0.66632, 0.666288}); + normals.push_back(dl::Vec3f{0.577331, 0.577375, 0.577345}); + normals.push_back(dl::Vec3f{0.666285, 0.666324, 0.334778}); + normals.push_back(dl::Vec3f{-0.000042, -0, -1}); + normals.push_back(dl::Vec3f{-0.000042, 0, -1}); + normals.push_back(dl::Vec3f{-0.382645, 0, -0.923896}); + normals.push_back(dl::Vec3f{-0.382645, -0, -0.923896}); + normals.push_back(dl::Vec3f{-0.382722, -0, -0.923863}); + normals.push_back(dl::Vec3f{-0.382722, 0, -0.923863}); + normals.push_back(dl::Vec3f{-0.707077, 0, -0.707136}); + normals.push_back(dl::Vec3f{-0.707077, -0, -0.707136}); + normals.push_back(dl::Vec3f{-0.707136, -0, -0.707077}); + normals.push_back(dl::Vec3f{-0.707136, 0, -0.707077}); + normals.push_back(dl::Vec3f{-0.923863, 0, -0.382722}); + normals.push_back(dl::Vec3f{-0.923863, -0, -0.382722}); + normals.push_back(dl::Vec3f{-0.923896, -0, -0.382645}); + normals.push_back(dl::Vec3f{-0.923896, 0, -0.382645}); + normals.push_back(dl::Vec3f{-1, 0, -0.000042}); + normals.push_back(dl::Vec3f{-1, -0, -0.000042}); + normals.push_back(dl::Vec3f{-0.000042, -1, 0}); + normals.push_back(dl::Vec3f{-0.000042, -1, -0}); + normals.push_back(dl::Vec3f{-0.382645, -0.923896, -0}); + normals.push_back(dl::Vec3f{-0.382645, -0.923896, 0}); + normals.push_back(dl::Vec3f{-0.382722, -0.923863, 0}); + normals.push_back(dl::Vec3f{-0.382722, -0.923863, -0}); + normals.push_back(dl::Vec3f{-0.707077, -0.707136, -0}); + normals.push_back(dl::Vec3f{-0.707077, -0.707136, 0}); + normals.push_back(dl::Vec3f{-0.707136, -0.707077, 0}); + normals.push_back(dl::Vec3f{-0.707136, -0.707077, -0}); + normals.push_back(dl::Vec3f{-0.923863, -0.382722, -0}); + normals.push_back(dl::Vec3f{-0.923863, -0.382722, 0}); + normals.push_back(dl::Vec3f{-0.923896, -0.382645, 0}); + normals.push_back(dl::Vec3f{-0.923896, -0.382645, -0}); + normals.push_back(dl::Vec3f{-1, -0.000042, -0}); + normals.push_back(dl::Vec3f{-1, -0.000042, 0}); + normals.push_back(dl::Vec3f{-0.000042, 0, 1}); + normals.push_back(dl::Vec3f{-0.000042, -0, 1}); + normals.push_back(dl::Vec3f{-0.382645, -0, 0.923896}); + normals.push_back(dl::Vec3f{-0.382645, 0, 0.923896}); + normals.push_back(dl::Vec3f{-0.382722, 0, 0.923863}); + normals.push_back(dl::Vec3f{-0.382722, -0, 0.923863}); + normals.push_back(dl::Vec3f{-0.707077, -0, 0.707136}); + normals.push_back(dl::Vec3f{-0.707077, 0, 0.707136}); + normals.push_back(dl::Vec3f{-0.707136, 0, 0.707077}); + normals.push_back(dl::Vec3f{-0.707136, -0, 0.707077}); + normals.push_back(dl::Vec3f{-0.923863, -0, 0.382722}); + normals.push_back(dl::Vec3f{-0.923863, 0, 0.382722}); + normals.push_back(dl::Vec3f{-0.923896, 0, 0.382645}); + normals.push_back(dl::Vec3f{-0.923896, -0, 0.382645}); + normals.push_back(dl::Vec3f{-1, -0, 0.000042}); + normals.push_back(dl::Vec3f{-1, 0, 0.000042}); + normals.push_back(dl::Vec3f{-0.000042, 1, -0}); + normals.push_back(dl::Vec3f{-0.000042, 1, 0}); + normals.push_back(dl::Vec3f{-0.382645, 0.923896, 0}); + normals.push_back(dl::Vec3f{-0.382645, 0.923896, -0}); + normals.push_back(dl::Vec3f{-0.382722, 0.923863, -0}); + normals.push_back(dl::Vec3f{-0.382722, 0.923863, 0}); + normals.push_back(dl::Vec3f{-0.707077, 0.707136, 0}); + normals.push_back(dl::Vec3f{-0.707077, 0.707136, -0}); + normals.push_back(dl::Vec3f{-0.707136, 0.707077, -0}); + normals.push_back(dl::Vec3f{-0.707136, 0.707077, 0}); + normals.push_back(dl::Vec3f{-0.923863, 0.382722, 0}); + normals.push_back(dl::Vec3f{-0.923863, 0.382722, -0}); + normals.push_back(dl::Vec3f{-0.923896, 0.382645, -0}); + normals.push_back(dl::Vec3f{-0.923896, 0.382645, 0}); + normals.push_back(dl::Vec3f{-1, 0.000042, 0}); + normals.push_back(dl::Vec3f{-1, 0.000042, -0}); + normals.push_back(dl::Vec3f{-0, 0.000042, -1}); + normals.push_back(dl::Vec3f{0, 0.000042, -1}); + normals.push_back(dl::Vec3f{0, 0.382645, -0.923896}); + normals.push_back(dl::Vec3f{-0, 0.382645, -0.923896}); + normals.push_back(dl::Vec3f{-0, 0.382722, -0.923863}); + normals.push_back(dl::Vec3f{0, 0.382722, -0.923863}); + normals.push_back(dl::Vec3f{0, 0.707077, -0.707136}); + normals.push_back(dl::Vec3f{-0, 0.707077, -0.707136}); + normals.push_back(dl::Vec3f{-0, 0.707136, -0.707077}); + normals.push_back(dl::Vec3f{0, 0.707136, -0.707077}); + normals.push_back(dl::Vec3f{0, 0.923863, -0.382722}); + normals.push_back(dl::Vec3f{-0, 0.923863, -0.382722}); + normals.push_back(dl::Vec3f{-0, 0.923896, -0.382645}); + normals.push_back(dl::Vec3f{0, 0.923896, -0.382645}); + normals.push_back(dl::Vec3f{0, 1, -0.000042}); + normals.push_back(dl::Vec3f{-0, 1, -0.000042}); + normals.push_back(dl::Vec3f{0, 0.000042, 1}); + normals.push_back(dl::Vec3f{-0, 0.000042, 1}); + normals.push_back(dl::Vec3f{-0, 0.382645, 0.923896}); + normals.push_back(dl::Vec3f{0, 0.382645, 0.923896}); + normals.push_back(dl::Vec3f{0, 0.382722, 0.923863}); + normals.push_back(dl::Vec3f{-0, 0.382722, 0.923863}); + normals.push_back(dl::Vec3f{-0, 0.707077, 0.707136}); + normals.push_back(dl::Vec3f{0, 0.707077, 0.707136}); + normals.push_back(dl::Vec3f{0, 0.707136, 0.707077}); + normals.push_back(dl::Vec3f{-0, 0.707136, 0.707077}); + normals.push_back(dl::Vec3f{-0, 0.923863, 0.382722}); + normals.push_back(dl::Vec3f{0, 0.923863, 0.382722}); + normals.push_back(dl::Vec3f{0, 0.923896, 0.382645}); + normals.push_back(dl::Vec3f{-0, 0.923896, 0.382645}); + normals.push_back(dl::Vec3f{-0, 1, 0.000042}); + normals.push_back(dl::Vec3f{0, 1, 0.000042}); + normals.push_back(dl::Vec3f{1, 0.000042, -0}); + normals.push_back(dl::Vec3f{1, 0.000042, 0}); + normals.push_back(dl::Vec3f{0.923896, 0.382645, 0}); + normals.push_back(dl::Vec3f{0.923896, 0.382645, -0}); + normals.push_back(dl::Vec3f{0.923863, 0.382722, -0}); + normals.push_back(dl::Vec3f{0.923863, 0.382722, 0}); + normals.push_back(dl::Vec3f{0.707136, 0.707077, 0}); + normals.push_back(dl::Vec3f{0.707136, 0.707077, -0}); + normals.push_back(dl::Vec3f{0.707077, 0.707136, -0}); + normals.push_back(dl::Vec3f{0.707077, 0.707136, 0}); + normals.push_back(dl::Vec3f{0.382722, 0.923863, 0}); + normals.push_back(dl::Vec3f{0.382722, 0.923863, -0}); + normals.push_back(dl::Vec3f{0.382645, 0.923896, -0}); + normals.push_back(dl::Vec3f{0.382645, 0.923896, 0}); + normals.push_back(dl::Vec3f{0.000042, 1, 0}); + normals.push_back(dl::Vec3f{0.000042, 1, -0}); + normals.push_back(dl::Vec3f{0.000042, 0, -1}); + normals.push_back(dl::Vec3f{0.000042, -0, -1}); + normals.push_back(dl::Vec3f{0.382645, -0, -0.923896}); + normals.push_back(dl::Vec3f{0.382645, 0, -0.923896}); + normals.push_back(dl::Vec3f{0.382722, 0, -0.923863}); + normals.push_back(dl::Vec3f{0.382722, -0, -0.923863}); + normals.push_back(dl::Vec3f{0.707077, -0, -0.707136}); + normals.push_back(dl::Vec3f{0.707077, 0, -0.707136}); + normals.push_back(dl::Vec3f{0.707136, 0, -0.707077}); + normals.push_back(dl::Vec3f{0.707136, -0, -0.707077}); + normals.push_back(dl::Vec3f{0.923863, -0, -0.382722}); + normals.push_back(dl::Vec3f{0.923863, 0, -0.382722}); + normals.push_back(dl::Vec3f{0.923896, 0, -0.382645}); + normals.push_back(dl::Vec3f{0.923896, -0, -0.382645}); + normals.push_back(dl::Vec3f{1, -0, -0.000042}); + normals.push_back(dl::Vec3f{1, 0, -0.000042}); + normals.push_back(dl::Vec3f{0.000042, -0, 1}); + normals.push_back(dl::Vec3f{0.000042, 0, 1}); + normals.push_back(dl::Vec3f{0.382645, 0, 0.923896}); + normals.push_back(dl::Vec3f{0.382645, -0, 0.923896}); + normals.push_back(dl::Vec3f{0.382722, -0, 0.923863}); + normals.push_back(dl::Vec3f{0.382722, 0, 0.923863}); + normals.push_back(dl::Vec3f{0.707077, 0, 0.707136}); + normals.push_back(dl::Vec3f{0.707077, -0, 0.707136}); + normals.push_back(dl::Vec3f{0.707136, -0, 0.707077}); + normals.push_back(dl::Vec3f{0.707136, 0, 0.707077}); + normals.push_back(dl::Vec3f{0.923863, 0, 0.382722}); + normals.push_back(dl::Vec3f{0.923863, -0, 0.382722}); + normals.push_back(dl::Vec3f{0.923896, -0, 0.382645}); + normals.push_back(dl::Vec3f{0.923896, 0, 0.382645}); + normals.push_back(dl::Vec3f{1, 0, 0.000042}); + normals.push_back(dl::Vec3f{1, -0, 0.000042}); + normals.push_back(dl::Vec3f{0.000042, -1, -0}); + normals.push_back(dl::Vec3f{0.000042, -1, 0}); + normals.push_back(dl::Vec3f{0.382645, -0.923896, 0}); + normals.push_back(dl::Vec3f{0.382645, -0.923896, -0}); + normals.push_back(dl::Vec3f{0.382722, -0.923863, -0}); + normals.push_back(dl::Vec3f{0.382722, -0.923863, 0}); + normals.push_back(dl::Vec3f{0.707077, -0.707136, 0}); + normals.push_back(dl::Vec3f{0.707077, -0.707136, -0}); + normals.push_back(dl::Vec3f{0.707136, -0.707077, -0}); + normals.push_back(dl::Vec3f{0.707136, -0.707077, 0}); + normals.push_back(dl::Vec3f{0.923863, -0.382722, 0}); + normals.push_back(dl::Vec3f{0.923863, -0.382722, -0}); + normals.push_back(dl::Vec3f{0.923896, -0.382645, -0}); + normals.push_back(dl::Vec3f{0.923896, -0.382645, 0}); + normals.push_back(dl::Vec3f{1, -0.000042, 0}); + normals.push_back(dl::Vec3f{1, -0.000042, -0}); + normals.push_back(dl::Vec3f{0, -0.000042, -1}); + normals.push_back(dl::Vec3f{-0, -0.000042, -1}); + normals.push_back(dl::Vec3f{-0, -0.382645, -0.923896}); + normals.push_back(dl::Vec3f{0, -0.382645, -0.923896}); + normals.push_back(dl::Vec3f{0, -0.382722, -0.923863}); + normals.push_back(dl::Vec3f{-0, -0.382722, -0.923863}); + normals.push_back(dl::Vec3f{-0, -0.707077, -0.707136}); + normals.push_back(dl::Vec3f{0, -0.707077, -0.707136}); + normals.push_back(dl::Vec3f{0, -0.707136, -0.707077}); + normals.push_back(dl::Vec3f{-0, -0.707136, -0.707077}); + normals.push_back(dl::Vec3f{-0, -0.923863, -0.382722}); + normals.push_back(dl::Vec3f{0, -0.923863, -0.382722}); + normals.push_back(dl::Vec3f{0, -0.923896, -0.382645}); + normals.push_back(dl::Vec3f{-0, -0.923896, -0.382645}); + normals.push_back(dl::Vec3f{-0, -1, -0.000042}); + normals.push_back(dl::Vec3f{0, -1, -0.000042}); + normals.push_back(dl::Vec3f{-0, -0.000042, 1}); + normals.push_back(dl::Vec3f{0, -0.000042, 1}); + normals.push_back(dl::Vec3f{0, -0.382645, 0.923896}); + normals.push_back(dl::Vec3f{-0, -0.382645, 0.923896}); + normals.push_back(dl::Vec3f{-0, -0.382722, 0.923863}); + normals.push_back(dl::Vec3f{0, -0.382722, 0.923863}); + normals.push_back(dl::Vec3f{0, -0.707077, 0.707136}); + normals.push_back(dl::Vec3f{-0, -0.707077, 0.707136}); + normals.push_back(dl::Vec3f{-0, -0.707136, 0.707077}); + normals.push_back(dl::Vec3f{0, -0.707136, 0.707077}); + normals.push_back(dl::Vec3f{0, -0.923863, 0.382722}); + normals.push_back(dl::Vec3f{-0, -0.923863, 0.382722}); + normals.push_back(dl::Vec3f{-0, -0.923896, 0.382645}); + normals.push_back(dl::Vec3f{0, -0.923896, 0.382645}); + normals.push_back(dl::Vec3f{0, -1, 0.000042}); + normals.push_back(dl::Vec3f{-0, -1, 0.000042}); + normals.push_back(dl::Vec3f{0, 0, -1}); + normals.push_back(dl::Vec3f{0, 0, -1}); + normals.push_back(dl::Vec3f{0, 0, -1}); + normals.push_back(dl::Vec3f{0, 0, -1}); + belMeshVoxel["steps"][0]["normals"] = normals; + + dl::ds::Vector uvs; + uvs.push_back(dl::Vec2f{0.410712, 0.785712}); + uvs.push_back(dl::Vec2f{0.589288, 0.785712}); + uvs.push_back(dl::Vec2f{0.589288, 0.964287}); + uvs.push_back(dl::Vec2f{0.410712, 0.964288}); + uvs.push_back(dl::Vec2f{0.410712, 0.535713}); + uvs.push_back(dl::Vec2f{0.589288, 0.535713}); + uvs.push_back(dl::Vec2f{0.589288, 0.714288}); + uvs.push_back(dl::Vec2f{0.410712, 0.714288}); + uvs.push_back(dl::Vec2f{0.660712, 0.535712}); + uvs.push_back(dl::Vec2f{0.839288, 0.535712}); + uvs.push_back(dl::Vec2f{0.839287, 0.714288}); + uvs.push_back(dl::Vec2f{0.660712, 0.714288}); + uvs.push_back(dl::Vec2f{0.410712, 0.035712}); + uvs.push_back(dl::Vec2f{0.589288, 0.035712}); + uvs.push_back(dl::Vec2f{0.589288, 0.214288}); + uvs.push_back(dl::Vec2f{0.410712, 0.214288}); + uvs.push_back(dl::Vec2f{0.410712, 0.285712}); + uvs.push_back(dl::Vec2f{0.589288, 0.285712}); + uvs.push_back(dl::Vec2f{0.589288, 0.464288}); + uvs.push_back(dl::Vec2f{0.410712, 0.464288}); + uvs.push_back(dl::Vec2f{0.160712, 0.714288}); + uvs.push_back(dl::Vec2f{0.160712, 0.727954}); + uvs.push_back(dl::Vec2f{0.1467, 0.728297}); + uvs.push_back(dl::Vec2f{0.147046, 0.714288}); + uvs.push_back(dl::Vec2f{0.160712, 0.727954}); + uvs.push_back(dl::Vec2f{0.160712, 0.75}); + uvs.push_back(dl::Vec2f{0.147414, 0.75}); + uvs.push_back(dl::Vec2f{0.1467, 0.728297}); + uvs.push_back(dl::Vec2f{0.147046, 0.714288}); + uvs.push_back(dl::Vec2f{0.1467, 0.728297}); + uvs.push_back(dl::Vec2f{0.125, 0.727586}); + uvs.push_back(dl::Vec2f{0.125, 0.714288}); + uvs.push_back(dl::Vec2f{0.1467, 0.728297}); + uvs.push_back(dl::Vec2f{0.147414, 0.75}); + uvs.push_back(dl::Vec2f{0.140094, 0.75}); + uvs.push_back(dl::Vec2f{0.125, 0.727586}); + uvs.push_back(dl::Vec2f{0.410712, 0.964288}); + uvs.push_back(dl::Vec2f{0.410712, 0.977954}); + uvs.push_back(dl::Vec2f{0.3967, 0.978297}); + uvs.push_back(dl::Vec2f{0.397046, 0.964288}); + uvs.push_back(dl::Vec2f{0.410712, 0.977954}); + uvs.push_back(dl::Vec2f{0.410712, 1}); + uvs.push_back(dl::Vec2f{0.397414, 1}); + uvs.push_back(dl::Vec2f{0.3967, 0.978297}); + uvs.push_back(dl::Vec2f{0.397046, 0.964288}); + uvs.push_back(dl::Vec2f{0.3967, 0.978297}); + uvs.push_back(dl::Vec2f{0.375, 0.977586}); + uvs.push_back(dl::Vec2f{0.375, 0.964288}); + uvs.push_back(dl::Vec2f{0.3967, 0.978297}); + uvs.push_back(dl::Vec2f{0.397414, 1}); + uvs.push_back(dl::Vec2f{0.390094, 1}); + uvs.push_back(dl::Vec2f{0.375, 0.977586}); + uvs.push_back(dl::Vec2f{0.410712, 0.035712}); + uvs.push_back(dl::Vec2f{0.397046, 0.035712}); + uvs.push_back(dl::Vec2f{0.3967, 0.0217}); + uvs.push_back(dl::Vec2f{0.410712, 0.022046}); + uvs.push_back(dl::Vec2f{0.397046, 0.035712}); + uvs.push_back(dl::Vec2f{0.375, 0.035712}); + uvs.push_back(dl::Vec2f{0.375, 0.022414}); + uvs.push_back(dl::Vec2f{0.3967, 0.0217}); + uvs.push_back(dl::Vec2f{0.410712, 0.022046}); + uvs.push_back(dl::Vec2f{0.3967, 0.0217}); + uvs.push_back(dl::Vec2f{0.397414, 0}); + uvs.push_back(dl::Vec2f{0.410712, 0}); + uvs.push_back(dl::Vec2f{0.3967, 0.0217}); + uvs.push_back(dl::Vec2f{0.375, 0.022414}); + uvs.push_back(dl::Vec2f{0.375, 0.015094}); + uvs.push_back(dl::Vec2f{0.397414, 0}); + uvs.push_back(dl::Vec2f{0.589288, 0.964287}); + uvs.push_back(dl::Vec2f{0.602954, 0.964288}); + uvs.push_back(dl::Vec2f{0.603297, 0.978297}); + uvs.push_back(dl::Vec2f{0.589288, 0.977954}); + uvs.push_back(dl::Vec2f{0.602954, 0.964288}); + uvs.push_back(dl::Vec2f{0.625, 0.964288}); + uvs.push_back(dl::Vec2f{0.625, 0.977586}); + uvs.push_back(dl::Vec2f{0.603297, 0.978297}); + uvs.push_back(dl::Vec2f{0.589288, 0.977954}); + uvs.push_back(dl::Vec2f{0.603297, 0.978297}); + uvs.push_back(dl::Vec2f{0.602586, 1}); + uvs.push_back(dl::Vec2f{0.589288, 1}); + uvs.push_back(dl::Vec2f{0.603297, 0.978297}); + uvs.push_back(dl::Vec2f{0.625, 0.977586}); + uvs.push_back(dl::Vec2f{0.625, 0.9849}); + uvs.push_back(dl::Vec2f{0.602586, 1}); + uvs.push_back(dl::Vec2f{0.839287, 0.714288}); + uvs.push_back(dl::Vec2f{0.852954, 0.714288}); + uvs.push_back(dl::Vec2f{0.853297, 0.728297}); + uvs.push_back(dl::Vec2f{0.839288, 0.727954}); + uvs.push_back(dl::Vec2f{0.852954, 0.714288}); + uvs.push_back(dl::Vec2f{0.875, 0.714288}); + uvs.push_back(dl::Vec2f{0.875, 0.727586}); + uvs.push_back(dl::Vec2f{0.853297, 0.728297}); + uvs.push_back(dl::Vec2f{0.839288, 0.727954}); + uvs.push_back(dl::Vec2f{0.853297, 0.728297}); + uvs.push_back(dl::Vec2f{0.852586, 0.75}); + uvs.push_back(dl::Vec2f{0.839288, 0.75}); + uvs.push_back(dl::Vec2f{0.853297, 0.728297}); + uvs.push_back(dl::Vec2f{0.875, 0.727586}); + uvs.push_back(dl::Vec2f{0.875, 0.7349}); + uvs.push_back(dl::Vec2f{0.852586, 0.75}); + uvs.push_back(dl::Vec2f{0.589288, 0.035712}); + uvs.push_back(dl::Vec2f{0.589288, 0.022046}); + uvs.push_back(dl::Vec2f{0.603297, 0.0217}); + uvs.push_back(dl::Vec2f{0.602954, 0.035712}); + uvs.push_back(dl::Vec2f{0.589288, 0.022046}); + uvs.push_back(dl::Vec2f{0.589287, 0}); + uvs.push_back(dl::Vec2f{0.602586, 0}); + uvs.push_back(dl::Vec2f{0.603297, 0.0217}); + uvs.push_back(dl::Vec2f{0.602954, 0.035712}); + uvs.push_back(dl::Vec2f{0.603297, 0.0217}); + uvs.push_back(dl::Vec2f{0.625, 0.022414}); + uvs.push_back(dl::Vec2f{0.625, 0.035712}); + uvs.push_back(dl::Vec2f{0.603297, 0.0217}); + uvs.push_back(dl::Vec2f{0.602586, 0}); + uvs.push_back(dl::Vec2f{0.6099, 0}); + uvs.push_back(dl::Vec2f{0.625, 0.022414}); + uvs.push_back(dl::Vec2f{0.160712, 0.535712}); + uvs.push_back(dl::Vec2f{0.147046, 0.535712}); + uvs.push_back(dl::Vec2f{0.1467, 0.5217}); + uvs.push_back(dl::Vec2f{0.160712, 0.522046}); + uvs.push_back(dl::Vec2f{0.147046, 0.535712}); + uvs.push_back(dl::Vec2f{0.125, 0.535712}); + uvs.push_back(dl::Vec2f{0.125, 0.522414}); + uvs.push_back(dl::Vec2f{0.1467, 0.5217}); + uvs.push_back(dl::Vec2f{0.160712, 0.522046}); + uvs.push_back(dl::Vec2f{0.1467, 0.5217}); + uvs.push_back(dl::Vec2f{0.147414, 0.5}); + uvs.push_back(dl::Vec2f{0.160712, 0.5}); + uvs.push_back(dl::Vec2f{0.1467, 0.5217}); + uvs.push_back(dl::Vec2f{0.125, 0.522414}); + uvs.push_back(dl::Vec2f{0.125, 0.515094}); + uvs.push_back(dl::Vec2f{0.147414, 0.5}); + uvs.push_back(dl::Vec2f{0.410712, 0.214288}); + uvs.push_back(dl::Vec2f{0.410712, 0.227954}); + uvs.push_back(dl::Vec2f{0.3967, 0.228297}); + uvs.push_back(dl::Vec2f{0.397046, 0.214288}); + uvs.push_back(dl::Vec2f{0.410712, 0.227954}); + uvs.push_back(dl::Vec2f{0.410712, 0.25}); + uvs.push_back(dl::Vec2f{0.397414, 0.25}); + uvs.push_back(dl::Vec2f{0.3967, 0.228297}); + uvs.push_back(dl::Vec2f{0.397046, 0.214288}); + uvs.push_back(dl::Vec2f{0.3967, 0.228297}); + uvs.push_back(dl::Vec2f{0.375, 0.227586}); + uvs.push_back(dl::Vec2f{0.375, 0.214288}); + uvs.push_back(dl::Vec2f{0.3967, 0.228297}); + uvs.push_back(dl::Vec2f{0.397414, 0.25}); + uvs.push_back(dl::Vec2f{0.390094, 0.25}); + uvs.push_back(dl::Vec2f{0.375, 0.227586}); + uvs.push_back(dl::Vec2f{0.410712, 0.285712}); + uvs.push_back(dl::Vec2f{0.397046, 0.285712}); + uvs.push_back(dl::Vec2f{0.3967, 0.2717}); + uvs.push_back(dl::Vec2f{0.410712, 0.272046}); + uvs.push_back(dl::Vec2f{0.397046, 0.285712}); + uvs.push_back(dl::Vec2f{0.375, 0.285712}); + uvs.push_back(dl::Vec2f{0.375, 0.272414}); + uvs.push_back(dl::Vec2f{0.3967, 0.2717}); + uvs.push_back(dl::Vec2f{0.410712, 0.272046}); + uvs.push_back(dl::Vec2f{0.3967, 0.2717}); + uvs.push_back(dl::Vec2f{0.397414, 0.25}); + uvs.push_back(dl::Vec2f{0.410712, 0.25}); + uvs.push_back(dl::Vec2f{0.3967, 0.2717}); + uvs.push_back(dl::Vec2f{0.375, 0.272414}); + uvs.push_back(dl::Vec2f{0.375, 0.265094}); + uvs.push_back(dl::Vec2f{0.397414, 0.25}); + uvs.push_back(dl::Vec2f{0.839288, 0.535712}); + uvs.push_back(dl::Vec2f{0.839288, 0.522046}); + uvs.push_back(dl::Vec2f{0.853297, 0.5217}); + uvs.push_back(dl::Vec2f{0.852954, 0.535712}); + uvs.push_back(dl::Vec2f{0.839288, 0.522046}); + uvs.push_back(dl::Vec2f{0.839288, 0.5}); + uvs.push_back(dl::Vec2f{0.852586, 0.5}); + uvs.push_back(dl::Vec2f{0.853297, 0.5217}); + uvs.push_back(dl::Vec2f{0.852954, 0.535712}); + uvs.push_back(dl::Vec2f{0.853297, 0.5217}); + uvs.push_back(dl::Vec2f{0.875, 0.522414}); + uvs.push_back(dl::Vec2f{0.875, 0.535712}); + uvs.push_back(dl::Vec2f{0.853297, 0.5217}); + uvs.push_back(dl::Vec2f{0.852586, 0.5}); + uvs.push_back(dl::Vec2f{0.8599, 0.5}); + uvs.push_back(dl::Vec2f{0.875, 0.522414}); + uvs.push_back(dl::Vec2f{0.589288, 0.285712}); + uvs.push_back(dl::Vec2f{0.589288, 0.272046}); + uvs.push_back(dl::Vec2f{0.603297, 0.2717}); + uvs.push_back(dl::Vec2f{0.602954, 0.285712}); + uvs.push_back(dl::Vec2f{0.589288, 0.272046}); + uvs.push_back(dl::Vec2f{0.589288, 0.25}); + uvs.push_back(dl::Vec2f{0.602586, 0.25}); + uvs.push_back(dl::Vec2f{0.603297, 0.2717}); + uvs.push_back(dl::Vec2f{0.602954, 0.285712}); + uvs.push_back(dl::Vec2f{0.603297, 0.2717}); + uvs.push_back(dl::Vec2f{0.625, 0.272414}); + uvs.push_back(dl::Vec2f{0.625, 0.285712}); + uvs.push_back(dl::Vec2f{0.603297, 0.2717}); + uvs.push_back(dl::Vec2f{0.602586, 0.25}); + uvs.push_back(dl::Vec2f{0.6099, 0.25}); + uvs.push_back(dl::Vec2f{0.625, 0.272414}); + uvs.push_back(dl::Vec2f{0.589288, 0.214288}); + uvs.push_back(dl::Vec2f{0.602954, 0.214288}); + uvs.push_back(dl::Vec2f{0.603297, 0.228297}); + uvs.push_back(dl::Vec2f{0.589288, 0.227954}); + uvs.push_back(dl::Vec2f{0.602954, 0.214288}); + uvs.push_back(dl::Vec2f{0.625, 0.214288}); + uvs.push_back(dl::Vec2f{0.625, 0.227586}); + uvs.push_back(dl::Vec2f{0.603297, 0.228297}); + uvs.push_back(dl::Vec2f{0.589288, 0.227954}); + uvs.push_back(dl::Vec2f{0.603297, 0.228297}); + uvs.push_back(dl::Vec2f{0.602586, 0.25}); + uvs.push_back(dl::Vec2f{0.589288, 0.25}); + uvs.push_back(dl::Vec2f{0.603297, 0.228297}); + uvs.push_back(dl::Vec2f{0.625, 0.227586}); + uvs.push_back(dl::Vec2f{0.625, 0.2349}); + uvs.push_back(dl::Vec2f{0.602586, 0.25}); + uvs.push_back(dl::Vec2f{0.339288, 0.714288}); + uvs.push_back(dl::Vec2f{0.352954, 0.714288}); + uvs.push_back(dl::Vec2f{0.353297, 0.728297}); + uvs.push_back(dl::Vec2f{0.339288, 0.727954}); + uvs.push_back(dl::Vec2f{0.352954, 0.714288}); + uvs.push_back(dl::Vec2f{0.375, 0.714288}); + uvs.push_back(dl::Vec2f{0.375, 0.727586}); + uvs.push_back(dl::Vec2f{0.353297, 0.728297}); + uvs.push_back(dl::Vec2f{0.339288, 0.727954}); + uvs.push_back(dl::Vec2f{0.353297, 0.728297}); + uvs.push_back(dl::Vec2f{0.352586, 0.75}); + uvs.push_back(dl::Vec2f{0.339288, 0.75}); + uvs.push_back(dl::Vec2f{0.353297, 0.728297}); + uvs.push_back(dl::Vec2f{0.375, 0.727586}); + uvs.push_back(dl::Vec2f{0.380031, 0.75}); + uvs.push_back(dl::Vec2f{0.352586, 0.75}); + uvs.push_back(dl::Vec2f{0.410712, 0.714288}); + uvs.push_back(dl::Vec2f{0.410712, 0.727954}); + uvs.push_back(dl::Vec2f{0.3967, 0.728297}); + uvs.push_back(dl::Vec2f{0.397046, 0.714288}); + uvs.push_back(dl::Vec2f{0.410712, 0.727954}); + uvs.push_back(dl::Vec2f{0.410712, 0.75}); + uvs.push_back(dl::Vec2f{0.397414, 0.75}); + uvs.push_back(dl::Vec2f{0.3967, 0.728297}); + uvs.push_back(dl::Vec2f{0.397046, 0.714288}); + uvs.push_back(dl::Vec2f{0.3967, 0.728297}); + uvs.push_back(dl::Vec2f{0.375, 0.727586}); + uvs.push_back(dl::Vec2f{0.375, 0.714288}); + uvs.push_back(dl::Vec2f{0.3967, 0.728297}); + uvs.push_back(dl::Vec2f{0.397414, 0.75}); + uvs.push_back(dl::Vec2f{0.380031, 0.75}); + uvs.push_back(dl::Vec2f{0.375, 0.727586}); + uvs.push_back(dl::Vec2f{0.410712, 0.785712}); + uvs.push_back(dl::Vec2f{0.397046, 0.785712}); + uvs.push_back(dl::Vec2f{0.3967, 0.7717}); + uvs.push_back(dl::Vec2f{0.410712, 0.772046}); + uvs.push_back(dl::Vec2f{0.397046, 0.785712}); + uvs.push_back(dl::Vec2f{0.375, 0.785712}); + uvs.push_back(dl::Vec2f{0.375, 0.772414}); + uvs.push_back(dl::Vec2f{0.3967, 0.7717}); + uvs.push_back(dl::Vec2f{0.410712, 0.772046}); + uvs.push_back(dl::Vec2f{0.3967, 0.7717}); + uvs.push_back(dl::Vec2f{0.397414, 0.75}); + uvs.push_back(dl::Vec2f{0.410712, 0.75}); + uvs.push_back(dl::Vec2f{0.3967, 0.7717}); + uvs.push_back(dl::Vec2f{0.375, 0.772414}); + uvs.push_back(dl::Vec2f{0.380031, 0.75}); + uvs.push_back(dl::Vec2f{0.397414, 0.75}); + uvs.push_back(dl::Vec2f{0.660712, 0.714288}); + uvs.push_back(dl::Vec2f{0.660712, 0.727954}); + uvs.push_back(dl::Vec2f{0.6467, 0.728297}); + uvs.push_back(dl::Vec2f{0.647046, 0.714288}); + uvs.push_back(dl::Vec2f{0.660712, 0.727954}); + uvs.push_back(dl::Vec2f{0.660712, 0.75}); + uvs.push_back(dl::Vec2f{0.647414, 0.75}); + uvs.push_back(dl::Vec2f{0.6467, 0.728297}); + uvs.push_back(dl::Vec2f{0.647046, 0.714288}); + uvs.push_back(dl::Vec2f{0.6467, 0.728297}); + uvs.push_back(dl::Vec2f{0.625, 0.727586}); + uvs.push_back(dl::Vec2f{0.625, 0.714288}); + uvs.push_back(dl::Vec2f{0.6467, 0.728297}); + uvs.push_back(dl::Vec2f{0.647414, 0.75}); + uvs.push_back(dl::Vec2f{0.625, 0.744969}); + uvs.push_back(dl::Vec2f{0.625, 0.727586}); + uvs.push_back(dl::Vec2f{0.589288, 0.785712}); + uvs.push_back(dl::Vec2f{0.589288, 0.772046}); + uvs.push_back(dl::Vec2f{0.603297, 0.7717}); + uvs.push_back(dl::Vec2f{0.602954, 0.785712}); + uvs.push_back(dl::Vec2f{0.589288, 0.772046}); + uvs.push_back(dl::Vec2f{0.589288, 0.75}); + uvs.push_back(dl::Vec2f{0.602586, 0.75}); + uvs.push_back(dl::Vec2f{0.603297, 0.7717}); + uvs.push_back(dl::Vec2f{0.602954, 0.785712}); + uvs.push_back(dl::Vec2f{0.603297, 0.7717}); + uvs.push_back(dl::Vec2f{0.625, 0.772414}); + uvs.push_back(dl::Vec2f{0.625, 0.785712}); + uvs.push_back(dl::Vec2f{0.603297, 0.7717}); + uvs.push_back(dl::Vec2f{0.602586, 0.75}); + uvs.push_back(dl::Vec2f{0.625, 0.744969}); + uvs.push_back(dl::Vec2f{0.625, 0.772414}); + uvs.push_back(dl::Vec2f{0.589288, 0.714288}); + uvs.push_back(dl::Vec2f{0.602954, 0.714288}); + uvs.push_back(dl::Vec2f{0.603297, 0.728297}); + uvs.push_back(dl::Vec2f{0.589288, 0.727954}); + uvs.push_back(dl::Vec2f{0.602954, 0.714288}); + uvs.push_back(dl::Vec2f{0.625, 0.714288}); + uvs.push_back(dl::Vec2f{0.625, 0.727586}); + uvs.push_back(dl::Vec2f{0.603297, 0.728297}); + uvs.push_back(dl::Vec2f{0.589288, 0.727954}); + uvs.push_back(dl::Vec2f{0.603297, 0.728297}); + uvs.push_back(dl::Vec2f{0.602586, 0.75}); + uvs.push_back(dl::Vec2f{0.589288, 0.75}); + uvs.push_back(dl::Vec2f{0.603297, 0.728297}); + uvs.push_back(dl::Vec2f{0.625, 0.727586}); + uvs.push_back(dl::Vec2f{0.625, 0.744969}); + uvs.push_back(dl::Vec2f{0.602586, 0.75}); + uvs.push_back(dl::Vec2f{0.339288, 0.535712}); + uvs.push_back(dl::Vec2f{0.339288, 0.522046}); + uvs.push_back(dl::Vec2f{0.353297, 0.5217}); + uvs.push_back(dl::Vec2f{0.352954, 0.535712}); + uvs.push_back(dl::Vec2f{0.339288, 0.522046}); + uvs.push_back(dl::Vec2f{0.339288, 0.5}); + uvs.push_back(dl::Vec2f{0.352586, 0.5}); + uvs.push_back(dl::Vec2f{0.353297, 0.5217}); + uvs.push_back(dl::Vec2f{0.352954, 0.535712}); + uvs.push_back(dl::Vec2f{0.353297, 0.5217}); + uvs.push_back(dl::Vec2f{0.375, 0.522414}); + uvs.push_back(dl::Vec2f{0.375, 0.535712}); + uvs.push_back(dl::Vec2f{0.353297, 0.5217}); + uvs.push_back(dl::Vec2f{0.352586, 0.5}); + uvs.push_back(dl::Vec2f{0.375, 0.505031}); + uvs.push_back(dl::Vec2f{0.375, 0.522414}); + uvs.push_back(dl::Vec2f{0.410712, 0.464288}); + uvs.push_back(dl::Vec2f{0.410712, 0.477954}); + uvs.push_back(dl::Vec2f{0.3967, 0.478297}); + uvs.push_back(dl::Vec2f{0.397046, 0.464288}); + uvs.push_back(dl::Vec2f{0.410712, 0.477954}); + uvs.push_back(dl::Vec2f{0.410712, 0.5}); + uvs.push_back(dl::Vec2f{0.397414, 0.5}); + uvs.push_back(dl::Vec2f{0.3967, 0.478297}); + uvs.push_back(dl::Vec2f{0.397046, 0.464288}); + uvs.push_back(dl::Vec2f{0.3967, 0.478297}); + uvs.push_back(dl::Vec2f{0.375, 0.477586}); + uvs.push_back(dl::Vec2f{0.375, 0.464288}); + uvs.push_back(dl::Vec2f{0.3967, 0.478297}); + uvs.push_back(dl::Vec2f{0.397414, 0.5}); + uvs.push_back(dl::Vec2f{0.375, 0.505031}); + uvs.push_back(dl::Vec2f{0.375, 0.477586}); + uvs.push_back(dl::Vec2f{0.410712, 0.535713}); + uvs.push_back(dl::Vec2f{0.397046, 0.535712}); + uvs.push_back(dl::Vec2f{0.3967, 0.5217}); + uvs.push_back(dl::Vec2f{0.410712, 0.522046}); + uvs.push_back(dl::Vec2f{0.397046, 0.535712}); + uvs.push_back(dl::Vec2f{0.375, 0.535712}); + uvs.push_back(dl::Vec2f{0.375, 0.522414}); + uvs.push_back(dl::Vec2f{0.3967, 0.5217}); + uvs.push_back(dl::Vec2f{0.410712, 0.522046}); + uvs.push_back(dl::Vec2f{0.3967, 0.5217}); + uvs.push_back(dl::Vec2f{0.397414, 0.5}); + uvs.push_back(dl::Vec2f{0.410712, 0.5}); + uvs.push_back(dl::Vec2f{0.3967, 0.5217}); + uvs.push_back(dl::Vec2f{0.375, 0.522414}); + uvs.push_back(dl::Vec2f{0.375, 0.505031}); + uvs.push_back(dl::Vec2f{0.397414, 0.5}); + uvs.push_back(dl::Vec2f{0.660712, 0.535712}); + uvs.push_back(dl::Vec2f{0.647046, 0.535712}); + uvs.push_back(dl::Vec2f{0.6467, 0.5217}); + uvs.push_back(dl::Vec2f{0.660712, 0.522046}); + uvs.push_back(dl::Vec2f{0.647046, 0.535712}); + uvs.push_back(dl::Vec2f{0.625, 0.535712}); + uvs.push_back(dl::Vec2f{0.625, 0.522414}); + uvs.push_back(dl::Vec2f{0.6467, 0.5217}); + uvs.push_back(dl::Vec2f{0.660712, 0.522046}); + uvs.push_back(dl::Vec2f{0.6467, 0.5217}); + uvs.push_back(dl::Vec2f{0.647414, 0.5}); + uvs.push_back(dl::Vec2f{0.660712, 0.5}); + uvs.push_back(dl::Vec2f{0.6467, 0.5217}); + uvs.push_back(dl::Vec2f{0.625, 0.522414}); + uvs.push_back(dl::Vec2f{0.619969, 0.5}); + uvs.push_back(dl::Vec2f{0.647414, 0.5}); + uvs.push_back(dl::Vec2f{0.589288, 0.535713}); + uvs.push_back(dl::Vec2f{0.589288, 0.522046}); + uvs.push_back(dl::Vec2f{0.603297, 0.5217}); + uvs.push_back(dl::Vec2f{0.602954, 0.535712}); + uvs.push_back(dl::Vec2f{0.589288, 0.522046}); + uvs.push_back(dl::Vec2f{0.589288, 0.5}); + uvs.push_back(dl::Vec2f{0.602586, 0.5}); + uvs.push_back(dl::Vec2f{0.603297, 0.5217}); + uvs.push_back(dl::Vec2f{0.602954, 0.535712}); + uvs.push_back(dl::Vec2f{0.603297, 0.5217}); + uvs.push_back(dl::Vec2f{0.625, 0.522414}); + uvs.push_back(dl::Vec2f{0.625, 0.535712}); + uvs.push_back(dl::Vec2f{0.603297, 0.5217}); + uvs.push_back(dl::Vec2f{0.602586, 0.5}); + uvs.push_back(dl::Vec2f{0.619969, 0.5}); + uvs.push_back(dl::Vec2f{0.625, 0.522414}); + uvs.push_back(dl::Vec2f{0.589288, 0.464288}); + uvs.push_back(dl::Vec2f{0.602954, 0.464288}); + uvs.push_back(dl::Vec2f{0.603297, 0.478297}); + uvs.push_back(dl::Vec2f{0.589288, 0.477954}); + uvs.push_back(dl::Vec2f{0.602954, 0.464288}); + uvs.push_back(dl::Vec2f{0.625, 0.464288}); + uvs.push_back(dl::Vec2f{0.625, 0.477586}); + uvs.push_back(dl::Vec2f{0.603297, 0.478297}); + uvs.push_back(dl::Vec2f{0.589288, 0.477954}); + uvs.push_back(dl::Vec2f{0.603297, 0.478297}); + uvs.push_back(dl::Vec2f{0.602586, 0.5}); + uvs.push_back(dl::Vec2f{0.589288, 0.5}); + uvs.push_back(dl::Vec2f{0.603297, 0.478297}); + uvs.push_back(dl::Vec2f{0.625, 0.477586}); + uvs.push_back(dl::Vec2f{0.619969, 0.5}); + uvs.push_back(dl::Vec2f{0.602586, 0.5}); + uvs.push_back(dl::Vec2f{0.160712, 0.535712}); + uvs.push_back(dl::Vec2f{0.160712, 0.714288}); + uvs.push_back(dl::Vec2f{0.147046, 0.714288}); + uvs.push_back(dl::Vec2f{0.147046, 0.535712}); + uvs.push_back(dl::Vec2f{0.147046, 0.535712}); + uvs.push_back(dl::Vec2f{0.147046, 0.714288}); + uvs.push_back(dl::Vec2f{0.125, 0.714288}); + uvs.push_back(dl::Vec2f{0.125, 0.535712}); + uvs.push_back(dl::Vec2f{0.375, 0.214288}); + uvs.push_back(dl::Vec2f{0.375, 0.035712}); + uvs.push_back(dl::Vec2f{0.397046, 0.035712}); + uvs.push_back(dl::Vec2f{0.397046, 0.214288}); + uvs.push_back(dl::Vec2f{0.397046, 0.214288}); + uvs.push_back(dl::Vec2f{0.397046, 0.035712}); + uvs.push_back(dl::Vec2f{0.410712, 0.035712}); + uvs.push_back(dl::Vec2f{0.410712, 0.214288}); + uvs.push_back(dl::Vec2f{0.410712, 0.964288}); + uvs.push_back(dl::Vec2f{0.589288, 0.964287}); + uvs.push_back(dl::Vec2f{0.589288, 0.977954}); + uvs.push_back(dl::Vec2f{0.410712, 0.977954}); + uvs.push_back(dl::Vec2f{0.410712, 0.977954}); + uvs.push_back(dl::Vec2f{0.589288, 0.977954}); + uvs.push_back(dl::Vec2f{0.589288, 1}); + uvs.push_back(dl::Vec2f{0.410712, 1}); + uvs.push_back(dl::Vec2f{0.410712, 0}); + uvs.push_back(dl::Vec2f{0.589287, 0}); + uvs.push_back(dl::Vec2f{0.589288, 0.022046}); + uvs.push_back(dl::Vec2f{0.410712, 0.022046}); + uvs.push_back(dl::Vec2f{0.410712, 0.022046}); + uvs.push_back(dl::Vec2f{0.589288, 0.022046}); + uvs.push_back(dl::Vec2f{0.589288, 0.035712}); + uvs.push_back(dl::Vec2f{0.410712, 0.035712}); + uvs.push_back(dl::Vec2f{0.839287, 0.714288}); + uvs.push_back(dl::Vec2f{0.839288, 0.535712}); + uvs.push_back(dl::Vec2f{0.852954, 0.535712}); + uvs.push_back(dl::Vec2f{0.852954, 0.714288}); + uvs.push_back(dl::Vec2f{0.852954, 0.714288}); + uvs.push_back(dl::Vec2f{0.852954, 0.535712}); + uvs.push_back(dl::Vec2f{0.875, 0.535712}); + uvs.push_back(dl::Vec2f{0.875, 0.714288}); + uvs.push_back(dl::Vec2f{0.625, 0.035712}); + uvs.push_back(dl::Vec2f{0.625, 0.214288}); + uvs.push_back(dl::Vec2f{0.602954, 0.214288}); + uvs.push_back(dl::Vec2f{0.602954, 0.035712}); + uvs.push_back(dl::Vec2f{0.602954, 0.035712}); + uvs.push_back(dl::Vec2f{0.602954, 0.214288}); + uvs.push_back(dl::Vec2f{0.589288, 0.214288}); + uvs.push_back(dl::Vec2f{0.589288, 0.035712}); + uvs.push_back(dl::Vec2f{0.589288, 0.285712}); + uvs.push_back(dl::Vec2f{0.410712, 0.285712}); + uvs.push_back(dl::Vec2f{0.410712, 0.272046}); + uvs.push_back(dl::Vec2f{0.589288, 0.272046}); + uvs.push_back(dl::Vec2f{0.589288, 0.272046}); + uvs.push_back(dl::Vec2f{0.410712, 0.272046}); + uvs.push_back(dl::Vec2f{0.410712, 0.25}); + uvs.push_back(dl::Vec2f{0.589288, 0.25}); + uvs.push_back(dl::Vec2f{0.589288, 0.25}); + uvs.push_back(dl::Vec2f{0.410712, 0.25}); + uvs.push_back(dl::Vec2f{0.410712, 0.227954}); + uvs.push_back(dl::Vec2f{0.589288, 0.227954}); + uvs.push_back(dl::Vec2f{0.589288, 0.227954}); + uvs.push_back(dl::Vec2f{0.410712, 0.227954}); + uvs.push_back(dl::Vec2f{0.410712, 0.214288}); + uvs.push_back(dl::Vec2f{0.589288, 0.214288}); + uvs.push_back(dl::Vec2f{0.339288, 0.535712}); + uvs.push_back(dl::Vec2f{0.160712, 0.535712}); + uvs.push_back(dl::Vec2f{0.160712, 0.522046}); + uvs.push_back(dl::Vec2f{0.339288, 0.522046}); + uvs.push_back(dl::Vec2f{0.339288, 0.522046}); + uvs.push_back(dl::Vec2f{0.160712, 0.522046}); + uvs.push_back(dl::Vec2f{0.160712, 0.5}); + uvs.push_back(dl::Vec2f{0.339288, 0.5}); + uvs.push_back(dl::Vec2f{0.375, 0.464288}); + uvs.push_back(dl::Vec2f{0.375, 0.285712}); + uvs.push_back(dl::Vec2f{0.397046, 0.285712}); + uvs.push_back(dl::Vec2f{0.397046, 0.464288}); + uvs.push_back(dl::Vec2f{0.397046, 0.464288}); + uvs.push_back(dl::Vec2f{0.397046, 0.285712}); + uvs.push_back(dl::Vec2f{0.410712, 0.285712}); + uvs.push_back(dl::Vec2f{0.410712, 0.464288}); + uvs.push_back(dl::Vec2f{0.839288, 0.535712}); + uvs.push_back(dl::Vec2f{0.660712, 0.535712}); + uvs.push_back(dl::Vec2f{0.660712, 0.522046}); + uvs.push_back(dl::Vec2f{0.839288, 0.522046}); + uvs.push_back(dl::Vec2f{0.839288, 0.522046}); + uvs.push_back(dl::Vec2f{0.660712, 0.522046}); + uvs.push_back(dl::Vec2f{0.660712, 0.5}); + uvs.push_back(dl::Vec2f{0.839288, 0.5}); + uvs.push_back(dl::Vec2f{0.625, 0.285712}); + uvs.push_back(dl::Vec2f{0.625, 0.464288}); + uvs.push_back(dl::Vec2f{0.602954, 0.464288}); + uvs.push_back(dl::Vec2f{0.602954, 0.285712}); + uvs.push_back(dl::Vec2f{0.602954, 0.285712}); + uvs.push_back(dl::Vec2f{0.602954, 0.464288}); + uvs.push_back(dl::Vec2f{0.589288, 0.464288}); + uvs.push_back(dl::Vec2f{0.589288, 0.285712}); + uvs.push_back(dl::Vec2f{0.589288, 0.535713}); + uvs.push_back(dl::Vec2f{0.410712, 0.535713}); + uvs.push_back(dl::Vec2f{0.410712, 0.522046}); + uvs.push_back(dl::Vec2f{0.589288, 0.522046}); + uvs.push_back(dl::Vec2f{0.589288, 0.522046}); + uvs.push_back(dl::Vec2f{0.410712, 0.522046}); + uvs.push_back(dl::Vec2f{0.410712, 0.5}); + uvs.push_back(dl::Vec2f{0.589288, 0.5}); + uvs.push_back(dl::Vec2f{0.589288, 0.5}); + uvs.push_back(dl::Vec2f{0.410712, 0.5}); + uvs.push_back(dl::Vec2f{0.410712, 0.477954}); + uvs.push_back(dl::Vec2f{0.589288, 0.477954}); + uvs.push_back(dl::Vec2f{0.589288, 0.477954}); + uvs.push_back(dl::Vec2f{0.410712, 0.477954}); + uvs.push_back(dl::Vec2f{0.410712, 0.464288}); + uvs.push_back(dl::Vec2f{0.589288, 0.464288}); + uvs.push_back(dl::Vec2f{0.339288, 0.714288}); + uvs.push_back(dl::Vec2f{0.339288, 0.535712}); + uvs.push_back(dl::Vec2f{0.352954, 0.535712}); + uvs.push_back(dl::Vec2f{0.352954, 0.714288}); + uvs.push_back(dl::Vec2f{0.352954, 0.714288}); + uvs.push_back(dl::Vec2f{0.352954, 0.535712}); + uvs.push_back(dl::Vec2f{0.375, 0.535712}); + uvs.push_back(dl::Vec2f{0.375, 0.714288}); + uvs.push_back(dl::Vec2f{0.375, 0.714288}); + uvs.push_back(dl::Vec2f{0.375, 0.535712}); + uvs.push_back(dl::Vec2f{0.397046, 0.535712}); + uvs.push_back(dl::Vec2f{0.397046, 0.714288}); + uvs.push_back(dl::Vec2f{0.397046, 0.714288}); + uvs.push_back(dl::Vec2f{0.397046, 0.535712}); + uvs.push_back(dl::Vec2f{0.410712, 0.535713}); + uvs.push_back(dl::Vec2f{0.410712, 0.714288}); + uvs.push_back(dl::Vec2f{0.660712, 0.535712}); + uvs.push_back(dl::Vec2f{0.660712, 0.714288}); + uvs.push_back(dl::Vec2f{0.647046, 0.714288}); + uvs.push_back(dl::Vec2f{0.647046, 0.535712}); + uvs.push_back(dl::Vec2f{0.647046, 0.535712}); + uvs.push_back(dl::Vec2f{0.647046, 0.714288}); + uvs.push_back(dl::Vec2f{0.625, 0.714288}); + uvs.push_back(dl::Vec2f{0.625, 0.535712}); + uvs.push_back(dl::Vec2f{0.625, 0.535712}); + uvs.push_back(dl::Vec2f{0.625, 0.714288}); + uvs.push_back(dl::Vec2f{0.602954, 0.714288}); + uvs.push_back(dl::Vec2f{0.602954, 0.535712}); + uvs.push_back(dl::Vec2f{0.602954, 0.535712}); + uvs.push_back(dl::Vec2f{0.602954, 0.714288}); + uvs.push_back(dl::Vec2f{0.589288, 0.714288}); + uvs.push_back(dl::Vec2f{0.589288, 0.535713}); + uvs.push_back(dl::Vec2f{0.589288, 0.785712}); + uvs.push_back(dl::Vec2f{0.410712, 0.785712}); + uvs.push_back(dl::Vec2f{0.410712, 0.772046}); + uvs.push_back(dl::Vec2f{0.589288, 0.772046}); + uvs.push_back(dl::Vec2f{0.589288, 0.772046}); + uvs.push_back(dl::Vec2f{0.410712, 0.772046}); + uvs.push_back(dl::Vec2f{0.410712, 0.75}); + uvs.push_back(dl::Vec2f{0.589288, 0.75}); + uvs.push_back(dl::Vec2f{0.589288, 0.75}); + uvs.push_back(dl::Vec2f{0.410712, 0.75}); + uvs.push_back(dl::Vec2f{0.410712, 0.727954}); + uvs.push_back(dl::Vec2f{0.589288, 0.727954}); + uvs.push_back(dl::Vec2f{0.589288, 0.727954}); + uvs.push_back(dl::Vec2f{0.410712, 0.727954}); + uvs.push_back(dl::Vec2f{0.410712, 0.714288}); + uvs.push_back(dl::Vec2f{0.589288, 0.714288}); + uvs.push_back(dl::Vec2f{0.160712, 0.714288}); + uvs.push_back(dl::Vec2f{0.339288, 0.714288}); + uvs.push_back(dl::Vec2f{0.339288, 0.727954}); + uvs.push_back(dl::Vec2f{0.160712, 0.727954}); + uvs.push_back(dl::Vec2f{0.160712, 0.727954}); + uvs.push_back(dl::Vec2f{0.339288, 0.727954}); + uvs.push_back(dl::Vec2f{0.339288, 0.75}); + uvs.push_back(dl::Vec2f{0.160712, 0.75}); + uvs.push_back(dl::Vec2f{0.375, 0.964288}); + uvs.push_back(dl::Vec2f{0.375, 0.785712}); + uvs.push_back(dl::Vec2f{0.397046, 0.785712}); + uvs.push_back(dl::Vec2f{0.397046, 0.964288}); + uvs.push_back(dl::Vec2f{0.397046, 0.964288}); + uvs.push_back(dl::Vec2f{0.397046, 0.785712}); + uvs.push_back(dl::Vec2f{0.410712, 0.785712}); + uvs.push_back(dl::Vec2f{0.410712, 0.964288}); + uvs.push_back(dl::Vec2f{0.660712, 0.714288}); + uvs.push_back(dl::Vec2f{0.839287, 0.714288}); + uvs.push_back(dl::Vec2f{0.839288, 0.727954}); + uvs.push_back(dl::Vec2f{0.660712, 0.727954}); + uvs.push_back(dl::Vec2f{0.660712, 0.727954}); + uvs.push_back(dl::Vec2f{0.839288, 0.727954}); + uvs.push_back(dl::Vec2f{0.839288, 0.75}); + uvs.push_back(dl::Vec2f{0.660712, 0.75}); + uvs.push_back(dl::Vec2f{0.625, 0.785712}); + uvs.push_back(dl::Vec2f{0.625, 0.964288}); + uvs.push_back(dl::Vec2f{0.602954, 0.964288}); + uvs.push_back(dl::Vec2f{0.602954, 0.785712}); + uvs.push_back(dl::Vec2f{0.602954, 0.785712}); + uvs.push_back(dl::Vec2f{0.602954, 0.964288}); + uvs.push_back(dl::Vec2f{0.589288, 0.964287}); + uvs.push_back(dl::Vec2f{0.589288, 0.785712}); + uvs.push_back(dl::Vec2f{0.160712, 0.535712}); + uvs.push_back(dl::Vec2f{0.339288, 0.535712}); + uvs.push_back(dl::Vec2f{0.339288, 0.714288}); + uvs.push_back(dl::Vec2f{0.160712, 0.714288}); + belMeshVoxel["steps"][0]["uvs"] = uvs; + + dl::ds::Vector points; + points.push_back(dl::Pos3f{0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.435228, -0.435228, -0.435228}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.435228, -0.435228, -0.435228}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.435228, -0.435228, -0.435228}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.435228, -0.435228, 0.435228}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.435228, -0.435228, 0.435228}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.435228, -0.435228, 0.435228}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.435228, 0.435228, -0.435228}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.435228, 0.435228, -0.435228}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.435228, 0.435228, -0.435228}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.435228, 0.435228, 0.435228}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.435228, 0.435228, 0.435228}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.435228, 0.435228, 0.435228}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.435228, -0.435228, -0.435228}); + points.push_back(dl::Pos3f{0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.435228, -0.435228, -0.435228}); + points.push_back(dl::Pos3f{0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.435228, -0.435228, -0.435228}); + points.push_back(dl::Pos3f{0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.435228, -0.435228, 0.435228}); + points.push_back(dl::Pos3f{0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.435228, -0.435228, 0.435228}); + points.push_back(dl::Pos3f{0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.435228, -0.435228, 0.435228}); + points.push_back(dl::Pos3f{0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.435228, 0.435228, -0.435228}); + points.push_back(dl::Pos3f{0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.435228, 0.435228, -0.435228}); + points.push_back(dl::Pos3f{0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.435228, 0.435228, -0.435228}); + points.push_back(dl::Pos3f{0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.435228, 0.435228, 0.435228}); + points.push_back(dl::Pos3f{0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.435228, 0.435228, 0.435228}); + points.push_back(dl::Pos3f{0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.435228, 0.435228, 0.435228}); + points.push_back(dl::Pos3f{0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, -0.495}); + belMeshVoxel["steps"][0]["points"] = points; 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 +// 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 // all_of, find, for_each +#include // nullptr_t, ptrdiff_t, size_t +#include // hash, less +#include // initializer_list +#ifndef JSON_NO_IO + #include // istream, ostream +#endif // JSON_NO_IO +#include // random_access_iterator_tag +#include // unique_ptr +#include // string, stoi, to_string +#include // declval, forward, move, pair, swap +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// 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 +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // transform +#include // array +#include // forward_list +#include // inserter, front_inserter, end +#include // map +#include // string +#include // tuple, make_tuple +#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible +#include // unordered_map +#include // pair, declval +#include // valarray + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // nullptr_t +#include // exception +#if JSON_DIAGNOSTICS + #include // accumulate +#endif +#include // runtime_error +#include // to_string +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // uint8_t +#include // string + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // declval, pair +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template struct make_void +{ + using type = void; +}; +template using void_t = typename make_void::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 Op, + class... Args> +struct detector +{ + using value_t = std::false_type; + using type = Default; +}; + +template class Op, class... Args> +struct detector>, Op, Args...> +{ + using value_t = std::true_type; + using type = Op; +}; + +template class Op, class... Args> +using is_detected = typename detector::value_t; + +template class Op, class... Args> +struct is_detected_lazy : is_detected { }; + +template class Op, class... Args> +using detected_t = typename detector::type; + +template class Op, class... Args> +using detected_or = detector; + +template class Op, class... Args> +using detected_or_t = typename detected_or::type; + +template class Op, class... Args> +using is_detected_exact = std::is_same>; + +template class Op, class... Args> +using is_detected_convertible = + std::is_convertible, To>; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + + +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson +// SPDX-License-Identifier: MIT + +/* Hedley - https://nemequ.github.io/hedley + * Created by Evan Nemerson + */ + +#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(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(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(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 + #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 + #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 + + +// 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() + #include + #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() + #define JSON_HAS_FILESYSTEM 1 + #elif __has_include() + #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 + #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 // 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 \ + inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ + { \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [e](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.first == e; \ + }); \ + j = ((it != std::end(m)) ? it : std::begin(m))->second; \ + } \ + template \ + inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ + { \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [&j](const std::pair& 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 class ObjectType, \ + template class ArrayType, \ + class StringType, class BooleanType, class NumberIntegerType, \ + class NumberUnsignedType, class NumberFloatType, \ + template class AllocatorType, \ + template class JSONSerializer, \ + class BinaryType, \ + class CustomBaseClass> + +#define NLOHMANN_BASIC_JSON_TPL \ + basic_json + +// 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 \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + } \ + \ + namespace detail2 { \ + struct std_name##_tag \ + { \ + }; \ + \ + template \ + std_name##_tag std_name(T&&...); \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + \ + template \ + struct would_call_std_##std_name \ + { \ + static constexpr auto const value = ::nlohmann::detail:: \ + is_detected_exact::value; \ + }; \ + } /* namespace detail2 */ \ + \ + template \ + struct would_call_std_##std_name : detail2::would_call_std_##std_name \ + { \ + } + +#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 // 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 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(lhs); + const auto r_index = static_cast(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 +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +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 +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 +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 +static void unescape(StringType& s) +{ + replace_substring(s, StringType{"~1"}, StringType{"/"}); + replace_substring(s, StringType{"~0"}, StringType{"~"}); +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // size_t + +// #include + + +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 + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-FileCopyrightText: 2018 The Abseil Authors +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type +#include // index_sequence, make_index_sequence, index_sequence_for + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +using uncvref_t = typename std::remove_cv::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 +using enable_if_t = typename std::enable_if::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` 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); +// +// 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()); +// } +template +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 +using index_sequence = integer_sequence; + +namespace utility_internal +{ + +template +struct Extend; + +// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. +template +struct Extend, SeqSize, 0> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; +}; + +template +struct Extend, SeqSize, 1> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; +}; + +// Recursion helper for 'make_integer_sequence'. +// 'Gen::type' is an alias for 'integer_sequence'. +template +struct Gen +{ + using type = + typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; +}; + +template +struct Gen +{ + using type = integer_sequence; +}; + +} // namespace utility_internal + +// Compile-time sequences of integers + +// make_integer_sequence +// +// This template alias is equivalent to +// `integer_sequence`, and is designed to be a drop-in +// replacement for C++14's `std::make_integer_sequence`. +template +using make_integer_sequence = typename utility_internal::Gen::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 +using make_index_sequence = make_integer_sequence; + +// 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 +using index_sequence_for = make_index_sequence; + +//// END OF CODE FROM GOOGLE ABSEIL + +#endif + +// dispatch utility (taken from ranges-v3) +template struct priority_tag : priority_tag < N - 1 > {}; +template<> struct priority_tag<0> {}; + +// taken from ranges-v3 +template +struct static_const +{ + static JSON_INLINE_VARIABLE constexpr T value{}; +}; + +#ifndef JSON_HAS_CPP_17 + template + constexpr T static_const::value; +#endif + +template +inline constexpr std::array make_array(Args&& ... args) +{ + return std::array {{static_cast(std::forward(args))...}}; +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // numeric_limits +#include // false_type, is_constructible, is_integral, is_same, true_type +#include // declval +#include // tuple +#include // char_traits + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // random_access_iterator_tag + +// #include + +// #include + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +struct iterator_types {}; + +template +struct iterator_types < + It, + void_t> +{ + 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 +struct iterator_traits +{ +}; + +template +struct iterator_traits < T, enable_if_t < !std::is_pointer::value >> + : iterator_types +{ +}; + +template +struct iterator_traits::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 + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); + +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); + +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_ + #define INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + #include // int64_t, uint64_t + #include // map + #include // allocator + #include // string + #include // vector + + // #include + + + /*! + @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 + struct adl_serializer; + + /// a class to store JSON values + /// @sa https://json.nlohmann.me/api/basic_json/ + template class ObjectType = + std::map, + template 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 class AllocatorType = std::allocator, + template class JSONSerializer = + adl_serializer, + class BinaryType = std::vector, // 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 + 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 + 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_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()))) +// +// In this case, T has to be properly CV-qualified to constraint the function arguments +// (e.g. to_json(BasicJsonType&, const T&)) + +template struct is_basic_json : std::false_type {}; + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +struct is_basic_json : 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 +struct is_basic_json_context : + std::integral_constant < bool, + is_basic_json::type>::type>::value + || std::is_same::value > +{}; + +////////////////////// +// json_ref helpers // +////////////////////// + +template +class json_ref; + +template +struct is_json_ref : std::false_type {}; + +template +struct is_json_ref> : std::true_type {}; + +////////////////////////// +// aliases for detected // +////////////////////////// + +template +using mapped_type_t = typename T::mapped_type; + +template +using key_type_t = typename T::key_type; + +template +using value_type_t = typename T::value_type; + +template +using difference_type_t = typename T::difference_type; + +template +using pointer_t = typename T::pointer; + +template +using reference_t = typename T::reference; + +template +using iterator_category_t = typename T::iterator_category; + +template +using to_json_function = decltype(T::to_json(std::declval()...)); + +template +using from_json_function = decltype(T::from_json(std::declval()...)); + +template +using get_template_function = decltype(std::declval().template get()); + +// trait checking if JSONSerializer::from_json(json const&, udt&) exists +template +struct has_from_json : std::false_type {}; + +// trait checking if j.get 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 +struct is_getable +{ + static constexpr bool value = is_detected::value; +}; + +template +struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if JSONSerializer::from_json(json const&) exists +// this overload is used for non-default-constructible user-defined-types +template +struct has_non_default_from_json : std::false_type {}; + +template +struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if BasicJsonType::json_serializer::to_json exists +// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. +template +struct has_to_json : std::false_type {}; + +template +struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +template +using detect_key_compare = typename T::key_compare; + +template +struct has_key_compare : std::integral_constant::value> {}; + +// obtains the actual object key comparator +template +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::value, + typename object_t::key_compare, object_comparator_t>::type; +}; + +template +using actual_object_comparator_t = typename actual_object_comparator::type; + +///////////////// +// char_traits // +///////////////// + +// Primary template of char_traits calls std char_traits +template +struct char_traits : std::char_traits +{}; + +// Explicitly define char traits for unsigned char since it is not standard +template<> +struct char_traits : std::char_traits +{ + 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(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(EOF); + } +}; + +// Explicitly define char traits for signed char since it is not standard +template<> +struct char_traits : std::char_traits +{ + 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(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(EOF); + } +}; + +/////////////////// +// is_ functions // +/////////////////// + +// https://en.cppreference.com/w/cpp/types/conjunction +template struct conjunction : std::true_type { }; +template struct conjunction : B { }; +template +struct conjunction +: std::conditional(B::value), conjunction, B>::type {}; + +// https://en.cppreference.com/w/cpp/types/negation +template 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 +struct is_default_constructible : std::is_default_constructible {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_constructible : std::is_constructible {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_iterator_traits : std::false_type {}; + +template +struct is_iterator_traits> +{ + private: + using traits = iterator_traits; + + public: + static constexpr auto value = + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value; +}; + +template +struct is_range +{ + private: + using t_ref = typename std::add_lvalue_reference::type; + + using iterator = detected_t; + using sentinel = detected_t; + + // 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>::value; + + public: + static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin; +}; + +template +using iterator_t = enable_if_t::value, result_of_begin())>>; + +template +using range_value_t = value_type_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 +struct is_complete_type : std::false_type {}; + +template +struct is_complete_type : std::true_type {}; + +template +struct is_compatible_object_type_impl : std::false_type {}; + +template +struct is_compatible_object_type_impl < + BasicJsonType, CompatibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + // macOS's is_constructible does not play well with nonesuch... + static constexpr bool value = + is_constructible::value && + is_constructible::value; +}; + +template +struct is_compatible_object_type + : is_compatible_object_type_impl {}; + +template +struct is_constructible_object_type_impl : std::false_type {}; + +template +struct is_constructible_object_type_impl < + BasicJsonType, ConstructibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + static constexpr bool value = + (is_default_constructible::value && + (std::is_move_assignable::value || + std::is_copy_assignable::value) && + (is_constructible::value && + std::is_same < + typename object_t::mapped_type, + typename ConstructibleObjectType::mapped_type >::value)) || + (has_from_json::value || + has_non_default_from_json < + BasicJsonType, + typename ConstructibleObjectType::mapped_type >::value); +}; + +template +struct is_constructible_object_type + : is_constructible_object_type_impl {}; + +template +struct is_compatible_string_type +{ + static constexpr auto value = + is_constructible::value; +}; + +template +struct is_constructible_string_type +{ + // launder type through decltype() to fix compilation failure on ICPC +#ifdef __INTEL_COMPILER + using laundered_type = decltype(std::declval()); +#else + using laundered_type = ConstructibleStringType; +#endif + + static constexpr auto value = + conjunction < + is_constructible, + is_detected_exact>::value; +}; + +template +struct is_compatible_array_type_impl : std::false_type {}; + +template +struct is_compatible_array_type_impl < + BasicJsonType, CompatibleArrayType, + enable_if_t < + is_detected::value&& + is_iterator_traits>>::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>::value >> +{ + static constexpr bool value = + is_constructible>::value; +}; + +template +struct is_compatible_array_type + : is_compatible_array_type_impl {}; + +template +struct is_constructible_array_type_impl : std::false_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t::value >> + : std::true_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t < !std::is_same::value&& + !is_compatible_string_type::value&& + is_default_constructible::value&& +(std::is_move_assignable::value || + std::is_copy_assignable::value)&& +is_detected::value&& +is_iterator_traits>>::value&& +is_detected::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>::value&& + is_complete_type < + detected_t>::value >> +{ + using value_type = range_value_t; + + static constexpr bool value = + std::is_same::value || + has_from_json::value || + has_non_default_from_json < + BasicJsonType, + value_type >::value; +}; + +template +struct is_constructible_array_type + : is_constructible_array_type_impl {}; + +template +struct is_compatible_integer_type_impl : std::false_type {}; + +template +struct is_compatible_integer_type_impl < + RealIntegerType, CompatibleNumberIntegerType, + enable_if_t < std::is_integral::value&& + std::is_integral::value&& + !std::is_same::value >> +{ + // is there an assert somewhere on overflows? + using RealLimits = std::numeric_limits; + using CompatibleLimits = std::numeric_limits; + + static constexpr auto value = + is_constructible::value && + CompatibleLimits::is_integer && + RealLimits::is_signed == CompatibleLimits::is_signed; +}; + +template +struct is_compatible_integer_type + : is_compatible_integer_type_impl {}; + +template +struct is_compatible_type_impl: std::false_type {}; + +template +struct is_compatible_type_impl < + BasicJsonType, CompatibleType, + enable_if_t::value >> +{ + static constexpr bool value = + has_to_json::value; +}; + +template +struct is_compatible_type + : is_compatible_type_impl {}; + +template +struct is_constructible_tuple : std::false_type {}; + +template +struct is_constructible_tuple> : conjunction...> {}; + +template +struct is_json_iterator_of : std::false_type {}; + +template +struct is_json_iterator_of : std::true_type {}; + +template +struct is_json_iterator_of : std::true_type +{}; + +// checks if a given type T is a template specialization of Primary +template