💚 add trait for 128 bit integers

🔊 add test for type traits
2026-06-21 11:44:18 +00:00 · 2020-07-13 14:03:04 +02:00 · 2020-07-13 13:46:56 +02:00 · 2020-07-13 13:23:36 +02:00 · 2020-07-13 12:51:39 +02:00 · 2020-07-13 12:44:34 +02:00
121 changed files with 3493 additions and 5746 deletions
@@ -1,84 +0,0 @@
 #AccessModifierOffset: 2
 AlignAfterOpenBracket: Align
 AlignConsecutiveAssignments: false
 #AlignConsecutiveBitFields: false
 AlignConsecutiveDeclarations: false
 AlignConsecutiveMacros: false
 AlignEscapedNewlines: Right
 #AlignOperands: AlignAfterOperator
 AlignTrailingComments: true
 AllowAllArgumentsOnNextLine: false
 AllowAllConstructorInitializersOnNextLine: false
 AllowAllParametersOfDeclarationOnNextLine: false
 AllowShortBlocksOnASingleLine: Empty
 AllowShortCaseLabelsOnASingleLine: false
 #AllowShortEnumsOnASingleLine: true
 AllowShortFunctionsOnASingleLine: Empty
 AllowShortIfStatementsOnASingleLine: Never
 AllowShortLambdasOnASingleLine: Empty
 AllowShortLoopsOnASingleLine: false
 AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
 AlwaysBreakTemplateDeclarations: Yes
 BinPackArguments: false
 BinPackParameters: false
 #BitFieldColonSpacing: Both
 BreakBeforeBraces: Custom # or Allman
 BraceWrapping:
  AfterCaseLabel: true
  AfterClass: true
  AfterControlStatement: Always
  AfterEnum: true
  AfterFunction: true
  AfterNamespace: false
  AfterStruct: true
  AfterUnion: true
  AfterExternBlock: false
  BeforeCatch: true
  BeforeElse: true
  #BeforeLambdaBody: false
  #BeforeWhile: false
  SplitEmptyFunction: false
  SplitEmptyRecord: false
  SplitEmptyNamespace: false
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializers: BeforeComma
 BreakStringLiterals: false
 ColumnLimit: 0
 CompactNamespaces: false
 ConstructorInitializerIndentWidth: 2
 Cpp11BracedListStyle: true
 PointerAlignment: Left
 FixNamespaceComments: true
 IncludeBlocks: Preserve
 #IndentCaseBlocks: false
 IndentCaseLabels: true
 IndentGotoLabels: false
 IndentPPDirectives: BeforeHash
 IndentWidth: 4
 KeepEmptyLinesAtTheStartOfBlocks: false
 MaxEmptyLinesToKeep: 1
 NamespaceIndentation: None
 ReflowComments: false
 SortIncludes: true
 SortUsingDeclarations: true
 SpaceAfterCStyleCast: false
 SpaceAfterLogicalNot: false
 SpaceAfterTemplateKeyword: false
 SpaceBeforeAssignmentOperators: true
 SpaceBeforeCpp11BracedList: false
 SpaceBeforeParens: ControlStatements
 SpaceBeforeRangeBasedForLoopColon: true
 SpaceBeforeSquareBrackets: false
 SpaceInEmptyBlock: false
 SpaceInEmptyParentheses: false
 SpacesBeforeTrailingComments: 2
 SpacesInAngles: false
 SpacesInCStyleCastParentheses: false
 SpacesInConditionalStatement: false
 SpacesInContainerLiterals: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
 Standard: c++11
 TabWidth: 4
 UseTab: Never
@@ -47,7 +47,7 @@ assignees: ''
 <!-- Please add an `x` to the respective line. -->
- [ ] latest release version 3.9.0
+- [ ] latest release version 3.7.3
 - [ ] other release - please state the version: ___
 - [ ] the `develop` branch
@@ -3,7 +3,8 @@ name: Windows
 on: [push, pull_request]
 jobs:
-  msvc2019:
+  build:
    runs-on: windows-latest
    steps:
@@ -14,55 +15,3 @@ jobs:
      run: cmake --build build --parallel 10
    - name: test
      run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
  clang9:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v1
      - name: install Clang
        run: curl -fsSL -o LLVM9.exe https://releases.llvm.org/9.0.0/LLVM-9.0.0-win64.exe ; 7z x LLVM9.exe -y -o"C:/Program Files/LLVM"
      - name: cmake
        run: cmake -S . -B build -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" -G"MinGW Makefiles" -DCMAKE_BUILD_TYPE=Debug -DJSON_BuildTests=On
      - name: build
        run: cmake --build build --parallel 10
      - name: test
        run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
  clang10:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v1
      - name: install Clang
        run: curl -fsSL -o LLVM10.exe https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.0/LLVM-10.0.0-win64.exe ; 7z x LLVM10.exe -y -o"C:/Program Files/LLVM"
      - name: cmake
        run: cmake -S . -B build -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" -G"MinGW Makefiles" -DCMAKE_BUILD_TYPE=Debug -DJSON_BuildTests=On
      - name: build
        run: cmake --build build --parallel 10
      - name: test
        run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
  clang-cl-10-x64:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v1
      - name: cmake
        run: cmake -S . -B build -G "Visual Studio 16 2019" -A x64 -T ClangCL -DJSON_BuildTests=On
      - name: build
        run: cmake --build build --config Debug --parallel 10
      - name: test
        run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
  clang-cl-10-x86:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v1
      - name: cmake
        run: cmake -S . -B build -G "Visual Studio 16 2019" -A Win32 -T ClangCL -DJSON_BuildTests=On
      - name: build
        run: cmake --build build --config Debug --parallel 10
      - name: test
        run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
@@ -0,0 +1,32 @@
 name: Windows
 on: [push, pull_request]
 jobs:
  clang9:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v1
      - name: install Clang
        run: curl -fsSL -o LLVM9.exe https://releases.llvm.org/9.0.0/LLVM-9.0.0-win64.exe ; 7z x LLVM9.exe -y -o"C:/Program Files/LLVM"
      - name: cmake
        run: cmake -S . -B build -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" -G"MinGW Makefiles" -DCMAKE_BUILD_TYPE=Debug -DJSON_BuildTests=On
      - name: build
        run: cmake --build build --parallel 10
      - name: test
        run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
  clang10:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v1
      - name: install Clang
        run: curl -fsSL -o LLVM10.exe https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.0/LLVM-10.0.0-win64.exe ; 7z x LLVM10.exe -y -o"C:/Program Files/LLVM"
      - name: cmake
        run: cmake -S . -B build -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" -G"MinGW Makefiles" -DCMAKE_BUILD_TYPE=Debug -DJSON_BuildTests=On
      - name: build
        run: cmake --build build --parallel 10
      - name: test
        run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
@@ -22,7 +22,7 @@ benchmarks/files/numbers/*.json
 .wsjcpp/*
 .idea
-/cmake-build-*
+cmake-build-debug
 test/test-*
 /.vs
@@ -32,4 +32,3 @@ doc/mkdocs/docs/images
 doc/mkdocs/docs/examples
 doc/mkdocs/site
 doc/mkdocs/docs/__pycache__/
 doc/xml
@@ -10,6 +10,17 @@ sudo: required
 group: edge
 ###################
 # global settings #
 ###################
 env:
  global:
   # The next declaration is the encrypted COVERITY_SCAN_TOKEN, created
   #   via the "travis encrypt" command using the project repo's public key
   - secure: "m89SSgE+ASLO38rSKx7MTXK3n5NkP9bIx95jwY71YEiuFzib30PDJ/DifKnXxBjvy/AkCGztErQRk/8ZCvq+4HXozU2knEGnL/RUitvlwbhzfh2D4lmS3BvWBGS3N3NewoPBrRmdcvnT0xjOGXxtZaJ3P74TkB9GBnlz/HmKORA="
 ################
 # build matrix #
 ################
@@ -118,9 +129,6 @@ matrix:
    env:
      - SPECIAL=coverity
      - COMPILER=clang++-3.6
        # The next declaration is the encrypted COVERITY_SCAN_TOKEN, created
        #   via the "travis encrypt" command using the project repo's public key
      - secure: "m89SSgE+ASLO38rSKx7MTXK3n5NkP9bIx95jwY71YEiuFzib30PDJ/DifKnXxBjvy/AkCGztErQRk/8ZCvq+4HXozU2knEGnL/RUitvlwbhzfh2D4lmS3BvWBGS3N3NewoPBrRmdcvnT0xjOGXxtZaJ3P74TkB9GBnlz/HmKORA="
  # OSX / Clang
@@ -142,14 +150,6 @@ matrix:
  - os: osx
    osx_image: xcode11.2
  - os: osx
    osx_image: xcode12
  - os: osx
    osx_image: xcode12
    env:
      - IMPLICIT_CONVERSIONS=OFF
  # Linux / GCC
  - os: linux
@@ -208,16 +208,6 @@ matrix:
        sources: ['ubuntu-toolchain-r-test']
        packages: ['g++-9', 'ninja-build']
  - os: linux
    compiler: gcc
    env:
      - COMPILER=g++-9
      - IMPLICIT_CONVERSIONS=OFF
    addons:
      apt:
        sources: ['ubuntu-toolchain-r-test']
        packages: ['g++-9', 'ninja-build']
  - os: linux
    compiler: gcc
    env:
@@ -330,12 +320,10 @@ script:
  - if [[ "${COMPILER}" != "" ]]; then export CXX=${COMPILER}; fi
  # by default, use the single-header version
  - if [[ "${MULTIPLE_HEADERS}" == "" ]]; then export MULTIPLE_HEADERS=OFF; fi
  # by default, use implicit conversions
  - if [[ "${IMPLICIT_CONVERSIONS}" == "" ]]; then export IMPLICIT_CONVERSIONS=ON; fi
  # compile and execute unit tests
  - mkdir -p build && cd build
-  - cmake .. ${CMAKE_OPTIONS} -DJSON_MultipleHeaders=${MULTIPLE_HEADERS} -DJSON_ImplicitConversions=${IMPLICIT_CONVERSIONS} -DJSON_BuildTests=On -GNinja && cmake --build . --config Release
+  - cmake .. ${CMAKE_OPTIONS} -DJSON_MultipleHeaders=${MULTIPLE_HEADERS} -DJSON_BuildTests=On -GNinja && cmake --build . --config Release
  - ctest -C Release --timeout 2700 -V -j
  - cd ..
@@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 3.1)
 ## PROJECT
 ## name and version
 ##
-project(nlohmann_json VERSION 3.9.0 LANGUAGES CXX)
+project(nlohmann_json VERSION 3.8.0 LANGUAGES CXX)
 ##
 ## INCLUDE
@@ -24,7 +24,6 @@ endif ()
 option(JSON_BuildTests "Build the unit tests when BUILD_TESTING is enabled." ON)
 option(JSON_Install "Install CMake targets during install step." ON)
 option(JSON_MultipleHeaders "Use non-amalgamated version of the library." OFF)
 option(JSON_ImplicitConversions "Enable implicit conversions." ON)
 ##
 ## CONFIGURATION
@@ -49,10 +48,6 @@ else()
    message(STATUS "Using the single-header code from ${NLOHMANN_JSON_INCLUDE_BUILD_DIR}")
 endif()
 if (NOT JSON_ImplicitConversions)
    message(STATUS "Implicit conversions are disabled")
 endif()
 ##
 ## TARGET
 ## create target and add include path
@@ -65,12 +60,6 @@ else()
    target_compile_features(${NLOHMANN_JSON_TARGET_NAME} INTERFACE cxx_std_11)
 endif()
 target_compile_definitions(
    ${NLOHMANN_JSON_TARGET_NAME}
    INTERFACE
    JSON_USE_IMPLICIT_CONVERSIONS=$<BOOL:${JSON_ImplicitConversions}>
 )
 target_include_directories(
    ${NLOHMANN_JSON_TARGET_NAME}
    INTERFACE
@@ -1,129 +1,13 @@
 # Changelog
 All notable changes to this project will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org/).
 ## [v3.9.0](https://github.com/nlohmann/json/releases/tag/v3.9.0) (2020-07-27)
 [Full Changelog](https://github.com/nlohmann/json/compare/v3.8.0...v3.9.0)
 - Unknown Type Name clang error when using NLOHMANN\_DEFINE\_TYPE\_NON\_INTRUSIVE [\#2313](https://github.com/nlohmann/json/issues/2313)
 - Clang 10.0 / GCC 10.1 warnings on disabled exceptions [\#2304](https://github.com/nlohmann/json/issues/2304)
 - Application stalls indefinitely with message byte size 10 [\#2293](https://github.com/nlohmann/json/issues/2293)
 - linker error [\#2292](https://github.com/nlohmann/json/issues/2292)
 - Add support for high-precision numbers in UBJSON encoding [\#2286](https://github.com/nlohmann/json/issues/2286)
 - NLOHMANN\_DEFINE\_TYPE\_NON\_INTRUSIVE fails if the length of the argument is 10 [\#2280](https://github.com/nlohmann/json/issues/2280)
 - Custom types : MACRO expansion bug [\#2267](https://github.com/nlohmann/json/issues/2267)
 - to/from\_json Failing To Convert String [\#2238](https://github.com/nlohmann/json/issues/2238)
 - clang 9.0 report warning: unused type alias 'size\_type' \[-Wunused-local-typedef\] [\#2221](https://github.com/nlohmann/json/issues/2221)
 - Enormous array created when working with map\<int,T\> [\#2220](https://github.com/nlohmann/json/issues/2220)
 - Can I disable sorting of json values [\#2219](https://github.com/nlohmann/json/issues/2219)
 - Getting Qt types to work [\#2217](https://github.com/nlohmann/json/issues/2217)
 - Convert to Qt QVariant  [\#2216](https://github.com/nlohmann/json/issues/2216)
 - How to custom serialize same data type of vector? [\#2215](https://github.com/nlohmann/json/issues/2215)
 - json constructor does not support std::optional [\#2214](https://github.com/nlohmann/json/issues/2214)
 - Failing to Parse Valid JSON [\#2209](https://github.com/nlohmann/json/issues/2209)
 - \(De-\)Serialization of std::variant with namespaces [\#2208](https://github.com/nlohmann/json/issues/2208)
 - Addint support for complex type [\#2207](https://github.com/nlohmann/json/issues/2207)
 - array\_index possible out of range [\#2205](https://github.com/nlohmann/json/issues/2205)
 - Object deserialized as array [\#2204](https://github.com/nlohmann/json/issues/2204)
 - Sending to a function a reference to a sub-branch [\#2200](https://github.com/nlohmann/json/issues/2200)
 - How to Serialize derived class to JSON object?  [\#2199](https://github.com/nlohmann/json/issues/2199)
 - JSON incorrectly serialized [\#2198](https://github.com/nlohmann/json/issues/2198)
 - Exception Unhandled out\_of\_range error [\#2197](https://github.com/nlohmann/json/issues/2197)
 - msgpack serialisation : float is treated as 64bit float, not 32bit float. [\#2196](https://github.com/nlohmann/json/issues/2196)
 - Is it possible to use compile-time type guarantees for JSON structures? [\#2195](https://github.com/nlohmann/json/issues/2195)
 - Question : performance against python dict [\#2194](https://github.com/nlohmann/json/issues/2194)
 - vs2017 compile error [\#2192](https://github.com/nlohmann/json/issues/2192)
 - Check if a key exists [\#2191](https://github.com/nlohmann/json/issues/2191)
 - Failed to run tests due to missing test data on builders without Internet access [\#2190](https://github.com/nlohmann/json/issues/2190)
 - 3.8.0: unit-cbor.cpp test failures [\#2189](https://github.com/nlohmann/json/issues/2189)
 - 'nlohmann/json.hpp' file not found [\#2188](https://github.com/nlohmann/json/issues/2188)
 - How to send json data over the wire? [\#2185](https://github.com/nlohmann/json/issues/2185)
 - Ubuntu 16 not supporting nlohmann/json? [\#2184](https://github.com/nlohmann/json/issues/2184)
 - .get\<std::string\> causing emdash errors [\#2180](https://github.com/nlohmann/json/issues/2180)
 - Object properties should not be re-sorted alphabetically [\#2179](https://github.com/nlohmann/json/issues/2179)
 - Custom type registration : instrusive API [\#2175](https://github.com/nlohmann/json/issues/2175)
 - Many version of the function "void to\_json\(json& j, const MyStruct& struct\)" [\#2171](https://github.com/nlohmann/json/issues/2171)
 - How should strings be escaped? [\#2155](https://github.com/nlohmann/json/issues/2155)
 - Adding a value to an existing json puts it at the beginning instead of the end [\#2149](https://github.com/nlohmann/json/issues/2149)
 - The header file is big, can we use what we need. [\#2134](https://github.com/nlohmann/json/issues/2134)
 - Changing the default format for unordered\_map \(or other set\) [\#2132](https://github.com/nlohmann/json/issues/2132)
 - Getting size of deserialized bson document [\#2131](https://github.com/nlohmann/json/issues/2131)
 - implicit conversion failure [\#2128](https://github.com/nlohmann/json/issues/2128)
 - Error thrown when parsing in a subclass [\#2124](https://github.com/nlohmann/json/issues/2124)
 - explicit conversion to string not considered for std::map keys in GCC8 [\#2096](https://github.com/nlohmann/json/issues/2096)
 - Add support for JSONC [\#2061](https://github.com/nlohmann/json/issues/2061)
 - Library provides template arg for string\_type but assumes std::string in some places [\#2059](https://github.com/nlohmann/json/issues/2059)
 - incremental parsing with sax\_parser [\#2030](https://github.com/nlohmann/json/issues/2030)
 - Question about flatten and unflatten [\#1989](https://github.com/nlohmann/json/issues/1989)
 - CBOR parser doesn't skip tags [\#1968](https://github.com/nlohmann/json/issues/1968)
 - Compilation failure using Clang on Windows [\#1898](https://github.com/nlohmann/json/issues/1898)
 - Fail to build when including json.hpp as a system include [\#1818](https://github.com/nlohmann/json/issues/1818)
 - Parsing string into json doesn't preserve the order correctly. [\#1817](https://github.com/nlohmann/json/issues/1817)
 - \[C++17\] Allow std::optional to convert to nlohmann::json [\#1749](https://github.com/nlohmann/json/issues/1749)
 - How can I save json object in file in order?  [\#1717](https://github.com/nlohmann/json/issues/1717)
 - Support for Comments [\#1513](https://github.com/nlohmann/json/issues/1513)
 - clang compiler: error : unknown type name 'not' [\#1119](https://github.com/nlohmann/json/issues/1119)
 - dump\(\) without alphabetical order [\#1106](https://github.com/nlohmann/json/issues/1106)
 - operator T\(\) considered harmful [\#958](https://github.com/nlohmann/json/issues/958)
 - Order of the elements in JSON object [\#952](https://github.com/nlohmann/json/issues/952)
 - How to prevent alphabetical sorting of data? [\#727](https://github.com/nlohmann/json/issues/727)
 - Why is an object ordering values by Alphabetical Order?  [\#660](https://github.com/nlohmann/json/issues/660)
 - Feature request: Comments [\#597](https://github.com/nlohmann/json/issues/597)
 - Head Elements Sorting [\#543](https://github.com/nlohmann/json/issues/543)
 - Automatic ordered JSON [\#424](https://github.com/nlohmann/json/issues/424)
 - Support for comments. [\#376](https://github.com/nlohmann/json/issues/376)
 - Optional comment support. [\#363](https://github.com/nlohmann/json/issues/363)
 - Strip comments / Minify [\#294](https://github.com/nlohmann/json/issues/294)
 - maintaining order of keys during iteration [\#106](https://github.com/nlohmann/json/issues/106)
 - Update documentation [\#2312](https://github.com/nlohmann/json/pull/2312) ([nlohmann](https://github.com/nlohmann))
 - Fix bug in CBOR tag handling [\#2308](https://github.com/nlohmann/json/pull/2308) ([nlohmann](https://github.com/nlohmann))
 - added inline to NLOHMANN\_DEFINE\_TYPE\_NON\_INTRUSIVE macro [\#2306](https://github.com/nlohmann/json/pull/2306) ([jwittbrodt](https://github.com/jwittbrodt))
 - fixes unused variable 'ex' for \#2304 [\#2305](https://github.com/nlohmann/json/pull/2305) ([AODQ](https://github.com/AODQ))
 - Cleanup [\#2303](https://github.com/nlohmann/json/pull/2303) ([nlohmann](https://github.com/nlohmann))
 - Add test with multiple translation units [\#2301](https://github.com/nlohmann/json/pull/2301) ([nlohmann](https://github.com/nlohmann))
 - Merge GitHub actions [\#2300](https://github.com/nlohmann/json/pull/2300) ([nlohmann](https://github.com/nlohmann))
 - Fix unused parameter [\#2299](https://github.com/nlohmann/json/pull/2299) ([nlohmann](https://github.com/nlohmann))
 - Add support for high-precision numbers in UBJSON encoding [\#2297](https://github.com/nlohmann/json/pull/2297) ([nlohmann](https://github.com/nlohmann))
 - fix eof for get\_binary and get\_string [\#2294](https://github.com/nlohmann/json/pull/2294) ([jprochazk](https://github.com/jprochazk))
 - Serialisation macros: increase upper bound on number of member variables [\#2287](https://github.com/nlohmann/json/pull/2287) ([pfeatherstone](https://github.com/pfeatherstone))
 - add inline specifier for detail::combine [\#2285](https://github.com/nlohmann/json/pull/2285) ([T0b1-iOS](https://github.com/T0b1-iOS))
 - Add static assertion for missing binary function in SAX interface [\#2282](https://github.com/nlohmann/json/pull/2282) ([nlohmann](https://github.com/nlohmann))
 - Add test for target\_include\_directories [\#2279](https://github.com/nlohmann/json/pull/2279) ([nlohmann](https://github.com/nlohmann))
 - Clean up maintainer Makefiles and fix some linter warnings [\#2274](https://github.com/nlohmann/json/pull/2274) ([nlohmann](https://github.com/nlohmann))
 - Add option to ignore CBOR tags [\#2273](https://github.com/nlohmann/json/pull/2273) ([nlohmann](https://github.com/nlohmann))
 - Hash function without allocation [\#2269](https://github.com/nlohmann/json/pull/2269) ([nlohmann](https://github.com/nlohmann))
 - Add ClangCL for MSVC [\#2268](https://github.com/nlohmann/json/pull/2268) ([t-b](https://github.com/t-b))
 - Makefile: Always use SED variable [\#2264](https://github.com/nlohmann/json/pull/2264) ([t-b](https://github.com/t-b))
 - Add Xcode 12 CI [\#2262](https://github.com/nlohmann/json/pull/2262) ([nlohmann](https://github.com/nlohmann))
 - Make library work with Clang on Windows [\#2259](https://github.com/nlohmann/json/pull/2259) ([nlohmann](https://github.com/nlohmann))
 - Add ordered\_json specialization with ordered object keys [\#2258](https://github.com/nlohmann/json/pull/2258) ([nlohmann](https://github.com/nlohmann))
 - Add pkg-config file [\#2253](https://github.com/nlohmann/json/pull/2253) ([ericonr](https://github.com/ericonr))
 - Fix regression from \#2181 [\#2251](https://github.com/nlohmann/json/pull/2251) ([nlohmann](https://github.com/nlohmann))
 - Tag binary values in cbor if set [\#2244](https://github.com/nlohmann/json/pull/2244) ([matthewbauer](https://github.com/matthewbauer))
 - Make assert configurable via JSON\_ASSERT [\#2242](https://github.com/nlohmann/json/pull/2242) ([nlohmann](https://github.com/nlohmann))
 - Add specialization of get\_to [\#2233](https://github.com/nlohmann/json/pull/2233) ([nlohmann](https://github.com/nlohmann))
 - Refine documentation of error\_handler parameter [\#2232](https://github.com/nlohmann/json/pull/2232) ([nlohmann](https://github.com/nlohmann))
 - Simplify conversion from/to custom types [\#2225](https://github.com/nlohmann/json/pull/2225) ([nlohmann](https://github.com/nlohmann))
 - Remove unused typedefs [\#2224](https://github.com/nlohmann/json/pull/2224) ([nlohmann](https://github.com/nlohmann))
 - Enable CMake policy CMP0077 [\#2222](https://github.com/nlohmann/json/pull/2222) ([alexreinking](https://github.com/alexreinking))
 - Add option to ignore comments in parse/accept functions [\#2212](https://github.com/nlohmann/json/pull/2212) ([nlohmann](https://github.com/nlohmann))
 - Fix Clang-Tidy warnings [\#2211](https://github.com/nlohmann/json/pull/2211) ([nlohmann](https://github.com/nlohmann))
 - Simple ordered\_json that works on all supported compilers [\#2206](https://github.com/nlohmann/json/pull/2206) ([gatopeich](https://github.com/gatopeich))
 - Use unsigned indizies for array index in json pointer [\#2203](https://github.com/nlohmann/json/pull/2203) ([t-b](https://github.com/t-b))
 - Add option to not rely on Internet connectivity during test stage [\#2202](https://github.com/nlohmann/json/pull/2202) ([nlohmann](https://github.com/nlohmann))
 - Serialize floating-point numbers with 32 bit when possible \(MessagePack\) [\#2201](https://github.com/nlohmann/json/pull/2201) ([nlohmann](https://github.com/nlohmann))
 - Fix consistency in function `int\_to\_string\(\)` [\#2193](https://github.com/nlohmann/json/pull/2193) ([dota17](https://github.com/dota17))
 - Fix issue\#1275 [\#2181](https://github.com/nlohmann/json/pull/2181) ([dota17](https://github.com/dota17))
 - C++20 support by removing swap specialization [\#2176](https://github.com/nlohmann/json/pull/2176) ([gracicot](https://github.com/gracicot))
 - Feat/explicit conversion operator [\#1559](https://github.com/nlohmann/json/pull/1559) ([theodelrieu](https://github.com/theodelrieu))
 ## [v3.8.0](https://github.com/nlohmann/json/releases/tag/v3.8.0) (2020-06-14)
 [Full Changelog](https://github.com/nlohmann/json/compare/v3.7.3...v3.8.0)
 - sorry delete this issue, i'm stupid [\#2187](https://github.com/nlohmann/json/issues/2187)
 - Append to a std::nlohmann::json type [\#2186](https://github.com/nlohmann/json/issues/2186)
 - Object properties should not be re-sorted alphabetically [\#2179](https://github.com/nlohmann/json/issues/2179)
 - Some troubles to compile the last revision [\#2177](https://github.com/nlohmann/json/issues/2177)
 - \# Top level CMakeLists.txt
 project\(FOO\)
@@ -150,6 +34,7 @@ All notable changes to this project will be documented in this file. This projec
 - test-cbor fails [\#2154](https://github.com/nlohmann/json/issues/2154)
 - Accessing array inside array syntax?  [\#2151](https://github.com/nlohmann/json/issues/2151)
 - Best way to catch errors when querying json [\#2150](https://github.com/nlohmann/json/issues/2150)
 - Adding a value to an existing json puts it at the beginning instead of the end [\#2149](https://github.com/nlohmann/json/issues/2149)
 - JSON Data Mapping Key-Value from other Key-Value [\#2148](https://github.com/nlohmann/json/issues/2148)
 - Conflicts with std \<any\> compiling with GCC 10 [\#2146](https://github.com/nlohmann/json/issues/2146)
 - Incorrect CMake FetchContent example [\#2142](https://github.com/nlohmann/json/issues/2142)
@@ -179,6 +64,7 @@ All notable changes to this project will be documented in this file. This projec
 - Can't ad an object in another objet [\#2101](https://github.com/nlohmann/json/issues/2101)
 - Implicit conversion causes "cannot use operator\[\] with a string argument with string" [\#2098](https://github.com/nlohmann/json/issues/2098)
 - C++20: char8\_t [\#2097](https://github.com/nlohmann/json/issues/2097)
 - UTF8  [\#2095](https://github.com/nlohmann/json/issues/2095)
 - Compilation issues when included in project [\#2094](https://github.com/nlohmann/json/issues/2094)
 - string value with null character causes infinite loop [\#2093](https://github.com/nlohmann/json/issues/2093)
 - corrupted size vs. prev\_size \(aborted\) [\#2092](https://github.com/nlohmann/json/issues/2092)
@@ -205,6 +91,7 @@ All notable changes to this project will be documented in this file. This projec
 - Bug: returning reference to local temporary object [\#2064](https://github.com/nlohmann/json/issues/2064)
 - Allow to use non strict parsing [\#2063](https://github.com/nlohmann/json/issues/2063)
 - Crashing on json::at [\#2062](https://github.com/nlohmann/json/issues/2062)
 - Add support for JSONC [\#2061](https://github.com/nlohmann/json/issues/2061)
 - How to convert a const std::vector\<char8\_t\> message to a json, to be able to parse it and extract information from it? Can you point to any examples? [\#2058](https://github.com/nlohmann/json/issues/2058)
 - Nice library [\#2057](https://github.com/nlohmann/json/issues/2057)
 - json.hpp:15372:22: error: expected unqualified-id if \(not std::isfinite\(x\)\): Started getting this bug after updating my XCode [\#2056](https://github.com/nlohmann/json/issues/2056)
@@ -310,6 +197,7 @@ All notable changes to this project will be documented in this file. This projec
 - typo in a comment [\#1903](https://github.com/nlohmann/json/issues/1903)
 - Watch JSON variables in Debug [\#1902](https://github.com/nlohmann/json/issues/1902)
 - does Json sdk cares about dfc dfd utf8 issue? [\#1901](https://github.com/nlohmann/json/issues/1901)
 - Compilation failure using Clang on Windows [\#1898](https://github.com/nlohmann/json/issues/1898)
 - Allow multiple line string value in JSON [\#1897](https://github.com/nlohmann/json/issues/1897)
 - Writing map to json file  [\#1896](https://github.com/nlohmann/json/issues/1896)
 - Small documentation mistake [\#1895](https://github.com/nlohmann/json/issues/1895)
@@ -365,6 +253,7 @@ All notable changes to this project will be documented in this file. This projec
 - Serialize big data in json [\#1828](https://github.com/nlohmann/json/issues/1828)
 - Backslash '\' in value causes exception [\#1827](https://github.com/nlohmann/json/issues/1827)
 - from\_json for non default constructible class with dependency injection [\#1819](https://github.com/nlohmann/json/issues/1819)
 - Fail to build when including json.hpp as a system include [\#1818](https://github.com/nlohmann/json/issues/1818)
 - Semi-frequent timeouts in `test-unicode\_all` with 3.6.1 \(aarch64\) [\#1816](https://github.com/nlohmann/json/issues/1816)
 - input\_adapter not user extensible [\#1813](https://github.com/nlohmann/json/issues/1813)
 - crash at json::destroy on android  [\#1812](https://github.com/nlohmann/json/issues/1812)
@@ -433,6 +322,7 @@ All notable changes to this project will be documented in this file. This projec
 - Fix issue\#1719 [\#2044](https://github.com/nlohmann/json/pull/2044) ([dota17](https://github.com/dota17))
 - Add missing testcase about NaN in unit-constructor1.cpp [\#2043](https://github.com/nlohmann/json/pull/2043) ([dota17](https://github.com/dota17))
 - Templatize basic\_json constructor from json\_ref [\#2034](https://github.com/nlohmann/json/pull/2034) ([ArtemSarmini](https://github.com/ArtemSarmini))
 - Replace deprecated std::is\_pod [\#2033](https://github.com/nlohmann/json/pull/2033) ([nlohmann](https://github.com/nlohmann))
 - fix \#1982:json\_pointer.contains\(\) exception is incorrectly raised [\#2019](https://github.com/nlohmann/json/pull/2019) ([dota17](https://github.com/dota17))
 - catch exceptions for json\_pointer : ..../+99 [\#1990](https://github.com/nlohmann/json/pull/1990) ([dota17](https://github.com/dota17))
 - fix warnings in serializer.hpp for VS2019 [\#1969](https://github.com/nlohmann/json/pull/1969) ([dota17](https://github.com/dota17))
@@ -479,6 +369,7 @@ All notable changes to this project will be documented in this file. This projec
 - json class should have a get\_or member function [\#1823](https://github.com/nlohmann/json/issues/1823)
 - NLOHMANN\_JSON\_SERIALIZE\_ENUM macro capture's json objects by value [\#1822](https://github.com/nlohmann/json/issues/1822)
 - Parse fails when number literals start with zero [\#1820](https://github.com/nlohmann/json/issues/1820)
 - Parsing string into json doesn't preserve the order correctly. [\#1817](https://github.com/nlohmann/json/issues/1817)
 - Weird behaviour of `contains` with `json\_pointer` [\#1815](https://github.com/nlohmann/json/issues/1815)
 - strange behaviour with json\_pointer and .contains\(\) [\#1811](https://github.com/nlohmann/json/issues/1811)
 - Can \#1695 be re-opened? [\#1808](https://github.com/nlohmann/json/issues/1808)
@@ -535,6 +426,7 @@ All notable changes to this project will be documented in this file. This projec
 - CMake not correctly finding the configuration package for 3.7.0  [\#1721](https://github.com/nlohmann/json/issues/1721)
 - name typo in the "spack package management" section of README.md [\#1720](https://github.com/nlohmann/json/issues/1720)
 - How to add json to another json? [\#1718](https://github.com/nlohmann/json/issues/1718)
 - How can I save json object in file in order?  [\#1717](https://github.com/nlohmann/json/issues/1717)
 - json::parse\(\) ubsan regression with v3.7.0 [\#1716](https://github.com/nlohmann/json/issues/1716)
 - What I am doing wrong?!? [\#1714](https://github.com/nlohmann/json/issues/1714)
 - Potential memory leak detected by Valgrind [\#1713](https://github.com/nlohmann/json/issues/1713)
@@ -741,6 +633,8 @@ All notable changes to this project will be documented in this file. This projec
 - Added to\_string and added basic tests [\#1585](https://github.com/nlohmann/json/pull/1585) ([Macr0Nerd](https://github.com/Macr0Nerd))
 - Regression tests for MSVC [\#1570](https://github.com/nlohmann/json/pull/1570) ([nickaein](https://github.com/nickaein))
 - Fix/1511 [\#1555](https://github.com/nlohmann/json/pull/1555) ([theodelrieu](https://github.com/theodelrieu))
 - Remove C++17 extension warning from clang; \#1535 [\#1551](https://github.com/nlohmann/json/pull/1551) ([heavywatal](https://github.com/heavywatal))
 - moved from Catch to doctest for unit tests [\#1439](https://github.com/nlohmann/json/pull/1439) ([onqtam](https://github.com/onqtam))
 ## [v3.6.1](https://github.com/nlohmann/json/releases/tag/v3.6.1) (2019-03-20)
@@ -764,6 +658,7 @@ All notable changes to this project will be documented in this file. This projec
 - how to precision to four decimal for double when use to\_json [\#1519](https://github.com/nlohmann/json/issues/1519)
 - error parse [\#1518](https://github.com/nlohmann/json/issues/1518)
 - Compile error: template argument deduction/substitution failed [\#1515](https://github.com/nlohmann/json/issues/1515)
 - Support for Comments [\#1513](https://github.com/nlohmann/json/issues/1513)
 - std::complex type [\#1510](https://github.com/nlohmann/json/issues/1510)
 - CBOR byte string support [\#1509](https://github.com/nlohmann/json/issues/1509)
 - Compilation error getting a std::pair\<\> on latest VS 2017 compiler [\#1506](https://github.com/nlohmann/json/issues/1506)
@@ -843,7 +738,6 @@ All notable changes to this project will be documented in this file. This projec
 - Implicit type conversion error on MSVC [\#1333](https://github.com/nlohmann/json/issues/1333)
 - NuGet Package [\#1132](https://github.com/nlohmann/json/issues/1132)
 - Remove C++17 extension warning from clang; \#1535 [\#1551](https://github.com/nlohmann/json/pull/1551) ([heavywatal](https://github.com/heavywatal))
 - Change macros to numeric\_limits [\#1514](https://github.com/nlohmann/json/pull/1514) ([naszta](https://github.com/naszta))
 - fix GCC 7.1.1 - 7.2.1 on CentOS [\#1496](https://github.com/nlohmann/json/pull/1496) ([lieff](https://github.com/lieff))
 - Update Buckaroo instructions in README.md [\#1495](https://github.com/nlohmann/json/pull/1495) ([njlr](https://github.com/njlr))
@@ -859,7 +753,6 @@ All notable changes to this project will be documented in this file. This projec
 - remove extra semicolon from readme [\#1451](https://github.com/nlohmann/json/pull/1451) ([Afforix](https://github.com/Afforix))
 - attempt to fix \#1445, flush buffer in serializer::dump\_escaped in UTF8\_REJECT case. [\#1446](https://github.com/nlohmann/json/pull/1446) ([scinart](https://github.com/scinart))
 - Use C++11 features supported by CMake 3.1. [\#1441](https://github.com/nlohmann/json/pull/1441) ([iwanders](https://github.com/iwanders))
 - moved from Catch to doctest for unit tests [\#1439](https://github.com/nlohmann/json/pull/1439) ([onqtam](https://github.com/onqtam))
 - :rotating\_light: fixed unused variable warning [\#1435](https://github.com/nlohmann/json/pull/1435) ([pboettch](https://github.com/pboettch))
 - allow push\_back\(\) and pop\_back\(\) calls on json\_pointer [\#1434](https://github.com/nlohmann/json/pull/1434) ([pboettch](https://github.com/pboettch))
 - Add instructions about using nlohmann/json with the conda package manager [\#1430](https://github.com/nlohmann/json/pull/1430) ([nicoddemus](https://github.com/nicoddemus))
@@ -931,6 +824,7 @@ All notable changes to this project will be documented in this file. This projec
 - Comparisons between large unsigned and negative signed integers [\#1295](https://github.com/nlohmann/json/issues/1295)
 - CMake alias to `nlohmann::json` [\#1291](https://github.com/nlohmann/json/issues/1291)
 - Release zips without tests [\#1285](https://github.com/nlohmann/json/issues/1285)
 - Suggestion to improve value\(\) accessors with respect to move semantics [\#1275](https://github.com/nlohmann/json/issues/1275)
 - separate object\_t::key\_type from basic\_json::key\_type, and use an allocator which returns object\_t::key\_type [\#1274](https://github.com/nlohmann/json/issues/1274)
 - Is there a nice way to associate external values with json elements? [\#1256](https://github.com/nlohmann/json/issues/1256)
 - Delete by json\_pointer [\#1248](https://github.com/nlohmann/json/issues/1248)
@@ -1129,6 +1023,7 @@ All notable changes to this project will be documented in this file. This projec
 - can't not parse "\\“ string [\#1123](https://github.com/nlohmann/json/issues/1123)
 -  if  json file  contain Internationalization   chars   ,  get  exception [\#1122](https://github.com/nlohmann/json/issues/1122)
 - How to use a json::iterator dereferenced value in code? [\#1120](https://github.com/nlohmann/json/issues/1120)
 - clang compiler: error : unknown type name 'not' [\#1119](https://github.com/nlohmann/json/issues/1119)
 - Disable implicit conversions from json to std::initializer\_list\<T\> for any T [\#1118](https://github.com/nlohmann/json/issues/1118)
 - Implicit conversions to complex types can lead to surprising and confusing errors [\#1116](https://github.com/nlohmann/json/issues/1116)
 - How can I write from\_json for a complex datatype that is not default constructible? [\#1115](https://github.com/nlohmann/json/issues/1115)
@@ -1140,6 +1035,7 @@ All notable changes to this project will be documented in this file. This projec
 - JSON representation for floating point values has too many digits [\#1109](https://github.com/nlohmann/json/issues/1109)
 - Not working for classes containing "\_declspec\(dllimport\)" in their declaration [\#1108](https://github.com/nlohmann/json/issues/1108)
 - Get keys from json object [\#1107](https://github.com/nlohmann/json/issues/1107)
 - dump\(\) without alphabetical order [\#1106](https://github.com/nlohmann/json/issues/1106)
 - Cannot deserialize types using std::ratio [\#1105](https://github.com/nlohmann/json/issues/1105)
 -  i want to learn json [\#1104](https://github.com/nlohmann/json/issues/1104)
 - Type checking during compile [\#1103](https://github.com/nlohmann/json/issues/1103)
@@ -1286,7 +1182,6 @@ All notable changes to this project will be documented in this file. This projec
 - Allowing for user-defined string type in lexer/parser [\#1009](https://github.com/nlohmann/json/pull/1009) ([nlohmann](https://github.com/nlohmann))
 - dump to alternative string type, as defined in basic\_json template [\#1006](https://github.com/nlohmann/json/pull/1006) ([agrianius](https://github.com/agrianius))
 - Fix memory leak during parser callback [\#1001](https://github.com/nlohmann/json/pull/1001) ([nlohmann](https://github.com/nlohmann))
 - fixed misprinted condition detected by PVS Studio. [\#992](https://github.com/nlohmann/json/pull/992) ([bogemic](https://github.com/bogemic))
 - Fix/basic json conversion [\#986](https://github.com/nlohmann/json/pull/986) ([theodelrieu](https://github.com/theodelrieu))
 - Make integration section concise [\#981](https://github.com/nlohmann/json/pull/981) ([wla80](https://github.com/wla80))
@@ -1310,6 +1205,7 @@ All notable changes to this project will be documented in this file. This projec
 - \[Request\] Macro generating from\_json\(\) and to\_json\(\) [\#895](https://github.com/nlohmann/json/issues/895)
 - basic\_json::value throws exception instead of returning default value [\#871](https://github.com/nlohmann/json/issues/871)
 - Fix memory leak during parser callback [\#1001](https://github.com/nlohmann/json/pull/1001) ([nlohmann](https://github.com/nlohmann))
 - Fix constraints on from\_json\(CompatibleArrayType\) [\#969](https://github.com/nlohmann/json/pull/969) ([theodelrieu](https://github.com/theodelrieu))
 - Make coveralls watch the include folder [\#957](https://github.com/nlohmann/json/pull/957) ([theodelrieu](https://github.com/theodelrieu))
 - Fix links in README.md [\#955](https://github.com/nlohmann/json/pull/955) ([patrikhuber](https://github.com/patrikhuber))
@@ -1323,6 +1219,7 @@ All notable changes to this project will be documented in this file. This projec
 [Full Changelog](https://github.com/nlohmann/json/compare/v3.0.1...3.1.0)
 - Order of the elements in JSON object [\#952](https://github.com/nlohmann/json/issues/952)
 - I have a proposal [\#949](https://github.com/nlohmann/json/issues/949)
 - VERSION define\(s\) [\#948](https://github.com/nlohmann/json/issues/948)
 - v3.0.1 compile error in icc 16.0.4 [\#947](https://github.com/nlohmann/json/issues/947)
@@ -1524,6 +1421,7 @@ All notable changes to this project will be documented in this file. This projec
 - Project's name is too generic and hard to search for [\#730](https://github.com/nlohmann/json/issues/730)
 - Visual Studio 2015 IntelliTrace problems [\#729](https://github.com/nlohmann/json/issues/729)
 - How to erase nested objects inside other objects? [\#728](https://github.com/nlohmann/json/issues/728)
 - How to prevent alphabetical sorting of data? [\#727](https://github.com/nlohmann/json/issues/727)
 - Serialization for CBOR [\#726](https://github.com/nlohmann/json/issues/726)
 - Using json Object as value in a map [\#725](https://github.com/nlohmann/json/issues/725)
 - std::regex and nlohmann::json value [\#724](https://github.com/nlohmann/json/issues/724)
@@ -1571,6 +1469,7 @@ All notable changes to this project will be documented in this file. This projec
 - could this json lib work on windows? [\#664](https://github.com/nlohmann/json/issues/664)
 - How does from\_json work? [\#662](https://github.com/nlohmann/json/issues/662)
 - insert\(or merge\) object should replace same key , not ignore [\#661](https://github.com/nlohmann/json/issues/661)
 - Why is an object ordering values by Alphabetical Order?  [\#660](https://github.com/nlohmann/json/issues/660)
 - Parse method doesn't handle newlines. [\#659](https://github.com/nlohmann/json/issues/659)
 - Compilation "note" on GCC 6 ARM [\#658](https://github.com/nlohmann/json/issues/658)
 - Adding additional push\_back/operator+= rvalue overloads for JSON object [\#657](https://github.com/nlohmann/json/issues/657)
@@ -1620,6 +1519,7 @@ All notable changes to this project will be documented in this file. This projec
 - Use of the binary type in CBOR and Message Pack [\#601](https://github.com/nlohmann/json/issues/601)
 - Newbie issue: how does one convert a map in Json back to std::map? [\#600](https://github.com/nlohmann/json/issues/600)
 - Plugin system [\#599](https://github.com/nlohmann/json/issues/599)
 - Feature request: Comments [\#597](https://github.com/nlohmann/json/issues/597)
 - Using custom types for scalars? [\#596](https://github.com/nlohmann/json/issues/596)
 - Issues with the arithmetic in iterator and reverse iterator [\#593](https://github.com/nlohmann/json/issues/593)
 - not enough examples [\#592](https://github.com/nlohmann/json/issues/592)
@@ -1661,6 +1561,7 @@ All notable changes to this project will be documented in this file. This projec
 - Ambiguous compare operators with clang-5.0 [\#547](https://github.com/nlohmann/json/issues/547)
 - Using tsl::ordered\_map [\#546](https://github.com/nlohmann/json/issues/546)
 - Compiler support errors are inconvenient [\#544](https://github.com/nlohmann/json/issues/544)
 - Head Elements Sorting [\#543](https://github.com/nlohmann/json/issues/543)
 - Duplicate symbols error happens while to\_json/from\_json method implemented inside entity definition header file [\#542](https://github.com/nlohmann/json/issues/542)
 - consider adding a bool json::is\_valid\(std::string const&\) non-member function [\#541](https://github.com/nlohmann/json/issues/541)
 - Help request [\#539](https://github.com/nlohmann/json/issues/539)
@@ -1829,6 +1730,7 @@ All notable changes to this project will be documented in this file. This projec
 - Getting std::invalid\_argument: stream error when following example [\#429](https://github.com/nlohmann/json/issues/429)
 - Forward declare-only header? [\#427](https://github.com/nlohmann/json/issues/427)
 - Implicit conversion from array to object [\#425](https://github.com/nlohmann/json/issues/425)
 - Automatic ordered JSON [\#424](https://github.com/nlohmann/json/issues/424)
 - error C4996: 'strerror' when reading file [\#422](https://github.com/nlohmann/json/issues/422)
 - Get an error - JSON pointer must be empty or begin with '/' [\#421](https://github.com/nlohmann/json/issues/421)
 - size parameter for parse\(\) [\#419](https://github.com/nlohmann/json/issues/419)
@@ -1837,6 +1739,7 @@ All notable changes to this project will be documented in this file. This projec
 - comparing to 0 literal [\#414](https://github.com/nlohmann/json/issues/414)
 - Single char converted to ASCII code instead of string [\#413](https://github.com/nlohmann/json/issues/413)
 - How to know if a string  was parsed as utf-8? [\#406](https://github.com/nlohmann/json/issues/406)
 - Heap-buffer-overflow \(OSS-Fuzz issue 342\) [\#405](https://github.com/nlohmann/json/issues/405)
 - Overloaded += to add objects to an array makes no sense? [\#404](https://github.com/nlohmann/json/issues/404)
 - Finding a value in an array [\#399](https://github.com/nlohmann/json/issues/399)
 - add release information in static function [\#397](https://github.com/nlohmann/json/issues/397)
@@ -1866,7 +1769,6 @@ All notable changes to this project will be documented in this file. This projec
 - Use-of-uninitialized-value \(OSS-Fuzz issue 347\) [\#409](https://github.com/nlohmann/json/issues/409)
 - Heap-buffer-overflow \(OSS-Fuzz issue 344\) [\#408](https://github.com/nlohmann/json/issues/408)
 - Heap-buffer-overflow \(OSS-Fuzz issue 343\) [\#407](https://github.com/nlohmann/json/issues/407)
 - Heap-buffer-overflow \(OSS-Fuzz issue 342\) [\#405](https://github.com/nlohmann/json/issues/405)
 - strerror throwing error in compiler VS2015 [\#403](https://github.com/nlohmann/json/issues/403)
 - json::parse of std::string being underlined by Visual Studio [\#402](https://github.com/nlohmann/json/issues/402)
 - Explicitly getting string without .dump\(\)  [\#401](https://github.com/nlohmann/json/issues/401)
@@ -1898,6 +1800,7 @@ All notable changes to this project will be documented in this file. This projec
 - Allow for forward declaring nlohmann::json [\#381](https://github.com/nlohmann/json/issues/381)
 - Bug in overflow detection when parsing integers [\#380](https://github.com/nlohmann/json/issues/380)
 - A unique name to mention the library? [\#377](https://github.com/nlohmann/json/issues/377)
 - Support for comments. [\#376](https://github.com/nlohmann/json/issues/376)
 - Non-unique keys in objects. [\#375](https://github.com/nlohmann/json/issues/375)
 - Request: binary serialization/deserialization [\#358](https://github.com/nlohmann/json/issues/358)
@@ -1921,6 +1824,7 @@ All notable changes to this project will be documented in this file. This projec
 - json::parse on failed stream gets stuck [\#366](https://github.com/nlohmann/json/issues/366)
 - Performance improvements [\#365](https://github.com/nlohmann/json/issues/365)
 - 'to\_string' is not a member of 'std'  [\#364](https://github.com/nlohmann/json/issues/364)
 - Optional comment support. [\#363](https://github.com/nlohmann/json/issues/363)
 - Crash in dump\(\) from a static object [\#359](https://github.com/nlohmann/json/issues/359)
 - json::parse\(...\) vs json j; j.parse\(...\) [\#357](https://github.com/nlohmann/json/issues/357)
 - Hi, is there any method to dump  json to string with the insert order rather than alphabets [\#356](https://github.com/nlohmann/json/issues/356)
@@ -1998,6 +1902,7 @@ All notable changes to this project will be documented in this file. This projec
 [Full Changelog](https://github.com/nlohmann/json/compare/v2.0.2...v2.0.3)
 - warning C4706: assignment within conditional expression [\#295](https://github.com/nlohmann/json/issues/295)
 - Strip comments / Minify [\#294](https://github.com/nlohmann/json/issues/294)
 - Q: Is it possible to build json tree from already UTF8 encoded values? [\#293](https://github.com/nlohmann/json/issues/293)
 - Equality operator results in array when assigned object [\#292](https://github.com/nlohmann/json/issues/292)
 - Support for integers not from the range \[-\(2\*\*53\)+1, \(2\*\*53\)-1\] in parser [\#291](https://github.com/nlohmann/json/issues/291)
@@ -2172,6 +2077,7 @@ All notable changes to this project will be documented in this file. This projec
 - error: unterminated raw string [\#109](https://github.com/nlohmann/json/issues/109)
 - vector\<json\> copy constructor really weird [\#108](https://github.com/nlohmann/json/issues/108)
 - \[clang-3.6.2\] string/sstream with number to json issue [\#107](https://github.com/nlohmann/json/issues/107)
 - maintaining order of keys during iteration [\#106](https://github.com/nlohmann/json/issues/106)
 - object field accessors [\#103](https://github.com/nlohmann/json/issues/103)
 - v8pp and json [\#95](https://github.com/nlohmann/json/issues/95)
 - Wishlist [\#65](https://github.com/nlohmann/json/issues/65)
@@ -5,7 +5,7 @@
 ##########################################################################
 # directory to recent compiler binaries
-COMPILER_DIR=/usr/local/opt/llvm/bin
+COMPILER_DIR=/Users/niels/Documents/projects/compilers/local/bin
 # find GNU sed to use `-i` parameter
 SED:=$(shell command -v gsed || which sed)
@@ -30,6 +30,7 @@ AMALGAMATED_FILE=single_include/nlohmann/json.hpp
 all:
 	@echo "amalgamate - amalgamate file single_include/nlohmann/json.hpp from the include/nlohmann sources"
 	@echo "ChangeLog.md - generate ChangeLog file"
 	@echo "check - compile and execute test suite"
 	@echo "check-amalgamation - check whether sources have been amalgamated"
 	@echo "clean - remove built files"
 	@echo "coverage - create coverage information with lcov"
@@ -43,24 +44,38 @@ all:
 	@echo "fuzz_testing_cbor - prepare fuzz testing of the CBOR parser"
 	@echo "fuzz_testing_msgpack - prepare fuzz testing of the MessagePack parser"
 	@echo "fuzz_testing_ubjson - prepare fuzz testing of the UBJSON parser"
 	@echo "json_unit - create single-file test executable"
 	@echo "pedantic_clang - run Clang with maximal warning flags"
 	@echo "pedantic_gcc - run GCC with maximal warning flags"
 	@echo "pretty - beautify code with Artistic Style"
 	@echo "run_benchmarks - build and run benchmarks"
 ##########################################################################
 # unit tests
 ##########################################################################
 # build unit tests
 json_unit:
 	@$(MAKE) json_unit -C test
 # run unit tests
 check:
 	$(MAKE) check -C test
 ##########################################################################
 # coverage
 ##########################################################################
 coverage:
-	rm -fr cmake-build-coverage
+	rm -fr build_coverage
-	mkdir cmake-build-coverage
+	mkdir build_coverage
-	cd cmake-build-coverage ; cmake .. -GNinja -DCMAKE_BUILD_TYPE=Debug -DJSON_Coverage=ON -DJSON_MultipleHeaders=ON
+	cd build_coverage ; cmake .. -GNinja -DCMAKE_BUILD_TYPE=Debug -DJSON_Coverage=ON -DJSON_MultipleHeaders=ON
-	cd cmake-build-coverage ; ninja
+	cd build_coverage ; ninja
-	cd cmake-build-coverage ; ctest -j10
+	cd build_coverage ; ctest -j10
-	cd cmake-build-coverage ; ninja lcov_html
+	cd build_coverage ; ninja lcov_html
-	open cmake-build-coverage/test/html/index.html
+	open build_coverage/test/html/index.html
 ##########################################################################
 # documentation tests
@@ -88,7 +103,7 @@ doctest:
 # -Wno-switch-enum -Wno-covered-switch-default: pedantic/contradicting warnings about switches
 # -Wno-weak-vtables: exception class is defined inline, but has virtual method
 pedantic_clang:
-	rm -fr cmake-build-pedantic
+	rm -fr build_pedantic
 	CXXFLAGS=" \
 		-std=c++11 -Wno-c++98-compat -Wno-c++98-compat-pedantic \
 		-Werror \
@@ -103,12 +118,12 @@ pedantic_clang:
 		-Wno-padded \
 		-Wno-range-loop-analysis \
 		-Wno-switch-enum -Wno-covered-switch-default \
-		-Wno-weak-vtables" cmake -S . -B cmake-build-pedantic -GNinja -DCMAKE_BUILD_TYPE=Debug -DJSON_MultipleHeaders=ON -DJSON_BuildTests=On
+		-Wno-weak-vtables" cmake -S . -B build_pedantic -GNinja -DCMAKE_BUILD_TYPE=Debug -DJSON_MultipleHeaders=ON -DJSON_BuildTests=On
-	cmake --build cmake-build-pedantic
+	cmake --build build_pedantic
 # calling GCC with most warnings
 pedantic_gcc:
-	rm -fr cmake-build-pedantic
+	rm -fr build_pedantic
 	CXXFLAGS=" \
 		-std=c++11 \
 		-pedantic \
@@ -366,19 +381,19 @@ pedantic_gcc:
 		-Wwrite-strings                                   \
 		-Wzero-as-null-pointer-constant                   \
 		-Wzero-length-bounds                              \
-		" cmake -S . -B cmake-build-pedantic -GNinja -DCMAKE_BUILD_TYPE=Debug -DJSON_MultipleHeaders=ON -DJSON_BuildTests=On
+		" cmake -S . -B build_pedantic -GNinja -DCMAKE_BUILD_TYPE=Debug -DJSON_MultipleHeaders=ON -DJSON_BuildTests=On
-	cmake --build cmake-build-pedantic
+	cmake --build build_pedantic
 ##########################################################################
 # benchmarks
 ##########################################################################
 run_benchmarks:
-	rm -fr cmake-build-benchmarks
+	rm -fr build_benchmarks
-	mkdir cmake-build-benchmarks
+	mkdir build_benchmarks
-	cd cmake-build-benchmarks ; cmake ../benchmarks -GNinja -DCMAKE_BUILD_TYPE=Release -DJSON_BuildTests=On
+	cd build_benchmarks ; cmake ../benchmarks -GNinja -DCMAKE_BUILD_TYPE=Release -DJSON_BuildTests=On
-	cd cmake-build-benchmarks ; ninja
+	cd build_benchmarks ; ninja
-	cd cmake-build-benchmarks ; ./json_benchmarks
+	cd build_benchmarks ; ./json_benchmarks
 ##########################################################################
 # fuzzing
@@ -451,14 +466,14 @@ cppcheck:
 # call Clang Static Analyzer <https://clang-analyzer.llvm.org>
 clang_analyze:
-	rm -fr cmake-build-clang-analyze
+	rm -fr clang_analyze_build
-	mkdir cmake-build-clang-analyze
+	mkdir clang_analyze_build
-	cd cmake-build-clang-analyze ; CCC_CXX=$(COMPILER_DIR)/clang++ CXX=$(COMPILER_DIR)/clang++ $(COMPILER_DIR)/scan-build cmake .. -GNinja -DJSON_BuildTests=On
+	cd clang_analyze_build ; CCC_CXX=$(COMPILER_DIR)/clang++ CXX=$(COMPILER_DIR)/clang++ $(COMPILER_DIR)/scan-build cmake .. -GNinja -DJSON_BuildTests=On -DJSON_MultipleHeaders=On
-	cd cmake-build-clang-analyze ; \
+	cd clang_analyze_build ; \
 		$(COMPILER_DIR)/scan-build \
 			-enable-checker alpha.core.BoolAssignment,alpha.core.CallAndMessageUnInitRefArg,alpha.core.CastSize,alpha.core.CastToStruct,alpha.core.Conversion,alpha.core.DynamicTypeChecker,alpha.core.FixedAddr,alpha.core.PointerArithm,alpha.core.PointerSub,alpha.core.SizeofPtr,alpha.core.StackAddressAsyncEscape,alpha.core.TestAfterDivZero,alpha.deadcode.UnreachableCode,core.builtin.BuiltinFunctions,core.builtin.NoReturnFunctions,core.CallAndMessage,core.DivideZero,core.DynamicTypePropagation,core.NonnilStringConstants,core.NonNullParamChecker,core.NullDereference,core.StackAddressEscape,core.UndefinedBinaryOperatorResult,core.uninitialized.ArraySubscript,core.uninitialized.Assign,core.uninitialized.Branch,core.uninitialized.CapturedBlockVariable,core.uninitialized.UndefReturn,core.VLASize,cplusplus.InnerPointer,cplusplus.Move,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,cplusplus.SelfAssignment,deadcode.DeadStores,nullability.NullableDereferenced,nullability.NullablePassedToNonnull,nullability.NullableReturnedFromNonnull,nullability.NullPassedToNonnull,nullability.NullReturnedFromNonnull \
 			--use-c++=$(COMPILER_DIR)/clang++ -analyze-headers -o report ninja
-	open cmake-build-clang-analyze/report/*/index.html
+	open clang_analyze_build/report/*/index.html
 # call cpplint <https://github.com/cpplint/cpplint>
 # Note: some errors expected due to false positives
@@ -469,22 +484,22 @@ cpplint:
 # call Clang-Tidy <https://clang.llvm.org/extra/clang-tidy/>
 clang_tidy:
-	$(COMPILER_DIR)/clang-tidy $(SRCS) -- -Iinclude -std=c++11
+	$(COMPILER_DIR)/clang-tidy $(AMALGAMATED_FILE) -- -Iinclude -std=c++11
 # call PVS-Studio Analyzer <https://www.viva64.com/en/pvs-studio/>
 pvs_studio:
-	rm -fr cmake-build-pvs-studio
+	rm -fr pvs_studio_build
-	mkdir cmake-build-pvs-studio
+	mkdir pvs_studio_build
-	cd cmake-build-pvs-studio ; cmake .. -DCMAKE_EXPORT_COMPILE_COMMANDS=On -DJSON_MultipleHeaders=ON
+	cd pvs_studio_build ; cmake .. -DCMAKE_EXPORT_COMPILE_COMMANDS=On -DJSON_MultipleHeaders=On
-	cd cmake-build-pvs-studio ; pvs-studio-analyzer analyze -j 10
+	cd pvs_studio_build ; pvs-studio-analyzer analyze -j 10
-	cd cmake-build-pvs-studio ; plog-converter -a'GA:1,2;64:1;CS' -t fullhtml PVS-Studio.log -o pvs
+	cd pvs_studio_build ; plog-converter -a'GA:1,2;64:1;CS' -t fullhtml PVS-Studio.log -o pvs
-	open cmake-build-pvs-studio/pvs/index.html
+	open pvs_studio_build/pvs/index.html
 # call Infer <https://fbinfer.com> static analyzer
 infer:
-	rm -fr cmake-build-infer
+	rm -fr infer_build
-	mkdir cmake-build-infer
+	mkdir infer_build
-	cd cmake-build-infer ; infer compile -- cmake .. -DJSON_MultipleHeaders=ON ; infer run -- make -j 4
+	cd infer_build ; infer compile -- cmake .. -DJSON_MultipleHeaders=On ; infer run -- make -j 4
 # call OCLint <http://oclint.org> static analyzer
 oclint:
@@ -493,11 +508,11 @@ oclint:
 # execute the test suite with Clang sanitizers (address and undefined behavior)
 clang_sanitize:
-	rm -fr cmake-build-clang-sanitize
+	rm -fr clang_sanitize_build
-	mkdir cmake-build-clang-sanitize
+	mkdir clang_sanitize_build
-	cd cmake-build-clang-sanitize ; CXX=$(COMPILER_DIR)/clang++ cmake .. -DJSON_Sanitizer=On -DJSON_MultipleHeaders=ON -DJSON_BuildTests=On -GNinja
+	cd clang_sanitize_build ; CXX=$(COMPILER_DIR)/clang++ cmake .. -DJSON_Sanitizer=On -DJSON_MultipleHeaders=ON -DJSON_BuildTests=On -GNinja
-	cd cmake-build-clang-sanitize ; ninja
+	cd clang_sanitize_build ; ninja
-	cd cmake-build-clang-sanitize ; ctest -j10
+	cd clang_sanitize_build ; ctest -j10
 ##########################################################################
@@ -525,11 +540,7 @@ pretty:
 	    --preserve-date \
 	    --suffix=none \
 	    --formatted \
-	   $(SRCS) $(AMALGAMATED_FILE) test/src/*.cpp test/src/*.hpp benchmarks/src/benchmarks.cpp doc/examples/*.cpp
+	   $(SRCS) $(AMALGAMATED_FILE) test/src/*.cpp benchmarks/src/benchmarks.cpp doc/examples/*.cpp
 # call the Clang-Format on all source files
 pretty_format:
 	for FILE in $(SRCS) $(AMALGAMATED_FILE) test/src/*.cpp test/src/*.hpp benchmarks/src/benchmarks.cpp doc/examples/*.cpp; do echo $$FILE; clang-format -i $$FILE; done
 # create single header file
 amalgamate: $(AMALGAMATED_FILE)
@@ -551,7 +562,7 @@ check-amalgamation:
 check-single-includes:
 	@for x in $(SRCS); do \
 	  echo "Checking self-sufficiency of $$x..." ; \
-	  echo "#include <$$x>\nint main() {}\n" | $(SED) 's|include/||' > single_include_test.cpp; \
+	  echo "#include <$$x>\nint main() {}\n" | sed 's|include/||' > single_include_test.cpp; \
 	  $(CXX) $(CXXFLAGS) -Iinclude -std=c++11 single_include_test.cpp -o single_include_test; \
 	  rm -f single_include_test.cpp single_include_test; \
 	done
@@ -561,17 +572,17 @@ check-single-includes:
 # CMake
 ##########################################################################
-# grep "^option" CMakeLists.txt test/CMakeLists.txt | $(SED) 's/(/ /' | awk '{print $2}' | xargs
+# grep "^option" CMakeLists.txt test/CMakeLists.txt | sed 's/(/ /' | awk '{print $2}' | xargs
 # check if all flags of our CMake files work
 check_cmake_flags_do:
 	$(CMAKE_BINARY) --version
-	for flag in JSON_BuildTests JSON_Install JSON_MultipleHeaders JSON_Sanitizer JSON_Valgrind JSON_NoExceptions JSON_Coverage; do \
+	for flag in '' JSON_BuildTests JSON_Install JSON_MultipleHeaders JSON_Sanitizer JSON_Valgrind JSON_NoExceptions JSON_Coverage; do \
 		rm -fr cmake_build; \
 		mkdir cmake_build; \
-		echo "\n\n$(CMAKE_BINARY) .. -D$$flag=On\n" ; \
+		echo "$(CMAKE_BINARY) .. -D$$flag=On" ; \
 		cd cmake_build ; \
-		$(CMAKE_BINARY) -Werror=dev .. -D$$flag=On -DCMAKE_CXX_COMPILE_FEATURES="cxx_std_11;cxx_range_for" -DCMAKE_CXX_FLAGS="-std=gnu++11" ; \
+		CXX=g++-8 $(CMAKE_BINARY) .. -D$$flag=On -DCMAKE_CXX_COMPILE_FEATURES="cxx_std_11;cxx_range_for" -DCMAKE_CXX_FLAGS="-std=gnu++11" ; \
 		test -f Makefile || exit 1 ; \
 		cd .. ; \
 	done;
@@ -629,8 +640,9 @@ clean:
 	rm -fr json_unit json_benchmarks fuzz fuzz-testing *.dSYM test/*.dSYM oclint_report.html
 	rm -fr benchmarks/files/numbers/*.json
 	rm -fr cmake-3.1.0-Darwin64.tar.gz cmake-3.1.0-Darwin64
-	rm -fr cmake-build-coverage cmake-build-benchmarks fuzz-testing cmake-build-clang-analyze cmake-build-pvs-studio cmake-build-infer cmake-build-clang-sanitize cmake_build
+	rm -fr build_coverage build_benchmarks fuzz-testing clang_analyze_build pvs_studio_build infer_build clang_sanitize_build cmake_build
 	$(MAKE) clean -Cdoc
 	$(MAKE) clean -Ctest
 ##########################################################################
 # Thirdparty code
@@ -639,6 +651,6 @@ clean:
 update_hedley:
 	rm -f include/nlohmann/thirdparty/hedley/hedley.hpp include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	curl https://raw.githubusercontent.com/nemequ/hedley/master/hedley.h -o include/nlohmann/thirdparty/hedley/hedley.hpp
-	$(SED) -i 's/HEDLEY_/JSON_HEDLEY_/g' include/nlohmann/thirdparty/hedley/hedley.hpp
+	gsed -i 's/HEDLEY_/JSON_HEDLEY_/g' include/nlohmann/thirdparty/hedley/hedley.hpp
-	grep "[[:blank:]]*#[[:blank:]]*undef" include/nlohmann/thirdparty/hedley/hedley.hpp | grep -v "__" | sort | uniq | $(SED) 's/ //g' | $(SED) 's/undef/undef /g' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp
+	grep "[[:blank:]]*#[[:blank:]]*undef" include/nlohmann/thirdparty/hedley/hedley.hpp | grep -v "__" | sort | uniq | gsed 's/ //g' | gsed 's/undef/undef /g' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	$(MAKE) amalgamate
@@ -512,8 +512,6 @@ bool number_float(number_float_t val, const string_t& s);
 // called when a string is parsed; value is passed and can be safely moved away
 bool string(string_t& val);
 // called when a binary value is parsed; value is passed and can be safely moved away
 bool binary(binary_t& val);
 // called when an object or array begins or ends, resp. The number of elements is passed (or -1 if not known)
 bool start_object(std::size_t elements);
@@ -764,7 +762,6 @@ Supported types can be implicitly converted to JSON values.
 It is recommended to **NOT USE** implicit conversions **FROM** a JSON value.
 You can find more details about this recommendation [here](https://www.github.com/nlohmann/json/issues/958). 
 You can switch off implicit conversions by defining `JSON_USE_IMPLICIT_CONVERSIONS` to `0` before including the `json.hpp` header. When using CMake, you can also achieve this by setting the option `JSON_ImplicitConversions` to `OFF`.
 ```cpp
 // strings
@@ -1229,7 +1226,6 @@ The following compilers are currently used in continuous integration at [Travis]
 | Apple Clang 10.0.1 (clang-1001.0.46.4); Xcode 10.2.1            | macOS 10.14.4      | Travis         |
 | Apple Clang 11.0.0 (clang-1100.0.33.12); Xcode 11.2.1           | macOS 10.14.6      | Travis         |
 | Apple Clang 11.0.3 (clang-1103.0.32.59); Xcode 11.4.1           | macOS 10.15.4      | GitHub Actions |
 | Apple Clang 12.0.0 (clang-1200.0.22.7); Xcode 11.4.1            | macOS 10.15.5      | Travis         |
 | Clang 3.5.0 (3.5.0-4ubuntu2~trusty2)                            | Ubuntu 14.04.5 LTS | Travis         |
 | Clang 3.6.2 (3.6.2-svn240577-1~exp1)                            | Ubuntu 14.04.5 LTS | Travis         |
 | Clang 3.7.1 (3.7.1-svn253571-1~exp1)                            | Ubuntu 14.04.5 LTS | Travis         |
@@ -1257,7 +1253,6 @@ The following compilers are currently used in continuous integration at [Travis]
 | MSVC 19.16.27035.0 (15.9.21+g9802d43bc3 for .NET Framework)     | Windows-10.0.14393 | AppVeyor       |
 | MSVC 19.25.28614.0 (Build Engine version 16.5.0+d4cbfca49 for .NET Framework) | Windows-10.0.17763  | AppVeyor       |
 | MSVC 19.25.28614.0 (Build Engine version 16.5.0+d4cbfca49 for .NET Framework) | Windows-10.0.17763  | GitHub Actions |
 | MSVC 19.25.28614.0 (Build Engine version 16.5.0+d4cbfca49 for .NET Framework) with ClangCL 10.0.0 | Windows-10.0.17763  | GitHub Actions |
 ## License
@@ -1511,17 +1506,6 @@ I deeply appreciate the help of the following people.
 - [XyFreak](https://github.com/XyFreak) fixed a compiler warning.
 - [TotalCaesar659](https://github.com/TotalCaesar659) fixed links in the README.
 - [Tanuj Garg](https://github.com/tanuj208) improved the fuzzer coverage for UBSAN input.
 - [AODQ](https://github.com/AODQ) fixed a compiler warning.
 - [jwittbrodt](https://github.com/jwittbrodt) made `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE` inline.
 - [pfeatherstone](https://github.com/pfeatherstone) improved the upper bound of arguments of the `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`/`NLOHMANN_DEFINE_TYPE_INTRUSIVE` macros.
 - [Jan Procházka](https://github.com/jprochazk) fixed a bug in the CBOR parser for binary and string values.
 - [T0b1-iOS](https://github.com/T0b1-iOS) fixed a bug in the new hash implementation.
 - [Matthew Bauer](https://github.com/matthewbauer) adjusted the CBOR writer to create tags for binary subtypes.
 - [gatopeich](https://github.com/gatopeich) implemented an ordered map container for `nlohmann::ordered_json`.
 - [Érico Nogueira Rolim](https://github.com/ericonr) added support for pkg-config.
 - [KonanM](https://github.com/KonanM) proposed an implementation for the `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`/`NLOHMANN_DEFINE_TYPE_INTRUSIVE` macros.
 - [Guillaume Racicot](https://github.com/gracicot) implemented `string_view` support and allowed C++20 support.
 - [Alex Reinking](https://github.com/alexreinking) improved CMake support for `FetchContent`.
 Thanks a lot for helping out! Please [let me know](mailto:mail@nlohmann.me) if I forgot someone.
@@ -7,7 +7,6 @@ environment:
      platform: x86
      CXX_FLAGS: ""
      LINKER_FLAGS: ""
      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 14 2015
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
@@ -15,7 +14,6 @@ environment:
      platform: x86
      CXX_FLAGS: ""
      LINKER_FLAGS: ""
      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 15 2017
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -23,7 +21,6 @@ environment:
      platform: x86
      CXX_FLAGS: ""
      LINKER_FLAGS: ""
      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 16 2019
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -31,7 +28,6 @@ environment:
      platform: x64
      CXX_FLAGS: ""
      LINKER_FLAGS: ""
      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 16 2019
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -40,7 +36,6 @@ environment:
      platform: x86
      CXX_FLAGS: ""
      LINKER_FLAGS: ""
      CMAKE_OPTIONS: ""
      GENERATOR: Ninja
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -49,7 +44,6 @@ environment:
      platform: x86
      CXX_FLAGS: ""
      LINKER_FLAGS: ""
      CMAKE_OPTIONS: ""
      GENERATOR: Ninja
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -57,7 +51,6 @@ environment:
      platform: x86
      CXX_FLAGS: ""
      LINKER_FLAGS: ""
      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 14 2015
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -66,7 +59,6 @@ environment:
      name: with_win_header
      CXX_FLAGS: ""
      LINKER_FLAGS: ""
      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 14 2015
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
@@ -74,7 +66,6 @@ environment:
      platform: x86
      CXX_FLAGS: "/permissive- /std:c++latest /utf-8"
      LINKER_FLAGS: ""
      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 15 2017
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -82,15 +73,6 @@ environment:
      platform: x86
      CXX_FLAGS: ""
      LINKER_FLAGS: ""
      CMAKE_OPTIONS: "-DJSON_ImplicitConversions=OFF"
      GENERATOR: Visual Studio 16 2019
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      configuration: Release
      platform: x64
      CXX_FLAGS: ""
      LINKER_FLAGS: ""
      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 16 2019
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -98,7 +80,6 @@ environment:
      platform: x64
      CXX_FLAGS: ""
      LINKER_FLAGS: ""
      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 14 2015
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
@@ -106,7 +87,6 @@ environment:
      platform: x64
      CXX_FLAGS: "/permissive- /std:c++latest /Zc:__cplusplus /utf-8 /F4000000"
      LINKER_FLAGS: "/STACK:4000000"
      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 15 2017
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -114,7 +94,6 @@ environment:
      platform: x64
      CXX_FLAGS: ""
      LINKER_FLAGS: ""
      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 16 2019
 init:
@@ -133,7 +112,7 @@ before_build:
  # for with_win_header build, inject the inclusion of Windows.h to the single-header library
  - ps: if ($env:name -Eq "with_win_header") { $header_path = "single_include\nlohmann\json.hpp" }
  - ps: if ($env:name -Eq "with_win_header") { "#include <Windows.h>`n" + (Get-Content $header_path | Out-String) | Set-Content $header_path }
-  - if "%GENERATOR%"=="Ninja" (cmake . -G "%GENERATOR%" -DCMAKE_BUILD_TYPE="%configuration%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_EXE_LINKER_FLAGS="%LINKER_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On "%CMAKE_OPTIONS%") else (cmake . -G "%GENERATOR%" -A "%GENERATOR_PLATFORM%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_EXE_LINKER_FLAGS="%LINKER_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On "%CMAKE_OPTIONS%")
+  - if "%GENERATOR%"=="Ninja" (cmake . -G "%GENERATOR%" -DCMAKE_BUILD_TYPE="%configuration%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_EXE_LINKER_FLAGS="%LINKER_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On) else (cmake . -G "%GENERATOR%" -A "%GENERATOR_PLATFORM%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_EXE_LINKER_FLAGS="%LINKER_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On)
 build_script:
  - cmake --build . --config "%configuration%"
@@ -5,7 +5,7 @@
 #---------------------------------------------------------------------------
 DOXYFILE_ENCODING      = UTF-8
 PROJECT_NAME           = "JSON for Modern C++"
-PROJECT_NUMBER         = 3.9.0
+PROJECT_NUMBER         = 3.8.0
 PROJECT_BRIEF          =
 PROJECT_LOGO           =
 OUTPUT_DIRECTORY       = .
@@ -43,7 +43,7 @@ check_output: $(EXAMPLES:.cpp=.test)
 clean:
-	rm -fr me.nlohmann.json.docset html xml $(EXAMPLES:.cpp=)
+	rm -fr me.nlohmann.json.docset html $(EXAMPLES:.cpp=)
 ##########################################################################
@@ -1 +1 @@
-<a target="_blank" href="https://wandbox.org/permlink/shE8T6phAQiEzAad"><b>online</b></a>
+<a target="_blank" href="https://wandbox.org/permlink/EezQxM0Nzi8tTUEe"><b>online</b></a>
@@ -2,16 +2,16 @@
    "compiler": {
        "c++": "201103",
        "family": "clang",
-        "version": "12.0.0 (clang-1200.0.22.19)"
+        "version": "11.0.3 (clang-1103.0.32.62)"
    },
-    "copyright": "(C) 2013-2020 Niels Lohmann",
+    "copyright": "(C) 2013-2017 Niels Lohmann",
    "name": "JSON for Modern C++",
    "platform": "apple",
    "url": "https://github.com/nlohmann/json",
    "version": {
        "major": 3,
-        "minor": 9,
+        "minor": 8,
        "patch": 0,
-        "string": "3.9.0"
+        "string": "3.8.0"
    }
 }
@@ -332,4 +332,4 @@ Note that this table only lists those exceptions thrown due to the type. For ins
@author [Niels Lohmann](http://nlohmann.me)
@see https://github.com/nlohmann/json to download the source code
-@version 3.9.0
+@version 3.8.0
@@ -1,74 +0,0 @@
 # basic_json::dump
 ```cpp
 string_t dump(const int indent = -1,
              const char indent_char = ' ',
              const bool ensure_ascii = false,
              const error_handler_t error_handler = error_handler_t::strict) const
 ```
 Serialization function for JSON values. The function tries to mimic
 Python's `json.dumps()` function, and currently supports its `indent`
 and `ensure_ascii` parameters.
 ## Parameters
 `indent` (in)
 :   If `indent` is nonnegative, then array elements and object
    members will be pretty-printed with that indent level. An indent level of
    `0` will only insert newlines. `-1` (the default) selects the most compact
    representation.
 `indent_char` (in)
 :   The character to use for indentation if `indent` is
    greater than `0`. The default is ` ` (space).
 `ensure_ascii` (in)
 :   If `ensure_ascii` is true, all non-ASCII characters
    in the output are escaped with `\uXXXX` sequences, and the result consists
    of ASCII characters only.
 `error_handler` (in)
 :   how to react on decoding errors; there are three
    possible values: `strict` (throws and exception in case a decoding error
    occurs; default), `replace` (replace invalid UTF-8 sequences with U+FFFD),
    and `ignore` (ignore invalid UTF-8 sequences during serialization; all
    bytes are copied to the output unchanged).
 ## Return value
 string containing the serialization of the JSON value
 ## Exception safety
 Strong guarantee: if an exception is thrown, there are no
 changes to any JSON value.
 ## Complexity
 Linear.
 ## Notes
 Binary values are serialized as object containing two keys:
 - "bytes": an array of bytes as integers
 - "subtype": the subtype as integer or `#!json null` if the binary has no subtype
 ## Example
 ??? example
    The following example shows the effect of different `indent`,
    `indent_char`, and `ensure_ascii` parameters to the result of the
    serialization.
    ```cpp
    --8<-- "examples/dump.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/dump.output"
    ```
@@ -1,253 +0,0 @@
 # basic_json
 !!! note
    This page is under construction.
 Defined in header `<json.hpp>`
 ```cpp
 template<template<typename, typename, typename...> class ObjectType,  
         template<typename, typename...> class ArrayType,             
         class StringType, class BooleanType, class NumberIntegerType,
         class NumberUnsignedType, class NumberFloatType,             
         template<typename> class AllocatorType,                      
         template<typename, typename = void> class JSONSerializer,    
         class BinaryType>
 class basic_json
 ```
 ## Specializations
 - json
 - ordered_json
 ## Template parameters
 - ObjectType
 - ArrayType
 - StringType
 - BooleanType
 - NumberIntegerType
 - NumberUnsignedType
 - NumberFloatType
 - AllocatorType
 - JSONSerializer
 - BinaryType
 ## Iterator invalidation
 ## Member types
 - value_t
 - json_pointer
 - json_serializer
 - error_handler_t
 - cbor_tag_handler_t
 - initializer_list_t
 - input_format_t
 - json_sax_t
 ### Exceptions
 - exception
 - parse_error
 - invalid_iterator
 - type_error
 - out_of_range
 - other_error
 ### Container types
 - value_type
 - reference
 - const_reference
 - difference_type
 - size_type
 - allocator_type
 - pointer
 - const_pointer
 - iterator
 - const_iterator
 - reverse_iterator
 - const_reverse_iterator
 ### JSON value data types
 - object_comparator_t
 - object_t
 - array_t
 - string_t
 - boolean_t
 - number_integer_t
 - number_unsigned_t
 - number_float_t
 - binary_t
 ### Parser callback
 - parse_event_t
 - parser_callback_t
 ## Member functions
 - (constructor)
 - (destructor)
 - binary (static) - explicitly create a binary array
 - array (static) - explicitly create an array
 - object (static) - explicitly create an object
 - operator= - copy assignment
 ### Object inspection
 Functions to inspect the type of a JSON value.
 - type - return the type of the JSON value
 - is_primitive - return whether type is primitive
 - is_structured - return whether type is structured
 - is_null - return whether value is null
 - is_boolean - return whether value is a boolean
 - is_number - return whether value is a number
 - is_number_integer - return whether value is an integer number
 - is_number_unsigned - return whether value is an unsigned integer number
 - is_number_float - return whether value is a floating-point number
 - is_object - return whether value is an object
 - is_array - return whether value is an array
 - is_string - return whether value is a string
 - is_binary - return whether value is a binary array
 - is_discarded - return whether value is discarded
 - operator value_t - return the type of the JSON value
 ### Value access
 Direct access to the stored value of a JSON value.
 - get - get a value
 - get_to - get a value
 - get_ptr - get a pointer value
 - get_ref - get a reference value
 - operator ValueType - get a value
 - get_binary - get a binary value
 ### Element access
 Access to the JSON value
 - at - access specified array element with bounds checking
 - at - access specified object element with bounds checking
 - operator[] - access specified array element
 - operator[] - access specified object element
 - value - access specified object element with default value
 - front - access the first element
 - back - access the last element
 - erase - remove elements
 ### Lookup
 - find - find an element in a JSON object
 - count - returns the number of occurrences of a key in a JSON object
 - contains - check the existence of an element in a JSON object
 ### Iterators
 - begin - returns an iterator to the first element
 - cbegin - returns a const iterator to the first element
 - end - returns an iterator to one past the last element
 - cend - returns a const iterator to one past the last element
 - rbegin - returns an iterator to the reverse-beginning
 - rend - returns an iterator to the reverse-end
 - crbegin - returns a const iterator to the reverse-beginning
 - crend - returns a const iterator to the reverse-end
 - items - wrapper to access iterator member functions in range-based for
 ### Capacity
 - empty - checks whether the container is empty
 - size - returns the number of elements
 - max_size - returns the maximum possible number of elements
 ### Modifiers
 - clear - clears the contents
 - push_back - add an object to an array
 - operator+= - add an object to an array
 - push_back - add an object to an object
 - operator+= - add an object to an object
 - emplace_back - add an object to an array
 - emplace - add an object to an object if key does not exist
 - insert - inserts element
 - update - updates a JSON object from another object, overwriting existing keys 
 - swap - exchanges the values
 ### Lexicographical comparison operators
 - operator== - comparison: equal
 - operator!= - comparison: not equal
 - operator< - comparison: less than
 - operator<= - comparison: less than or equal
 - operator> - comparison: greater than
 - operator>= - comparison: greater than or equal
 ### Serialization
 - [**dump**](dump.md) - serialization
 - to_string - user-defined to_string function for JSON values
 ### Deserialization
 - [**parse**](parse.md) - deserialize from a compatible input
 - accept - check if the input is valid JSON
 - sax_parse - generate SAX events
 ### Convenience functions
 - type_name - return the type as string
 ### JSON Pointer functions
 - at - access specified object element with bounds checking via JSON Pointer
 - operator[] - access specified element via JSON Pointer
 - value - access specified object element with default value via JSON Pointer
 - flatten - return flattened JSON value
 - unflatten - unflatten a previously flattened JSON value
 ### JSON Patch functions
 - patch - applies a JSON patch
 - diff (static) - creates a diff as a JSON patch
 ### JSON Merge Patch functions
 - merge_patch - applies a JSON Merge Patch
 ## Static functions
 - [**meta**](meta.md) - returns version information on the library
 - get_allocator - returns the allocator associated with the container
 ### Binary formats
 - to_cbor - create a CBOR serialization of a given JSON value
 - to_msgpack - create a MessagePack serialization of a given JSON value
 - to_ubjson - create a UBJSON serialization of a given JSON value
 - to_bson - create a BSON serialization of a given JSON value
 - from_cbor - create a JSON value from an input in CBOR format
 - from_msgpack - create a JSON value from an input in MessagePack format
 - from_ubjson - create a JSON value from an input in UBJSON format
 - from_bson - create a JSON value from an input in BSON format
 ## Non-member functions
 - operator<<(std::ostream&) - serialize to stream
 - operator>>(std::istream&) - deserialize from stream
 ## Literals
 - operator""_json
 - operator""_json_pointer
 ## Helper classes
 - std::hash<nlohmann::json\>
 - std::less<nlohmann::value_t\>
 - std::swap<nlohmann::json\>
@@ -1,45 +0,0 @@
 # basic_json::meta
 ```cpp
 static basic_json meta();
 ```
 This function returns a JSON object with information about the library,
 including the version number and information on the platform and compiler.
 ## Return value
 JSON object holding version information
 key         | description
 ----------- | ---------------
 `compiler`  | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version).
 `copyright` | The copyright line for the library as string.
 `name`      | The name of the library as string.
 `platform`  | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.
 `url`       | The URL of the project as string.
 `version`   | The version of the library. It is an object with the following keys: `major`, `minor`, and `patch` as defined by [Semantic Versioning](http://semver.org), and `string` (the version string).
 ## Exception safety
 Strong guarantee: if an exception is thrown, there are no
 changes to any JSON value.
 ## Complexity
 Constant.
 ## Example
 The following code shows an example output of the `meta()`
 function.
 ```cpp
 --8<-- "examples/meta.cpp"
 ```
 Output:
 ```json
 --8<-- "examples/meta.output"
 ```
@@ -1,146 +0,0 @@
 # basic_json::parse
 ```cpp
 // (1)
 template<typename InputType>
 static basic_json parse(InputType&& i,
                        const parser_callback_t cb = nullptr,
                        const bool allow_exceptions = true,
                        const bool ignore_comments = false)
 // (2)
 template<typename IteratorType>
 static basic_json parse(IteratorType first,
                        IteratorType last,
                        const parser_callback_t cb = nullptr,
                        const bool allow_exceptions = true,
                        const bool ignore_comments = false)
 ```
 1. Deserialize from a compatible input.
 2. Deserialize from a pair of character iterators
    The value_type of the iterator must be a integral type with size of 1, 2 or
    4 bytes, which will be interpreted respectively as UTF-8, UTF-16 and UTF-32.
 ## Template parameters
 `InputType`
 :   A compatible input, for instance:
    - an `std::istream` object
    - a `FILE` pointer
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters
    - an object `obj` for which `begin(obj)` and `end(obj)` produces a valid pair of
      iterators.
 `IteratorType`
 :   Description
 ## Parameters
 `i` (in)
 :   Input to parse from.
 `cb` (in)
 :   a parser callback function of type `parser_callback_t`
    which is used to control the deserialization by filtering unwanted values
    (optional)
 `allow_exceptions` (in)
 :    whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)
 `ignore_comments` (in)
 :   whether comments should be ignored and treated
    like whitespace (`#!cpp true`) or yield a parse error (`#!cpp false`); (optional, `#!cpp false` by
    default)
 `first` (in)
 :   iterator to start of character range
 `last` (in)
 :   iterator to end of character range
 ## Return value
 Deserialized JSON value; in case of a parse error and `allow_exceptions`
 set to `#!cpp false`, the return value will be `value_t::discarded`.
 ## Exception safety
 ## Complexity
 Linear in the length of the input. The parser is a predictive
 LL(1) parser. The complexity can be higher if the parser callback function
 `cb` or reading from (1) the input `i` or (2) the iterator range [`first`, `last`] has a super-linear complexity.
 ## Notes
 (1) A UTF-8 byte order mark is silently ignored.
 ## Examples
 ??? example
    The example below demonstrates the `parse()` function reading
    from an array.
    ```cpp
    --8<-- "examples/parse__array__parser_callback_t.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/parse__array__parser_callback_t.output"
    ```
 ??? example
    The example below demonstrates the `parse()` function with
    and without callback function.
    ```cpp
    --8<-- "examples/parse__string__parser_callback_t.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/parse__string__parser_callback_t.output"
    ```
 ??? example
    The example below demonstrates the `parse()` function with
    and without callback function.
    ```cpp
    --8<-- "examples/parse__istream__parser_callback_t.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/parse__istream__parser_callback_t.output"
    ```
 ??? example
    The example below demonstrates the `parse()` function reading
    from a contiguous container.
    ```cpp
    --8<-- "examples/parse__contiguouscontainer__parser_callback_t.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/parse__contiguouscontainer__parser_callback_t.output"
    ```
 ## History
 (1) version 2.0.3 (contiguous containers); version 3.9.0 allowed to ignore comments.
@@ -92,10 +92,6 @@ There are two macros to make your life easier as long as you (1) want to use a J
 In both macros, the first parameter is the name of the class/struct, and all remaining parameters name the members.
 !!! note
    At most 64 member variables can be passed to `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE` or `NLOHMANN_DEFINE_TYPE_INTRUSIVE`.
 ??? example
    The `to_json`/`from_json` functions for the `person` struct above can be created with:
@@ -64,6 +64,7 @@ binary          | *size*: 4294967296..18446744073709551615   | byte string (8 by
 	If NaN or Infinity are stored inside a JSON number, they are serialized properly. This behavior differs from the normal JSON serialization which serializes NaN or Infinity to `null`.
 !!! info "Unused CBOR types"
 	The following CBOR types are not used in the conversion:
@@ -76,16 +77,13 @@ binary          | *size*: 4294967296..18446744073709551615   | byte string (8 by
      - bignum (0xC2..0xC3)
      - decimal fraction (0xC4)
      - bigfloat (0xC5)
      - tagged items (0xC6..0xD4, 0xD8..0xDB)
      - expected conversions (0xD5..0xD7)
      - simple values (0xE0..0xF3, 0xF8)
      - undefined (0xF7)
      - half-precision floats (0xF9)
      - break (0xFF)
 !!! info "Tagged items"
    Binary subtypes will be serialized as tagged items. See [binary values](../binary_values.md#cbor) for an example.
 ??? example
    ```cpp
@@ -152,6 +150,7 @@ Double-Precision Float | number_float    | 0xFB
     - bignum (0xC2..0xC3)
     - decimal fraction (0xC4)
     - bigfloat (0xC5)
     - tagged items (0xC6..0xD4, 0xD8..0xDB)
     - expected conversions (0xD5..0xD7)
     - simple values (0xE0..0xF3, 0xF8)
     - undefined (0xF7)
@@ -160,10 +159,6 @@ Double-Precision Float | number_float    | 0xFB
 	CBOR allows map keys of any type, whereas JSON only allows strings as keys in object values. Therefore, CBOR maps with keys other than UTF-8 strings are rejected.
 !!! warning "Tagged items"
    Tagged items will throw a parse error by default. However, they can be ignored by passing `cbor_tag_handler_t::ignore` to function `from_cbor`.
 ??? example
    ```cpp
@@ -28,7 +28,6 @@ number_unsigned | 128..255                          | uint8       | `U`
 number_unsigned | 256..32767                        | int16       | `I`
 number_unsigned | 32768..2147483647                 | int32       | `l`
 number_unsigned | 2147483648..9223372036854775807   | int64       | `L`
 number_unsigned | 2147483649..18446744073709551615  | high-precision | `H`
 number_float    | *any value*                       | float64     | `D`
 string          | *with shortest length indicator*  | string      | `S`
 array           | *see notes on optimized format*   | array       | `[`
@@ -45,6 +44,7 @@ object          | *see notes on optimized format*   | map         | `{`
 	The following values can **not** be converted to a UBJSON value:
      - strings with more than 9223372036854775807 bytes (theoretical)
      - unsigned integer numbers above 9223372036854775807
 !!! info "Unused UBJSON markers"
@@ -158,14 +158,14 @@ JSON does not have a binary type, and this library does not introduce a new type
 ### CBOR
-[CBOR](binary_formats/cbor.md) supports binary values, but no subtypes. Subtypes will be serialized as tags. Any binary value will be serialized as byte strings. The library will choose the smallest representation using the length of the byte array.
+[CBOR](binary_formats/cbor.md) supports binary values, but no subtypes. Any binary value will be serialized as byte strings. The library will choose the smallest representation using the length of the byte array.
 ??? example
    Code:
    ```cpp
-    // create a binary value of subtype 42
+    // create a binary value of subtype 42 (will be ignored by CBOR)
    json j;
    j["binary"] = json::binary({0xCA, 0xFE, 0xBA, 0xBE}, 42);
@@ -173,18 +173,17 @@ JSON does not have a binary type, and this library does not introduce a new type
    auto v = json::to_cbor(j);      
    ```
-    `v` is a `std::vector<std::uint8t>` with the following 15 elements:
+    `v` is a `std::vector<std::uint8t>` with the following 13 elements:
    ```c
    0xA1                                   // map(1)
        0x66                               // text(6)
            0x62 0x69 0x6E 0x61 0x72 0x79  // "binary"
        0xD8 0x2A                          // tag(42)
        0x44                               // bytes(4)
            0xCA 0xFE 0xBA 0xBE            // content
    ```
-    Note that the subtype is serialized as tag. However, parsing tagged values yield a parse error unless `json::cbor_tag_handler_t::ignore` is passed to `json::from_cbor`.
+    Note the subtype (42) is **not** serialized, and deserializing `v` would yield the following value:
    ```json
    {
@@ -1,83 +0,0 @@
 # Comments
 This library does not support comments *by default*. It does so for three reasons:
 1. Comments are not part of the [JSON specification](https://tools.ietf.org/html/rfc8259). You may argue that `//` or `/* */` are allowed in JavaScript, but JSON is not JavaScript.
 2. This was not an oversight: Douglas Crockford [wrote on this](https://plus.google.com/118095276221607585885/posts/RK8qyGVaGSr) in May 2012:
 	> 	I removed comments from JSON because I saw people were using them to hold parsing directives, a practice which would have destroyed interoperability.  I know that the lack of comments makes some people sad, but it shouldn't. 
 	> 	Suppose you are using JSON to keep configuration files, which you would like to annotate. Go ahead and insert all the comments you like. Then pipe it through JSMin before handing it to your JSON parser.
 3. It is dangerous for interoperability if some libraries would add comment support while others don't. Please check [The Harmful Consequences of the Robustness Principle](https://tools.ietf.org/html/draft-iab-protocol-maintenance-01) on this.
 However, you can pass set parameter `ignore_comments` to `#!c true` in the parse function to ignore `//` or `/* */` comments. Comments will then be treated as whitespace.
 !!! example
    Consider the following JSON with comments.
    ```json
    {
        // update in 2006: removed Pluto
        "planets": ["Mercury", "Venus", "Earth", "Mars",
                    "Jupiter", "Uranus", "Neptune" /*, "Pluto" */]
    }
    ```
    When calling `parse` without additional argument, a parse error exception is thrown. If `skip_comments` is set to `#! true`, the comments are skipped during parsing:
    ```cpp
    #include <iostream>
    #include "json.hpp"
    using json = nlohmann::json;
    int main()
    {
        std::string s = R"(
        {
            // update in 2006: removed Pluto
            "planets": ["Mercury", "Venus", "Earth", "Mars",
                        "Jupiter", "Uranus", "Neptune" /*, "Pluto" */]
        }
        )";
        try
        {
            json j = json::parse(s);
        }
        catch (json::exception &e)
        {
            std::cout << e.what() << std::endl;
        }
        json j = json::parse(s,
                             /* callback */ nullptr,
                             /* allow exceptions */ true,
                             /* skip_comments */ true);
        std::cout << j.dump(2) << '\n';
    }
    ```
    Output:
    ```
    [json.exception.parse_error.101] parse error at line 3, column 9:
    syntax error while parsing object key - invalid literal;
    last read: '<U+000A>    {<U+000A>        /'; expected string literal
    ```
    ```json
    {
      "planets": [
        "Mercury",
        "Venus",
        "Earth",
        "Mars",
        "Jupiter",
        "Uranus",
        "Neptune"
      ]
    }
    ```
@@ -1,77 +0,0 @@
 # Checked access: at
 ## Overview
 The `#!cpp at()` member function performs checked access; that is, it returns a reference to the desired value if it exists and throws a [`basic_json::out_of_range` exception](../../home/exceptions.md#out-of-range) otherwise.
 ??? example
    Consider the following JSON value:
    ```json
    {
        "name": "Mary Smith",
        "age": 42,
        "hobbies": ["hiking", "reading"]
    }
    ```
    Assume the value is parsed to a `json` variable `j`.
    | expression | value |
    | ---------- | ----- |
    | `#!cpp j`  | `#!json {"name": "Mary Smith", "age": 42, "hobbies": ["hiking", "reading"]}` |
    | `#!cpp j.at("name")`  | `#!json "Mary Smith"` |
    | `#!cpp j.at("age")`  | `#!json 42` |
    | `#!cpp j.at("hobbies")`  | `#!json ["hiking", "reading"]` |
    | `#!cpp j.at("hobbies").at(0)`  | `#!json "hiking"` |
    | `#!cpp j.at("hobbies").at(1)`  | `#!json "reading"` |
 The return value is a reference, so it can be modify the original value.
 ??? example
    ```cpp
    j.at("name") = "John Smith";
    ```
    This code produces the following JSON value:
    ```json
    {
        "name": "John Smith",
        "age": 42,
        "hobbies": ["hiking", "reading"]
    }
    ```
 When accessing an invalid index (i.e., and index greater than or equal to the array size) or the passed object key is non-existing, an exception is thrown.
 ??? example
    ```cpp
    j.at("hobbies").at(3) = "cooking";
    ```
    This code produces the following exception:
    ```
    [json.exception.out_of_range.401] array index 3 is out of range
    ```
 ## Notes
 !!! failure "Exceptions"
    - `at` can only be used with objects (with a string argument) or with arrays (with a numeric argument). For other types, a [`basic_json::type_error`](../../home/exceptions.md#jsonexceptiontype_error304) is thrown.
    - [`basic_json::out_of_range` exception](../../home/exceptions.md#out-of-range) exceptions are thrown if the provided key is not found in an object or the provided index is invalid.
 ## Summary
 | scenario | non-const value | const value |
 | -------- | ------------- | ----------- |
 | access to existing object key | reference to existing value is returned | const reference to existing value is returned |
 | access to valid array index | reference to existing value is returned | const reference to existing value is returned |
 | access to non-existing object key | `basic_json::out_of_range` exception is thrown | `basic_json::out_of_range` exception is thrown |
 | access to invalid array index | `basic_json::out_of_range` exception is thrown | `basic_json::out_of_range` exception is thrown |
@@ -1,32 +0,0 @@
 # Access with default value: value
 ## Overview
 In many situations such as configuration files, missing values are not exceptional, but may be treated as if a default value was present.
 ??? example
    Consider the following JSON value:
    ```json
    {
        "logOutput": "result.log",
        "append": true
    }
    ```
    Assume the value is parsed to a `json` variable `j`.
    | expression | value |
    | ---------- | ----- |
    | `#!cpp j`  | `#!json {"logOutput": "result.log", "append": true}` |
    | `#!cpp j.value("logOutput", "logfile.log")`  | `#!json "result.log"` |
    | `#!cpp j.value("append", true)`  | `#!json true` |
    | `#!cpp j.value("append", false)`  | `#!json true` |
    | `#!cpp j.value("logLevel", "verbose")`  | `#!json "verbose"` |
 ## Note
 !!! failure "Exceptions"
    - `value` can only be used with objects. For other types, a [`basic_json::type_error`](../../home/exceptions.md#jsonexceptiontype_error306) is thrown.
@@ -1,9 +0,0 @@
 # Overview
 There are many ways elements in a JSON value can be accessed:
 - unchecked access via [`operator[]`](unchecked_access.md)
 - checked access via [`at`](checked_access.md)
 - access with default value via [`value`](default_value.md)
 - iterators
 - JSON pointers
@@ -1,102 +0,0 @@
 # Unchecked access: operator[]
 ## Overview
 Elements in a JSON object and a JSON array can be accessed via `#!cpp operator[]` similar to a `#!cpp std::map` and a `#!cpp std::vector`, respectively.
 ??? example
    Consider the following JSON value:
    ```json
    {
        "name": "Mary Smith",
        "age": 42,
        "hobbies": ["hiking", "reading"]
    }
    ```
    Assume the value is parsed to a `json` variable `j`.
    | expression | value |
    | ---------- | ----- |
    | `#!cpp j`  | `#!json {"name": "Mary Smith", "age": 42, "hobbies": ["hiking", "reading"]}` |
    | `#!cpp j["name"]`  | `#!json "Mary Smith"` |
    | `#!cpp j["age"]`  | `#!json 42` |
    | `#!cpp j["hobbies"]`  | `#!json ["hiking", "reading"]` |
    | `#!cpp j["hobbies"][0]`  | `#!json "hiking"` |
    | `#!cpp j["hobbies"][1]`  | `#!json "reading"` |
 The return value is a reference, so it can be modify the original value. In case the passed object key is non-existing, a `#!json null` value is inserted which can be immediately be overwritten.
 ??? example
    ```cpp
    j["name"] = "John Smith";
    j["maidenName"] = "Jones";
    ```
    This code produces the following JSON value:
    ```json
    {
        "name": "John Smith",
        "maidenName": "Jones",
        "age": 42,
        "hobbies": ["hiking", "reading"]
    }
    ```
 When accessing an invalid index (i.e., and index greater than or equal to the array size), the JSON array is resized such that the passed index is the new maximal index. Intermediate values are filled with `#!json null`.
 ??? example
    ```cpp
    j["hobbies"][0] = "running";
    j["hobbies"][3] = "cooking";
    ```
    This code produces the following JSON value:
    ```json
    {
        "name": "John Smith",
        "maidenName": "Jones",
        "age": 42,
        "hobbies": ["running", "reading", null, "cooking"]
    }
    ```
 ## Notes
 !!! info "Design rationale"
    The library behaves differently to `#!cpp std::vector` and `#!cpp std::map`:
    - `#!cpp std::vector::operator[]` never inserts a new element.
    - `#!cpp std::map::operator[]` is not available for const values.
    The type `#!cpp json` wraps all JSON value types. It would be impossible to remove `operator[]` for const objects. At the same time, inserting elements for non-const objects is really convenient as it avoids awkward `insert` calls. To this end, we decided to have an inserting non-const behavior for both arrays and objects.
 !!! info
    The access is unchecked. In case the passed object key does not exist or the passed array index is invalid, no exception is thrown.
 !!! danger
    - It is **undefined behavior** to access a const object with a non-existing key.
    - It is **undefined behavior** to access a const array with an invalid index.
    - In debug mode, an **assertion** will fire in both cases. You can disable assertions by defining the preprocessor symbol `#!cpp NDEBUG` or redefine the macro [`JSON_ASSERT(x)`](../macros.md#json_assertx).
 !!! failure "Exceptions"
    `operator[]` can only be used with objects (with a string argument) or with arrays (with a numeric argument). For other types, a [`basic_json::type_error`](../../home/exceptions.md#jsonexceptiontype_error305) is thrown.
 ## Summary
 | scenario | non-const value | const value |
 | -------- | ------------- | ----------- |
 | access to existing object key | reference to existing value is returned | const reference to existing value is returned |
 | access to valid array index | reference to existing value is returned | const reference to existing value is returned |
 | access to non-existing object key | reference to newly inserted `#!json null` value is returned | **undefined behavior**; assertion in debug mode |
 | access to invalid array index | reference to newly inserted `#!json null` value is returned; any index between previous maximal index and passed index are filled with `#!json null` | **undefined behavior**; assertion in debug mode |
@@ -2,10 +2,6 @@
 Some aspects of the library can be configured by defining preprocessor macros before including the `json.hpp` header.
 ## `JSON_ASSERT(x)`
 The default value is `#!cpp assert(x)`.
 ## `JSON_CATCH_USER(exception)`
 This macro overrides `#!cpp catch` calls inside the library. The argument is the type of the exception to catch. As of version 3.8.0, the library only catches `std::out_of_range` exceptions internally to rethrow them as [`json::out_of_range`](../home/exceptions.md#out-of-range) exceptions. The macro is always followed by a scope.
@@ -36,26 +32,6 @@ This macro overrides `#!cpp try` calls inside the library. It has no arguments a
 See [Switch off exceptions](../home/exceptions.md#switch-off-exceptions) for an example.
 ## `JSON_USE_IMPLICIT_CONVERSIONS`
 When defined to `0`, implicit conversions are switched off. By default, implicit conversions are switched on.
 ??? example
    This is an example for an implicit conversion:
    ```cpp
    json j = "Hello, world!";
    std::string s = j;
    ```
    When `JSON_USE_IMPLICIT_CONVERSIONS` is defined to `0`, the code above does no longer compile. Instead, it must be written like this:
    ```cpp
    json j = "Hello, world!";
    auto s = j.get<std::string>();
    ```
 ## `NLOHMANN_DEFINE_TYPE_INTRUSIVE(type, member...)`
 This macro can be used to simplify the serialization/deserialization of types if (1) want to use a JSON object as serialization and (2) want to use the member variable names as object keys in that object.
@@ -1,67 +0,0 @@
 # Object Order
 The [JSON standard](https://tools.ietf.org/html/rfc8259.html) defines objects as "an unordered collection of zero or more name/value pairs". As such, an implementation does not need to preserve any specific order of object keys.
 The default type `nlohmann::json` uses a `std::map` to store JSON objects, and thus stores object keys **sorted alphabetically**.
 ??? example
    ```cpp
    #include <iostream>
    #include "json.hpp"
    using json = nlohmann::json;
    int main()
    {
        json j;
        j["one"] = 1;
        j["two"] = 2;
        j["three"] = 3;
        std::cout << j.dump(2) << '\n';
    }
    ```
    Output:
    ```json
    {
      "one": 1,
      "three": 3,
      "two": 2
    }
    ```
 If you do want to preserve the **insertion order**, you can try the type [`nlohmann::ordered_json`](https://github.com/nlohmann/json/issues/2179).
 ??? example
    ```cpp
    #include <iostream>
    #include <nlohmann/json.hpp>
    using ordered_json = nlohmann::ordered_json;
    int main()
    {
        ordered_json j;
        j["one"] = 1;
        j["two"] = 2;
        j["three"] = 3;
        std::cout << j.dump(2) << '\n';
    }
    ```
    Output:
    ```json
    {
      "one": 1,
      "two": 2,
      "three": 3
    }
    ```
 Alternatively, you can use a more sophisticated ordered map like [`tsl::ordered_map`](https://github.com/Tessil/ordered-map) ([integration](https://github.com/nlohmann/json/issues/546#issuecomment-304447518)) or [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map) ([integration](https://github.com/nlohmann/json/issues/485#issuecomment-333652309)).
@@ -14,7 +14,6 @@ interface json::sax_t {
    + {abstract} bool number_float(number_float_t val, const string_t& s)
    + {abstract} bool string(string_t& val)
    + {abstract} bool binary(binary_t& val)
    + {abstract} bool start_object(std::size_t elements)
    + {abstract} bool end_object()
@@ -42,8 +41,6 @@ bool number_float(number_float_t val, const string_t& s);
 // called when a string is parsed; value is passed and can be safely moved away
 bool string(string_t& val);
 // called when a binary value is parsed; value is passed and can be safely moved away
 bool binary(binary& val);
 // called when an object or array begins or ends, resp. The number of elements is passed (or -1 if not known)
 bool start_object(std::size_t elements);
@@ -279,16 +279,6 @@ The parsing of the corresponding BSON record type is not implemented (yet).
    [json.exception.parse_error.114] parse error at byte 5: Unsupported BSON record type 0xFF
    ```
 ### json.exception.parse_error.115
 A UBJSON high-precision number could not be parsed.
 !!! failure "Example message"
    ```
    [json.exception.parse_error.115] parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1A
    ```
 ## Iterator errors
 This exception is thrown if iterators passed to a library function do not match
@@ -775,10 +765,6 @@ UBJSON and BSON only support integer numbers up to 9223372036854775807.
    number overflow serializing '9223372036854775808'
    ```
 !!! note
    Since version 3.9.0, integer numbers beyond int64 are serialized as high-precision UBJSON numbers, and this exception does not further occur. 
 ### json.exception.out_of_range.408
 The size (following `#`) of an UBJSON array or object exceeds the maximal capacity.
@@ -2,6 +2,31 @@
 ## Limitations
 ### Comments
 !!! question "Questions"
 	- Why does the library not support comments?
 	- Can you add support for JSON5/JSONC/HOCON so that comments are supported?
 This library does not support comments. It does so for three reasons:
 1. Comments are not part of the [JSON specification](https://tools.ietf.org/html/rfc8259). You may argue that `//` or `/* */` are allowed in JavaScript, but JSON is not JavaScript.
 2. This was not an oversight: Douglas Crockford [wrote on this](https://plus.google.com/118095276221607585885/posts/RK8qyGVaGSr) in May 2012:
 	> 	I removed comments from JSON because I saw people were using them to hold parsing directives, a practice which would have destroyed interoperability.  I know that the lack of comments makes some people sad, but it shouldn't. 
 	> 	Suppose you are using JSON to keep configuration files, which you would like to annotate. Go ahead and insert all the comments you like. Then pipe it through JSMin before handing it to your JSON parser.
 3. It is dangerous for interoperability if some libraries would add comment support while others don't. Please check [The Harmful Consequences of the Robustness Principle](https://tools.ietf.org/html/draft-iab-protocol-maintenance-01) on this.
 This library will not support comments in the future. If you wish to use comments, I see three options:
 1. Strip comments before using this library.
 2. Use a different JSON library with comment support.
 3. Use a format that natively supports comments (e.g., YAML or JSON5).
 ### Relaxed parsing
 !!! question
@@ -44,6 +69,18 @@ No, this is not possible. See <https://github.com/nlohmann/json/issues/932> for
 ## Serialization issues
 ### Order of object keys
 !!! question "Questions"
 	- Why are object keys sorted?
 	- Why is the insertion order of object keys not preserved?
 By default, the library does not preserve the **insertion order of object elements**. This is standards-compliant, as the [JSON standard](https://tools.ietf.org/html/rfc8259.html) defines objects as "an unordered collection of zero or more name/value pairs".
 If you do want to preserve the insertion order, you can specialize the object type with containers like [`tsl::ordered_map`](https://github.com/Tessil/ordered-map) ([integration](https://github.com/nlohmann/json/issues/546#issuecomment-304447518)) or [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map) ([integration](https://github.com/nlohmann/json/issues/485#issuecomment-333652309)).
 ### Number precision
 !!! question
@@ -4,7 +4,7 @@
 The class is licensed under the [MIT License](http://opensource.org/licenses/MIT):
-Copyright &copy; 2013-2020 [Niels Lohmann](http://nlohmann.me)
+Copyright &copy; 2013-2019 [Niels Lohmann](http://nlohmann.me)
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
@@ -3,8 +3,5 @@ import os.path
 def copy_doxygen(*args, **kwargs):
-    doxygen_dir = os.path.join(kwargs['config']['site_dir'], 'doxygen')
+    shutil.copytree('../html', os.path.join(kwargs['config']['site_dir'], 'doxygen'))
-    if not os.path.isdir(doxygen_dir) or not os.listdir(doxygen_dir):
+    print('Copy Doxygen complete')
        print('Copy Doxygen files...')
        shutil.copytree('../html', doxygen_dir)
        print('Copy Doxygen complete')
@@ -44,24 +44,17 @@ nav:
      - features/binary_formats/messagepack.md
      - features/binary_formats/ubjson.md
    - features/binary_values.md
    - features/comments.md
    - Element Access:
      - features/element_access/index.md
      - features/element_access/unchecked_access.md
      - features/element_access/checked_access.md
      - features/element_access/default_value.md
    - features/iterators.md
    - features/json_pointer.md
    - features/json_patch.md
    - features/merge_patch.md
    - features/object_order.md
    - Parsing:
        - features/parsing/index.md
        - features/parsing/parse_exceptions.md
        - features/parsing/parser_callbacks.md
        - features/parsing/sax_interface.md
    - features/enum_conversion.md
    - features/macros.md
    - Parsing:
      - features/parsing/index.md
      - features/parsing/parse_exceptions.md
      - features/parsing/parser_callbacks.md
      - features/parsing/sax_interface.md
    - features/types.md
  - Integration:
    - integration/index.md
@@ -69,12 +62,6 @@ nav:
    - integration/package_managers.md
  - Doxygen:
    - doxygen/index.html
  - API:
      - basic_json:
        - api/basic_json/index.md
        - api/basic_json/dump.md
        - api/basic_json/meta.md
        - api/basic_json/parse.md
 # Extras
 extra:
@@ -93,7 +80,6 @@ extra:
 # Extensions
 markdown_extensions:
  - admonition
  - def_list
  - codehilite:
      guess_lang: false
  - toc:
@@ -34,7 +34,7 @@ void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
 // overloads for basic_json template parameters
 template < typename BasicJsonType, typename ArithmeticType,
-           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
+           enable_if_t < (std::is_arithmetic<ArithmeticType>::value || is_128_bit_integral<ArithmeticType>::value)&&
                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
                         int > = 0 >
 void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
@@ -128,7 +128,7 @@ void from_json(const BasicJsonType& j, EnumType& e)
 // forward_list doesn't have an insert method
 template<typename BasicJsonType, typename T, typename Allocator,
-         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+         enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
 void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
@@ -145,7 +145,7 @@ void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
 // valarray doesn't have an insert method
 template<typename BasicJsonType, typename T,
-         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+         enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
 void from_json(const BasicJsonType& j, std::valarray<T>& l)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
@@ -153,11 +153,7 @@ void from_json(const BasicJsonType& j, std::valarray<T>& l)
        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
    }
    l.resize(j.size());
-    std::transform(j.begin(), j.end(), std::begin(l),
+    std::copy(j.begin(), j.end(), std::begin(l));
                   [](const BasicJsonType & elem)
    {
        return elem.template get<T>();
    });
 }
 template<typename BasicJsonType, typename T, std::size_t N>
@@ -97,7 +97,6 @@ json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vect
 json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xF8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read.
 json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read.
 json.exception.parse_error.114 | parse error: Unsupported BSON record type 0x0F | The parsing of the corresponding BSON record type is not implemented (yet).
 json.exception.parse_error.115 | parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1A | A UBJSON high-precision number could not be parsed.
@note For an input with n bytes, 1 is the index of the first character and n+1
      is the index of the terminating null byte or the end of file. This also
@@ -286,7 +285,7 @@ json.exception.out_of_range.403 | key 'foo' not found | The provided key was not
 json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved.
 json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value.
 json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF.
-json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON and BSON only support integer numbers up to 9223372036854775807. (until version 3.8.0) |
+json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON and BSON only support integer numbers up to 9223372036854775807. |
 json.exception.out_of_range.408 | excessive array size: 8658170730974374167 | The size (following `#`) of an UBJSON array or object exceeds the maximal capacity. |
 json.exception.out_of_range.409 | BSON key cannot contain code point U+0000 (at byte 2) | Key identifiers to be serialized to BSON cannot contain code point U+0000, since the key is stored as zero-terminated c-string |
@@ -1,117 +0,0 @@
 #pragma once
 #include <cstddef> // size_t, uint8_t
 #include <functional> // hash
 namespace nlohmann
 {
 namespace detail
 {
 // boost::hash_combine
 inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
 {
    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
    return seed;
 }
 /*!
@brief hash a JSON value
 The hash function tries to rely on std::hash where possible. Furthermore, the
 type of the JSON value is taken into account to have different hash values for
 null, 0, 0U, and false, etc.
@tparam BasicJsonType basic_json specialization
@param j JSON value to hash
@return hash value of j
 */
 template<typename BasicJsonType>
 std::size_t hash(const BasicJsonType& j)
 {
    using string_t = typename BasicJsonType::string_t;
    using number_integer_t = typename BasicJsonType::number_integer_t;
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using number_float_t = typename BasicJsonType::number_float_t;
    const auto type = static_cast<std::size_t>(j.type());
    switch (j.type())
    {
        case BasicJsonType::value_t::null:
        case BasicJsonType::value_t::discarded:
        {
            return combine(type, 0);
        }
        case BasicJsonType::value_t::object:
        {
            auto seed = combine(type, j.size());
            for (const auto& element : j.items())
            {
                const auto h = std::hash<string_t> {}(element.key());
                seed = combine(seed, h);
                seed = combine(seed, hash(element.value()));
            }
            return seed;
        }
        case BasicJsonType::value_t::array:
        {
            auto seed = combine(type, j.size());
            for (const auto& element : j)
            {
                seed = combine(seed, hash(element));
            }
            return seed;
        }
        case BasicJsonType::value_t::string:
        {
            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
            return combine(type, h);
        }
        case BasicJsonType::value_t::boolean:
        {
            const auto h = std::hash<bool> {}(j.template get<bool>());
            return combine(type, h);
        }
        case BasicJsonType::value_t::number_integer:
        {
            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
            return combine(type, h);
        }
        case nlohmann::detail::value_t::number_unsigned:
        {
            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
            return combine(type, h);
        }
        case nlohmann::detail::value_t::number_float:
        {
            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
            return combine(type, h);
        }
        case nlohmann::detail::value_t::binary:
        {
            auto seed = combine(type, j.get_binary().size());
            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
            seed = combine(seed, h);
            seed = combine(seed, j.get_binary().subtype());
            for (const auto byte : j.get_binary())
            {
                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
            }
            return seed;
        }
        default: // LCOV_EXCL_LINE
            JSON_ASSERT(false); // LCOV_EXCL_LINE
    }
 }
 }  // namespace detail
 }  // namespace nlohmann
@@ -15,7 +15,6 @@
 #include <nlohmann/detail/exceptions.hpp>
 #include <nlohmann/detail/input/input_adapters.hpp>
 #include <nlohmann/detail/input/json_sax.hpp>
 #include <nlohmann/detail/input/lexer.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
 #include <nlohmann/detail/meta/is_sax.hpp>
 #include <nlohmann/detail/value_t.hpp>
@@ -25,13 +24,6 @@ namespace nlohmann
 namespace detail
 {
 /// how to treat CBOR tags
 enum class cbor_tag_handler_t
 {
    error,  ///< throw a parse_error exception in case of a tag
    ignore   ///< ignore tags
 };
 /*!
@brief determine system byte order
@@ -86,15 +78,13 @@ class binary_reader
    @param[in] format  the binary format to parse
    @param[in] sax_    a SAX event processor
    @param[in] strict  whether to expect the input to be consumed completed
    @param[in] tag_handler  how to treat CBOR tags
    @return
    */
    JSON_HEDLEY_NON_NULL(3)
    bool sax_parse(const input_format_t format,
                   json_sax_t* sax_,
-                   const bool strict = true,
+                   const bool strict = true)
                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
    {
        sax = sax_;
        bool result = false;
@@ -106,7 +96,7 @@ class binary_reader
                break;
            case input_format_t::cbor:
-                result = parse_cbor_internal(true, tag_handler);
+                result = parse_cbor_internal();
                break;
            case input_format_t::msgpack:
@@ -394,14 +384,12 @@ class binary_reader
    /*!
    @param[in] get_char  whether a new character should be retrieved from the
-                         input (true) or whether the last read character should
+                         input (true, default) or whether the last read
-                         be considered instead (false)
+                         character should be considered instead
    @param[in] tag_handler how CBOR tags should be treated
    @return whether a valid CBOR value was passed to the SAX parser
    */
-    bool parse_cbor_internal(const bool get_char,
+    bool parse_cbor_internal(const bool get_char = true)
                             const cbor_tag_handler_t tag_handler)
    {
        switch (get_char ? get() : current)
        {
@@ -607,34 +595,34 @@ class binary_reader
            case 0x95:
            case 0x96:
            case 0x97:
-                return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+                return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
            case 0x98: // array (one-byte uint8_t for n follows)
            {
                std::uint8_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len));
            }
            case 0x99: // array (two-byte uint16_t for n follow)
            {
                std::uint16_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len));
            }
            case 0x9A: // array (four-byte uint32_t for n follow)
            {
                std::uint32_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len));
            }
            case 0x9B: // array (eight-byte uint64_t for n follow)
            {
                std::uint64_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len));
            }
            case 0x9F: // array (indefinite length)
-                return get_cbor_array(std::size_t(-1), tag_handler);
+                return get_cbor_array(std::size_t(-1));
            // map (0x00..0x17 pairs of data items follow)
            case 0xA0:
@@ -661,101 +649,34 @@ class binary_reader
            case 0xB5:
            case 0xB6:
            case 0xB7:
-                return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+                return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
            case 0xB8: // map (one-byte uint8_t for n follows)
            {
                std::uint8_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len));
            }
            case 0xB9: // map (two-byte uint16_t for n follow)
            {
                std::uint16_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len));
            }
            case 0xBA: // map (four-byte uint32_t for n follow)
            {
                std::uint32_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len));
            }
            case 0xBB: // map (eight-byte uint64_t for n follow)
            {
                std::uint64_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len));
            }
            case 0xBF: // map (indefinite length)
-                return get_cbor_object(std::size_t(-1), tag_handler);
+                return get_cbor_object(std::size_t(-1));
            case 0xC6: // tagged item
            case 0xC7:
            case 0xC8:
            case 0xC9:
            case 0xCA:
            case 0xCB:
            case 0xCC:
            case 0xCD:
            case 0xCE:
            case 0xCF:
            case 0xD0:
            case 0xD1:
            case 0xD2:
            case 0xD3:
            case 0xD4:
            case 0xD8: // tagged item (1 bytes follow)
            case 0xD9: // tagged item (2 bytes follow)
            case 0xDA: // tagged item (4 bytes follow)
            case 0xDB: // tagged item (8 bytes follow)
            {
                switch (tag_handler)
                {
                    case cbor_tag_handler_t::error:
                    {
                        auto last_token = get_token_string();
                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
                    }
                    case cbor_tag_handler_t::ignore:
                    {
                        switch (current)
                        {
                            case 0xD8:
                            {
                                std::uint8_t len{};
                                get_number(input_format_t::cbor, len);
                                break;
                            }
                            case 0xD9:
                            {
                                std::uint16_t len{};
                                get_number(input_format_t::cbor, len);
                                break;
                            }
                            case 0xDA:
                            {
                                std::uint32_t len{};
                                get_number(input_format_t::cbor, len);
                                break;
                            }
                            case 0xDB:
                            {
                                std::uint64_t len{};
                                get_number(input_format_t::cbor, len);
                                break;
                            }
                            default:
                                break;
                        }
                        return parse_cbor_internal(true, tag_handler);
                    }
                    default:            // LCOV_EXCL_LINE
                        JSON_ASSERT(false);  // LCOV_EXCL_LINE
                }
            }
            case 0xF4: // false
                return sax->boolean(false);
@@ -1031,11 +952,9 @@ class binary_reader
    /*!
    @param[in] len  the length of the array or std::size_t(-1) for an
                    array of indefinite size
    @param[in] tag_handler how CBOR tags should be treated
    @return whether array creation completed
    */
-    bool get_cbor_array(const std::size_t len,
+    bool get_cbor_array(const std::size_t len)
                        const cbor_tag_handler_t tag_handler)
    {
        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
        {
@@ -1046,7 +965,7 @@ class binary_reader
        {
            for (std::size_t i = 0; i < len; ++i)
            {
-                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal()))
                {
                    return false;
                }
@@ -1056,7 +975,7 @@ class binary_reader
        {
            while (get() != 0xFF)
            {
-                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false)))
                {
                    return false;
                }
@@ -1069,11 +988,9 @@ class binary_reader
    /*!
    @param[in] len  the length of the object or std::size_t(-1) for an
                    object of indefinite size
    @param[in] tag_handler how CBOR tags should be treated
    @return whether object creation completed
    */
-    bool get_cbor_object(const std::size_t len,
+    bool get_cbor_object(const std::size_t len)
                         const cbor_tag_handler_t tag_handler)
    {
        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
        {
@@ -1091,7 +1008,7 @@ class binary_reader
                    return false;
                }
-                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal()))
                {
                    return false;
                }
@@ -1107,7 +1024,7 @@ class binary_reader
                    return false;
                }
-                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal()))
                {
                    return false;
                }
@@ -2005,11 +1922,6 @@ class binary_reader
                return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
            }
            case 'H':
            {
                return get_ubjson_high_precision_number();
            }
            case 'C':  // char
            {
                get();
@@ -2186,55 +2098,6 @@ class binary_reader
    // Note, no reader for UBJSON binary types is implemented because they do
    // not exist
    bool get_ubjson_high_precision_number()
    {
        // get size of following number string
        std::size_t size{};
        auto res = get_ubjson_size_value(size);
        if (JSON_HEDLEY_UNLIKELY(!res))
        {
            return res;
        }
        // get number string
        std::vector<char> number_vector;
        for (std::size_t i = 0; i < size; ++i)
        {
            get();
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "number")))
            {
                return false;
            }
            number_vector.push_back(static_cast<char>(current));
        }
        // parse number string
        auto number_ia = detail::input_adapter(std::forward<decltype(number_vector)>(number_vector));
        auto number_lexer = detail::lexer<BasicJsonType, decltype(number_ia)>(std::move(number_ia), false);
        const auto result_number = number_lexer.scan();
        const auto number_string = number_lexer.get_token_string();
        const auto result_remainder = number_lexer.scan();
        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
        {
            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
        }
        switch (result_number)
        {
            case token_type::value_integer:
                return sax->number_integer(number_lexer.get_number_integer());
            case token_type::value_unsigned:
                return sax->number_unsigned(number_lexer.get_number_unsigned());
            case token_type::value_float:
                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
            default:
                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
        }
    }
    ///////////////////////
    // Utility functions //
    ///////////////////////
@@ -2330,16 +2193,15 @@ class binary_reader
                    string_t& result)
    {
        bool success = true;
-        for (NumberType i = 0; i < len; i++)
+        std::generate_n(std::back_inserter(result), len, [this, &success, &format]()
        {
            get();
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
            {
                success = false;
                break;
            }
-            result.push_back(static_cast<typename string_t::value_type>(current));
+            return std::char_traits<char_type>::to_char_type(current);
-        };
+        });
        return success;
    }
@@ -2363,16 +2225,15 @@ class binary_reader
                    binary_t& result)
    {
        bool success = true;
-        for (NumberType i = 0; i < len; i++)
+        std::generate_n(std::back_inserter(result), len, [this, &success, &format]()
        {
            get();
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
            {
                success = false;
                break;
            }
-            result.push_back(static_cast<std::uint8_t>(current));
+            return static_cast<std::uint8_t>(current);
-        }
+        });
        return success;
    }
@@ -36,7 +36,7 @@ class file_input_adapter
    using char_type = char;
    JSON_HEDLEY_NON_NULL(2)
-    explicit file_input_adapter(std::FILE* f) noexcept
+    explicit file_input_adapter(std::FILE* f)  noexcept
        : m_file(f)
    {}
@@ -90,7 +90,7 @@ class input_stream_adapter
    input_stream_adapter& operator=(input_stream_adapter&) = delete;
    input_stream_adapter& operator=(input_stream_adapter&& rhs) = delete;
-    input_stream_adapter(input_stream_adapter&& rhs) noexcept : is(rhs.is), sb(rhs.sb)
+    input_stream_adapter(input_stream_adapter&& rhs) : is(rhs.is), sb(rhs.sb)
    {
        rhs.is = nullptr;
        rhs.sb = nullptr;
@@ -258,15 +258,30 @@ class json_sax_dom_parser
        return true;
    }
    template<class Exception>
    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
-                     const Exception& ex)
+                     const detail::exception& ex)
    {
        errored = true;
        static_cast<void>(ex);
        if (allow_exceptions)
        {
-            JSON_THROW(ex);
+            // determine the proper exception type from the id
            switch ((ex.id / 100) % 100)
            {
                case 1:
                    JSON_THROW(*dynamic_cast<const detail::parse_error*>(&ex));
                case 4:
                    JSON_THROW(*dynamic_cast<const detail::out_of_range*>(&ex));
                // LCOV_EXCL_START
                case 2:
                    JSON_THROW(*dynamic_cast<const detail::invalid_iterator*>(&ex));
                case 3:
                    JSON_THROW(*dynamic_cast<const detail::type_error*>(&ex));
                case 5:
                    JSON_THROW(*dynamic_cast<const detail::other_error*>(&ex));
                default:
                    JSON_ASSERT(false);
                    // LCOV_EXCL_STOP
            }
        }
        return false;
    }
@@ -497,15 +512,30 @@ class json_sax_dom_callback_parser
        return true;
    }
    template<class Exception>
    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
-                     const Exception& ex)
+                     const detail::exception& ex)
    {
        errored = true;
        static_cast<void>(ex);
        if (allow_exceptions)
        {
-            JSON_THROW(ex);
+            // determine the proper exception type from the id
            switch ((ex.id / 100) % 100)
            {
                case 1:
                    JSON_THROW(*dynamic_cast<const detail::parse_error*>(&ex));
                case 4:
                    JSON_THROW(*dynamic_cast<const detail::out_of_range*>(&ex));
                // LCOV_EXCL_START
                case 2:
                    JSON_THROW(*dynamic_cast<const detail::invalid_iterator*>(&ex));
                case 3:
                    JSON_THROW(*dynamic_cast<const detail::type_error*>(&ex));
                case 5:
                    JSON_THROW(*dynamic_cast<const detail::other_error*>(&ex));
                default:
                    JSON_ASSERT(false);
                    // LCOV_EXCL_STOP
            }
        }
        return false;
    }
@@ -13,6 +13,7 @@
 #include <nlohmann/detail/input/input_adapters.hpp>
 #include <nlohmann/detail/input/position_t.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
 #include <nlohmann/detail/meta/type_traits.hpp>
 namespace nlohmann
 {
@@ -918,6 +919,68 @@ class lexer : public lexer_base<BasicJsonType>
        f = std::strtold(str, endptr);
    }
    JSON_HEDLEY_NON_NULL(2)
    unsigned long long strtoull(const char* str, char** str_end, std::true_type)
    {
        return std::strtoull(str, str_end, 10);
    }
    JSON_HEDLEY_NON_NULL(2)
    number_unsigned_t strtoull(const char* str, char** str_end, std::false_type)
    {
        number_unsigned_t val = 0;
        const char* p = str;
        while (*p >= '0' && * p <= '9')
        {
            val = (10U * val) + static_cast<number_unsigned_t>((*p - '0'));
            p++;
        }
        if (str_end != nullptr)
        {
            *str_end = const_cast<char*>(p);
        }
        return val;
    }
    JSON_HEDLEY_NON_NULL(2)
    long long strtoll(const char* str, char** str_end, std::true_type)
    {
        return std::strtoll(str, str_end, 10);
    }
    JSON_HEDLEY_NON_NULL(2)
    number_integer_t strtoll(const char* str, char** str_end, std::false_type)
    {
        number_integer_t val = 0;
        const char* p = str;
        if (*p == '-')
        {
            p++;
        }
        while (*p >= '0' and * p <= '9')
        {
            val = (10 * val) + (*p - '0');
            p++;
        }
        if (*str == '-')
        {
            val = val * -1;
        }
        if (str_end != nullptr)
        {
            *str_end = const_cast<char*>(p);
        }
        return val;
    }
    /*!
    @brief scan a number literal
@@ -1242,7 +1305,7 @@ scan_number_done:
        // try to parse integers first and fall back to floats
        if (number_type == token_type::value_unsigned)
        {
-            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
+            const auto x = strtoull(token_buffer.data(), &endptr, is_64_bit<number_unsigned_t>());
            // we checked the number format before
            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
@@ -1258,7 +1321,7 @@ scan_number_done:
        }
        else if (number_type == token_type::value_integer)
        {
-            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
+            const auto x = strtoll(token_buffer.data(), &endptr, is_64_bit<number_integer_t>());
            // we checked the number format before
            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
@@ -1521,6 +1584,7 @@ scan_number_done:
            // skip following whitespace
            skip_whitespace();
        }
        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
        switch (current)
        {
@@ -134,138 +134,25 @@
 // 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_GET_MACRO(_1,_2,_3,_4,_5,_6, _7, _8, _9, _10, _11, 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_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, NLOHMANN_JSON_PASTE11, \
-#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
+        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_PASTE8(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_PASTE8(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
 #define NLOHMANN_JSON_TO(v1) j[#v1] = t.v1;
 #define NLOHMANN_JSON_FROM(v1) j.at(#v1).get_to(t.v1);
 /*!
@brief macro
@@ -273,8 +160,8 @@
@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 to_json(nlohmann::json& j, const Type& 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__)) }
+    friend void from_json(const nlohmann::json& j, Type& t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
 /*!
@brief macro
@@ -282,15 +169,5 @@
@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__)) } \
+    void to_json(nlohmann::json& j, const Type& 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__)) }
+    void from_json(const nlohmann::json& j, Type& t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
 #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
@@ -18,6 +18,5 @@
 #undef JSON_HAS_CPP_17
 #undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
 #undef NLOHMANN_BASIC_JSON_TPL
 #undef JSON_EXPLICIT
 #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
@@ -34,10 +34,6 @@ template<typename T, typename String>
 using string_function_t =
    decltype(std::declval<T&>().string(std::declval<String&>()));
 template<typename T, typename Binary>
 using binary_function_t =
    decltype(std::declval<T&>().binary(std::declval<Binary&>()));
 template<typename T>
 using start_object_function_t =
    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
@@ -72,18 +68,19 @@ struct is_sax
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using number_float_t = typename BasicJsonType::number_float_t;
    using string_t = typename BasicJsonType::string_t;
    using binary_t = typename BasicJsonType::binary_t;
    using exception_t = typename BasicJsonType::exception;
  public:
    static constexpr bool value =
        is_detected_exact<bool, null_function_t, SAX>::value &&
        is_detected_exact<bool, boolean_function_t, SAX>::value &&
-        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
+        is_detected_exact<bool, number_integer_function_t, SAX,
-        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
+        number_integer_t>::value &&
-        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
+        is_detected_exact<bool, number_unsigned_function_t, SAX,
        number_unsigned_t>::value &&
        is_detected_exact<bool, number_float_function_t, SAX, number_float_t,
        string_t>::value &&
        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
        is_detected_exact<bool, start_object_function_t, SAX>::value &&
        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
        is_detected_exact<bool, end_object_function_t, SAX>::value &&
@@ -103,7 +100,6 @@ struct is_sax_static_asserts
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using number_float_t = typename BasicJsonType::number_float_t;
    using string_t = typename BasicJsonType::string_t;
    using binary_t = typename BasicJsonType::binary_t;
    using exception_t = typename BasicJsonType::exception;
  public:
@@ -127,9 +123,6 @@ struct is_sax_static_asserts
    static_assert(
        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
        "Missing/invalid function: bool string(string_t&)");
    static_assert(
        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
        "Missing/invalid function: bool binary(binary_t&)");
    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
                  "Missing/invalid function: bool start_object(std::size_t)");
    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
@@ -94,16 +94,6 @@ using get_template_function = decltype(std::declval<T>().template get<U>());
 template<typename BasicJsonType, typename T, typename = void>
 struct has_from_json : std::false_type {};
 // trait checking if j.get<T> is valid
 // use this trait instead of std::is_constructible or std::is_convertible,
 // both rely on, or make use of implicit conversions, and thus fail when T
 // has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
 template <typename BasicJsonType, typename T>
 struct is_getable
 {
    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
 };
 template<typename BasicJsonType, typename T>
 struct has_from_json < BasicJsonType, T,
           enable_if_t < !is_basic_json<T>::value >>
@@ -337,6 +327,16 @@ template<typename BasicJsonType, typename ConstructibleArrayType>
 struct is_constructible_array_type
    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
 // true for types with up to 64 bit
 template<typename NumberType>
 struct is_64_bit : std::integral_constant < bool, (sizeof(NumberType) <= 8) >
 {};
 // true for types with at least 64 bit that con be convert from 64 bit integers
 template<typename NumberType>
 struct is_128_bit_integral : std::integral_constant < bool, (((std::is_signed<NumberType>::value&& std::is_convertible<std::int64_t, NumberType>::value) || (std::is_unsigned<NumberType>::value&& std::is_convertible<std::uint64_t, NumberType>::value))&& !is_64_bit<NumberType>::value) >
 {};
 template<typename RealIntegerType, typename CompatibleNumberIntegerType,
         typename = void>
 struct is_compatible_integer_type_impl : std::false_type {};
@@ -359,6 +359,16 @@ struct is_compatible_integer_type_impl <
        RealLimits::is_signed == CompatibleLimits::is_signed;
 };
 // second version for 128 bit integers that fail std::is_integral test
 template<typename RealIntegerType, typename CompatibleNumberIntegerType>
 struct is_compatible_integer_type_impl < RealIntegerType, CompatibleNumberIntegerType,
           enable_if_t < std::is_same<RealIntegerType, CompatibleNumberIntegerType>::value&&
           !std::is_integral<CompatibleNumberIntegerType>::value&&
           is_128_bit_integral<CompatibleNumberIntegerType>::value >>
 {
    static constexpr auto value = true;
 };
 template<typename RealIntegerType, typename CompatibleNumberIntegerType>
 struct is_compatible_integer_type
    : is_compatible_integer_type_impl<RealIntegerType,
@@ -279,12 +279,6 @@ class binary_writer
            case value_t::binary:
            {
                if (j.m_value.binary->has_subtype())
                {
                    write_number(static_cast<std::uint8_t>(0xd8));
                    write_number(j.m_value.binary->subtype());
                }
                // step 1: write control byte and the binary array size
                const auto N = j.m_value.binary->size();
                if (N <= 0x17)
@@ -1319,17 +1313,7 @@ class binary_writer
        }
        else
        {
-            if (add_prefix)
+            JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(n) + " cannot be represented by UBJSON as it does not fit int64"));
            {
                oa->write_character(to_char_type('H'));  // high-precision number
            }
            const auto number = BasicJsonType(n).dump();
            write_number_with_ubjson_prefix(number.size(), true);
            for (std::size_t i = 0; i < number.size(); ++i)
            {
                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
            }
        }
    }
@@ -1383,23 +1367,19 @@ class binary_writer
        // LCOV_EXCL_START
        else
        {
-            if (add_prefix)
+            JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(n) + " cannot be represented by UBJSON as it does not fit int64"));
            {
                oa->write_character(to_char_type('H'));  // high-precision number
            }
            const auto number = BasicJsonType(n).dump();
            write_number_with_ubjson_prefix(number.size(), true);
            for (std::size_t i = 0; i < number.size(); ++i)
            {
                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
            }
        }
        // LCOV_EXCL_STOP
    }
    /*!
    @brief determine the type prefix of container values
    @note This function does not need to be 100% accurate when it comes to
          integer limits. In case a number exceeds the limits of int64_t,
          this will be detected by a later call to function
          write_number_with_ubjson_prefix. Therefore, we return 'L' for any
          value that does not fit the previous limits.
    */
    CharType ubjson_prefix(const BasicJsonType& j) const noexcept
    {
@@ -1429,12 +1409,8 @@ class binary_writer
                {
                    return 'l';
                }
-                if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                // no check and assume int64_t (see note above)
-                {
+                return 'L';
                    return 'L';
                }
                // anything else is treated as high-precision number
                return 'H'; // LCOV_EXCL_LINE
            }
            case value_t::number_unsigned:
@@ -1455,12 +1431,8 @@ class binary_writer
                {
                    return 'l';
                }
-                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+                // no check and assume int64_t (see note above)
-                {
+                return 'L';
                    return 'L';
                }
                // anything else is treated as high-precision number
                return 'H'; // LCOV_EXCL_LINE
            }
            case value_t::number_float:
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -31,7 +31,7 @@ SOFTWARE.
 #define INCLUDE_NLOHMANN_JSON_HPP_
 #define NLOHMANN_JSON_VERSION_MAJOR 3
-#define NLOHMANN_JSON_VERSION_MINOR 9
+#define NLOHMANN_JSON_VERSION_MINOR 8
 #define NLOHMANN_JSON_VERSION_PATCH 0
 #include <algorithm> // all_of, find, for_each
@@ -51,7 +51,6 @@ SOFTWARE.
 #include <nlohmann/detail/conversions/from_json.hpp>
 #include <nlohmann/detail/conversions/to_json.hpp>
 #include <nlohmann/detail/exceptions.hpp>
 #include <nlohmann/detail/hash.hpp>
 #include <nlohmann/detail/input/binary_reader.hpp>
 #include <nlohmann/detail/input/input_adapters.hpp>
 #include <nlohmann/detail/input/lexer.hpp>
@@ -230,8 +229,6 @@ class basic_json
    using json_serializer = JSONSerializer<T, SFINAE>;
    /// how to treat decoding errors
    using error_handler_t = detail::error_handler_t;
    /// how to treat CBOR tags
    using cbor_tag_handler_t = detail::cbor_tag_handler_t;
    /// helper type for initializer lists of basic_json values
    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
@@ -344,7 +341,7 @@ class basic_json
    {
        basic_json result;
-        result["copyright"] = "(C) 2013-2020 Niels Lohmann";
+        result["copyright"] = "(C) 2013-2017 Niels Lohmann";
        result["name"] = "JSON for Modern C++";
        result["url"] = "https://github.com/nlohmann/json";
        result["version"]["string"] =
@@ -1052,7 +1049,7 @@ class basic_json
                    object = nullptr;  // silence warning, see #821
                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
                    {
-                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.9.0")); // LCOV_EXCL_LINE
+                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.8.0")); // LCOV_EXCL_LINE
                    }
                    break;
                }
@@ -3229,7 +3226,7 @@ class basic_json
 #endif
                   && detail::is_detected<detail::get_template_function, const basic_json_t&, ValueType>::value
                   , int >::type = 0 >
-    JSON_EXPLICIT operator ValueType() const
+    operator ValueType() const
    {
        // delegate the call to get<>() const
        return get<ValueType>();
@@ -3784,9 +3781,8 @@ class basic_json
    @since version 1.0.0
    */
    // using std::is_convertible in a std::enable_if will fail when using explicit conversions
    template < class ValueType, typename std::enable_if <
-                   detail::is_getable<basic_json_t, ValueType>::value
+                   std::is_convertible<basic_json_t, ValueType>::value
                   && !std::is_same<value_t, ValueType>::value, int >::type = 0 >
    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
    {
@@ -3797,7 +3793,7 @@ class basic_json
            const auto it = find(key);
            if (it != end())
            {
-                return it->template get<ValueType>();
+                return *it;
            }
            return default_value;
@@ -3859,7 +3855,7 @@ class basic_json
    @since version 2.0.2
    */
    template<class ValueType, typename std::enable_if<
-                 detail::is_getable<basic_json_t, ValueType>::value, int>::type = 0>
+                 std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
    {
        // at only works for objects
@@ -3868,7 +3864,7 @@ class basic_json
            // if pointer resolves a value, return it or use default value
            JSON_TRY
            {
-                return ptr.get_checked(this).template get<ValueType>();
+                return ptr.get_checked(this);
            }
            JSON_INTERNAL_CATCH (out_of_range&)
            {
@@ -7036,6 +7032,7 @@ class basic_json
          - bignum (0xC2..0xC3)
          - decimal fraction (0xC4)
          - bigfloat (0xC5)
          - tagged items (0xC6..0xD4, 0xD8..0xDB)
          - expected conversions (0xD5..0xD7)
          - simple values (0xE0..0xF3, 0xF8)
          - undefined (0xF7)
@@ -7051,7 +7048,7 @@ class basic_json
    vector in CBOR format.,to_cbor}
    @sa http://cbor.io
-    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
        analogous deserialization
    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
@@ -7200,7 +7197,6 @@ class basic_json
    number_unsigned | 256..32767                        | int16       | `I`
    number_unsigned | 32768..2147483647                 | int32       | `l`
    number_unsigned | 2147483648..9223372036854775807   | int64       | `L`
    number_unsigned | 2147483649..18446744073709551615  | high-precision | `H`
    number_float    | *any value*                       | float64     | `D`
    string          | *with shortest length indicator*  | string      | `S`
    array           | *see notes on optimized format*   | array       | `[`
@@ -7211,6 +7207,7 @@ class basic_json
    @note The following values can **not** be converted to a UBJSON value:
          - strings with more than 9223372036854775807 bytes (theoretical)
          - unsigned integer numbers above 9223372036854775807
    @note The following markers are not used in the conversion:
          - `Z`: no-op values are not created.
@@ -7422,6 +7419,7 @@ class basic_json
             - bignum (0xC2..0xC3)
             - decimal fraction (0xC4)
             - bigfloat (0xC5)
             - tagged items (0xC6..0xD4, 0xD8..0xDB)
             - expected conversions (0xD5..0xD7)
             - simple values (0xE0..0xF3, 0xF8)
             - undefined (0xF7)
@@ -7438,7 +7436,6 @@ class basic_json
                       (true by default)
    @param[in] allow_exceptions  whether to throw exceptions in case of a
    parse error (optional, true by default)
    @param[in] tag_handler how to treat CBOR tags (optional, error by default)
    @return deserialized JSON value; in case of a parse error and
            @a allow_exceptions set to `false`, the return value will be
@@ -7465,36 +7462,34 @@ class basic_json
    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
           consume input adapters, removed start_index parameter, and added
           @a strict parameter since 3.0.0; added @a allow_exceptions parameter
-           since 3.2.0; added @a tag_handler parameter since 3.9.0.
+           since 3.2.0
    */
    template<typename InputType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json from_cbor(InputType&& i,
                                const bool strict = true,
-                                const bool allow_exceptions = true,
+                                const bool allow_exceptions = true)
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = detail::input_adapter(std::forward<InputType>(i));
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }
    /*!
-    @copydoc from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t)
+    @copydoc from_cbor(detail::input_adapter&&, const bool, const bool)
    */
    template<typename IteratorType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json from_cbor(IteratorType first, IteratorType last,
                                const bool strict = true,
-                                const bool allow_exceptions = true,
+                                const bool allow_exceptions = true)
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = detail::input_adapter(std::move(first), std::move(last));
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }
@@ -7503,10 +7498,9 @@ class basic_json
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
    static basic_json from_cbor(const T* ptr, std::size_t len,
                                const bool strict = true,
-                                const bool allow_exceptions = true,
+                                const bool allow_exceptions = true)
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
    {
-        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
+        return from_cbor(ptr, ptr + len, strict, allow_exceptions);
    }
@@ -7514,13 +7508,12 @@ class basic_json
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
    static basic_json from_cbor(detail::span_input_adapter&& i,
                                const bool strict = true,
-                                const bool allow_exceptions = true,
+                                const bool allow_exceptions = true)
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = i.get();
-        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }
@@ -7598,7 +7591,7 @@ class basic_json
    @sa http://msgpack.org
    @sa @ref to_msgpack(const basic_json&) for the analogous serialization
-    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
        related CBOR format
    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for
        the related UBJSON format
@@ -7685,7 +7678,6 @@ class basic_json
    int16       | number_integer                          | `I`
    int32       | number_integer                          | `l`
    int64       | number_integer                          | `L`
    high-precision number | number_integer, number_unsigned, or number_float - depends on number string | 'H'
    string      | string                                  | `S`
    char        | string                                  | `C`
    array       | array (optimized values are supported)  | `[`
@@ -7717,7 +7709,7 @@ class basic_json
    @sa http://ubjson.org
    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
             analogous serialization
-    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
        related CBOR format
    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
        the related MessagePack format
@@ -7832,7 +7824,7 @@ class basic_json
    @sa http://bsonspec.org/spec.html
    @sa @ref to_bson(const basic_json&) for the analogous serialization
-    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
        related CBOR format
    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
        the related MessagePack format
@@ -8341,8 +8333,8 @@ class basic_json
            }
            // collect mandatory members
-            const auto op = get_value("op", "op", true).template get<std::string>();
+            const std::string op = get_value("op", "op", true);
-            const auto path = get_value(op, "path", true).template get<std::string>();
+            const std::string path = get_value(op, "path", true);
            json_pointer ptr(path);
            switch (get_op(op))
@@ -8368,7 +8360,7 @@ class basic_json
                case patch_operations::move:
                {
-                    const auto from_path = get_value("move", "from", true).template get<std::string>();
+                    const std::string from_path = get_value("move", "from", true);
                    json_pointer from_ptr(from_path);
                    // the "from" location must exist - use at()
@@ -8385,7 +8377,7 @@ class basic_json
                case patch_operations::copy:
                {
-                    const auto from_path = get_value("copy", "from", true).template get<std::string>();
+                    const std::string from_path = get_value("copy", "from", true);
                    const json_pointer from_ptr(from_path);
                    // the "from" location must exist - use at()
@@ -8706,7 +8698,9 @@ struct hash<nlohmann::json>
    */
    std::size_t operator()(const nlohmann::json& j) const
    {
-        return nlohmann::detail::hash(j);
+        // a naive hashing via the string representation
        const auto& h = hash<nlohmann::json::string_t>();
        return h(j.dump());
    }
 };
@@ -1,6 +1,6 @@
 project('nlohmann_json',
    'cpp',
-    version : '3.9.0',
+    version : '3.8.0',
    license : 'MIT',
 )
@@ -94,6 +94,7 @@ endif()
 set(files
    src/unit-algorithms.cpp
    src/unit-allocator.cpp
    src/unit-alt-number.cpp
    src/unit-alt-string.cpp
    src/unit-assert_macro.cpp
    src/unit-bson.cpp
@@ -112,7 +113,6 @@ set(files
    src/unit-deserialization.cpp
    src/unit-element_access1.cpp
    src/unit-element_access2.cpp
    src/unit-hash.cpp
    src/unit-inspection.cpp
    src/unit-items.cpp
    src/unit-iterators1.cpp
@@ -193,4 +193,3 @@ add_subdirectory(cmake_import)
 add_subdirectory(cmake_import_minver)
 add_subdirectory(cmake_add_subdirectory)
 add_subdirectory(cmake_fetch_content)
 add_subdirectory(cmake_target_include_directories)
@@ -1,13 +1,98 @@
-##############################################################################
+##########################################################################
-# OSS-Fuzz
+# unit tests
-##############################################################################
+##########################################################################
 # The following targets realize the integration to OSS-Fuzz.
 # See <https://github.com/google/oss-fuzz/blob/master/projects/json/build.sh> for more information.
 # additional flags
-CXXFLAGS += -std=c++11
+CXXFLAGS += -std=c++11 -Wall -Wextra -pedantic -Wcast-align -Wcast-qual -Wno-ctor-dtor-privacy -Wdisabled-optimization -Wformat=2 -Winit-self -Wmissing-declarations -Wmissing-include-dirs -Wold-style-cast -Woverloaded-virtual -Wredundant-decls -Wshadow -Wsign-conversion -Wsign-promo -Wstrict-overflow=5 -Wswitch -Wundef -Wno-unused -Wnon-virtual-dtor -Wreorder -Wdeprecated -Wno-float-equal
-CPPFLAGS += -I ../single_include
+CPPFLAGS += -I ../single_include -I . -I thirdparty/doctest -I thirdparty/fifo_map -DDOCTEST_CONFIG_SUPER_FAST_ASSERTS
 SOURCES = src/unit.cpp \
          src/unit-algorithms.cpp \
          src/unit-allocator.cpp \
          src/unit-alt-string.cpp \
          src/unit-bson.cpp \
          src/unit-capacity.cpp \
          src/unit-cbor.cpp \
          src/unit-class_const_iterator.cpp \
          src/unit-class_iterator.cpp \
          src/unit-class_lexer.cpp \
          src/unit-class_parser.cpp \
          src/unit-comparison.cpp \
          src/unit-concepts.cpp \
          src/unit-constructor1.cpp \
          src/unit-constructor2.cpp \
          src/unit-convenience.cpp \
          src/unit-conversions.cpp \
          src/unit-deserialization.cpp \
          src/unit-element_access1.cpp \
          src/unit-element_access2.cpp \
          src/unit-inspection.cpp \
          src/unit-items.cpp \
          src/unit-iterators1.cpp \
          src/unit-iterators2.cpp \
          src/unit-merge_patch.cpp \
          src/unit-json_patch.cpp \
          src/unit-json_pointer.cpp \
          src/unit-meta.cpp \
          src/unit-modifiers.cpp \
          src/unit-msgpack.cpp \
          src/unit-pointer_access.cpp \
          src/unit-readme.cpp \
          src/unit-reference_access.cpp \
          src/unit-regression.cpp \
          src/unit-serialization.cpp \
          src/unit-testsuites.cpp \
          src/unit-ubjson.cpp \
          src/unit-unicode.cpp \
          src/unit-user_defined_input.cpp \
          src/unit-wstring.cpp
 OBJECTS = $(SOURCES:.cpp=.o)
 TESTCASES = $(patsubst src/unit-%.cpp,test-%,$(wildcard src/unit-*.cpp))
 ##############################################################################
 # main rules
 ##############################################################################
 all: $(TESTCASES)
 clean:
 	rm -fr json_unit $(OBJECTS) $(SOURCES:.cpp=.gcno) $(SOURCES:.cpp=.gcda) $(TESTCASES) $(FUZZERS) test_data.hpp
 test_data.hpp:
 	@echo "#define TEST_DATA_DIRECTORY" > $@
 ##############################################################################
 # single test file
 ##############################################################################
 json_unit: $(OBJECTS) ../single_include/nlohmann/json.hpp thirdparty/doctest/doctest.h
 	@echo "[CXXLD] $@"
 	@$(CXX) $(CXXFLAGS) $(LDFLAGS) $(OBJECTS) -o $@
 %.o: %.cpp ../single_include/nlohmann/json.hpp thirdparty/doctest/doctest.h test_data.hpp
 	@echo "[CXX]   $@"
 	@$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $< -o $@
 ##############################################################################
 # individual test cases
 ##############################################################################
 test-%: src/unit-%.o src/unit.o ../single_include/nlohmann/json.hpp thirdparty/doctest/doctest.h test_data.hpp
 	@echo "[CXXLD] $@"
 	@$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS) $< src/unit.o -o $@
 TEST_PATTERN ?= "*"
 TEST_PREFIX = ""
 check: $(OBJECTS) $(TESTCASES)
 	@cd .. ; for testcase in $(TESTCASES); do echo "Executing $$testcase..."; $(TEST_PREFIX)test/$$testcase $(TEST_PATTERN) || exit 1; done
 ##############################################################################
 # fuzzer
 ##############################################################################
 FUZZER_ENGINE = src/fuzzer-driver_afl.cpp
 FUZZERS = parse_afl_fuzzer parse_bson_fuzzer parse_cbor_fuzzer parse_msgpack_fuzzer parse_ubjson_fuzzer
@@ -1,16 +0,0 @@
 add_test(NAME cmake_target_include_directories_configure
  COMMAND ${CMAKE_COMMAND}
    -G "${CMAKE_GENERATOR}"
    -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
    -Dnlohmann_json_source=${PROJECT_SOURCE_DIR}
    ${CMAKE_CURRENT_SOURCE_DIR}/project
 )
 add_test(NAME cmake_target_include_directories_build
    COMMAND ${CMAKE_COMMAND} --build .
 )
 set_tests_properties(cmake_target_include_directories_configure PROPERTIES
    FIXTURES_SETUP cmake_target_include_directories
 )
 set_tests_properties(cmake_target_include_directories_build PROPERTIES
    FIXTURES_REQUIRED cmake_target_include_directories
 )
@@ -1,3 +0,0 @@
 #include "Bar.hpp"
 class Bar;
@@ -1,4 +0,0 @@
 #include <nlohmann/json.hpp>
 #include "Foo.hpp"
 class Bar : public Foo{};
@@ -1,21 +0,0 @@
 cmake_minimum_required(VERSION 3.1)
 project(DummyImport CXX)
 add_executable(with_private_target main.cpp)
 target_include_directories(with_private_target PRIVATE ${nlohmann_json_source}/include)
 set_target_properties(with_private_target PROPERTIES CXX_STANDARD 11)
 add_executable(with_private_system_target main.cpp)
 target_include_directories(with_private_system_target PRIVATE SYSTEM ${nlohmann_json_source}/include)
 set_target_properties(with_private_system_target PROPERTIES CXX_STANDARD 11)
 # regression from https://github.com/nlohmann/json/discussions/2281
 add_library(Foo STATIC Foo.cpp Bar.cpp)
 target_include_directories(Foo PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${nlohmann_json_source}/include)
 set_target_properties(Foo PROPERTIES CXX_STANDARD 11)
 add_library(Bar STATIC Bar.cpp)
 target_link_libraries(Bar PRIVATE Foo)
 target_include_directories(Bar PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${nlohmann_json_source}/include)
 set_target_properties(Bar PROPERTIES CXX_STANDARD 11)
@@ -1,3 +0,0 @@
 #include "Foo.hpp"
 class Foo;
@@ -1,4 +0,0 @@
 #pragma once
 #include <nlohmann/json.hpp>
 class Foo{};
@@ -1,8 +0,0 @@
 #include <nlohmann/json.hpp>
 int main(int argc, char **argv)
 {
    nlohmann::json j;
    return 0;
 }
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (fuzz test support)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 This file implements a driver for American Fuzzy Lop (afl-fuzz). It relies on
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (fuzz test support)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 This file implements a parser test suitable for fuzz testing. Given a byte
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (fuzz test support)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 This file implements a parser test suitable for fuzz testing. Given a byte
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (fuzz test support)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 This file implements a parser test suitable for fuzz testing. Given a byte
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (fuzz test support)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 This file implements a parser test suitable for fuzz testing. Given a byte
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (fuzz test support)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 This file implements a parser test suitable for fuzz testing. Given a byte
@@ -1,25 +0,0 @@
 #pragma once
 #include <cstdint> // uint8_t
 #include <fstream> // ifstream, istreambuf_iterator, ios
 #include <vector> // vector
 namespace utils
 {
 inline std::vector<std::uint8_t> read_binary_file(const std::string& filename)
 {
    std::ifstream file(filename, std::ios::binary);
    file.unsetf(std::ios::skipws);
    file.seekg(0, std::ios::end);
    const auto size = file.tellg();
    file.seekg(0, std::ios::beg);
    std::vector<std::uint8_t> byte_vector;
    byte_vector.reserve(static_cast<std::size_t>(size));
    byte_vector.insert(byte_vector.begin(), std::istream_iterator<std::uint8_t>(file), std::istream_iterator<std::uint8_t>());
    return byte_vector;
 }
 } // namespace utils
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -0,0 +1,129 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
 |  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
 SPDX-License-Identifier: MIT
 Copyright (c) 2018 Vitaliy Manushkin <agri@akamo.info>.
 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.
 */
 #include "doctest_compatibility.h"
 #include <nlohmann/json.hpp>
 TEST_CASE("Alternative number types")
 {
    SECTION("8 bit integers")
    {
        using json8 = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int8_t, std::uint8_t>;
        SECTION("unsigned")
        {
            std::uint8_t unsigned_max = 255;
            json8 j_unsigned_max = json8::parse("255");
            CHECK(j_unsigned_max.is_number_unsigned());
            CHECK(j_unsigned_max.dump() == "255");
            CHECK((j_unsigned_max.get<std::uint8_t>() == unsigned_max));
            CHECK(json8::parse(j_unsigned_max.dump()) == j_unsigned_max);
            json8 j_overflow = json8::parse("256");
            CHECK(j_overflow.is_number_float());
            CHECK(j_overflow.dump() == "256.0");
        }
        SECTION("signed")
        {
            std::int8_t signed_min = -128;
            json8 j_signed_min = json8::parse("-128");
            CHECK(j_signed_min.is_number_integer());
            CHECK(j_signed_min.dump() == "-128");
            CHECK((j_signed_min.get<std::int8_t>() == signed_min));
            CHECK(json8::parse(j_signed_min.dump()) == j_signed_min);
            json8 j_underflow = json8::parse("-129");
            CHECK(j_underflow.is_number_float());
            CHECK(j_underflow.dump() == "-129.0");
        }
    }
    SECTION("16 bit integers")
    {
        using json16 = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int16_t, std::uint16_t>;
        SECTION("unsigned")
        {
            std::uint16_t unsigned_max = 65535;
            json16 j_unsigned_max = json16::parse("65535");
            CHECK(j_unsigned_max.is_number_unsigned());
            CHECK(j_unsigned_max.dump() == "65535");
            CHECK((j_unsigned_max.get<std::uint16_t>() == unsigned_max));
            CHECK(json16::parse(j_unsigned_max.dump()) == j_unsigned_max);
            json16 j_overflow = json16::parse("65536");
            CHECK(j_overflow.is_number_float());
            CHECK(j_overflow.dump() == "65536.0");
        }
        SECTION("signed")
        {
            std::int16_t signed_min = -32768;
            json16 j_signed_min = json16::parse("-32768");
            CHECK(j_signed_min.is_number_integer());
            CHECK(j_signed_min.dump() == "-32768");
            CHECK((j_signed_min.get<std::int16_t>() == signed_min));
            CHECK(json16::parse(j_signed_min.dump()) == j_signed_min);
            json16 j_underflow = json16::parse("-32769");
            CHECK(j_underflow.is_number_float());
            CHECK(j_underflow.dump() == "-32769.0");
        }
    }
    // 128-bit arithmetic does not work with sanitizers
 #if defined(__SIZEOF_INT128__) && !defined(__SANITIZE_ADDRESS__)
    SECTION("128 bit integers")
    {
        using json128 = nlohmann::basic_json<std::map, std::vector, std::string, bool, __int128_t, __uint128_t>;
        SECTION("unsigned")
        {
            __uint128_t unsigned_max = (340282366920938463463.374607431768211455) * std::pow(10, 18);
            json128 j_unsigned_max = json128::parse("340282366920938463463374607431768211455");
            CHECK(j_unsigned_max.is_number_unsigned());
            CHECK(j_unsigned_max.dump() == "340282366920938463463374607431768211455");
            //CHECK((j_unsigned_max.get<__uint128_t>() == unsigned_max));
            CHECK(json128::parse(j_unsigned_max.dump()) == j_unsigned_max);
        }
        SECTION("signed")
        {
            __int128_t signed_min = (-170141183460469231731.687303715884105728) * std::pow(10, 18);
            json128 j_signed_min = json128::parse("-170141183460469231731687303715884105728");
            CHECK(j_signed_min.is_number_integer());
            CHECK(j_signed_min.dump() == "-170141183460469231731687303715884105728");
            CHECK((j_signed_min.get<__int128_t>() == signed_min));
            CHECK(json128::parse(j_signed_min.dump()) == j_signed_min);
        }
    }
 #endif
 }
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -35,7 +35,6 @@ using nlohmann::json;
 #include <fstream>
 #include <sstream>
 #include <test_data.hpp>
 #include "test_utils.hpp"
 TEST_CASE("BSON")
 {
@@ -1264,7 +1263,10 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
                json j1 = json::parse(f_json);
                // parse BSON file
-                auto packed = utils::read_binary_file(filename + ".bson");
+                std::ifstream f_bson(filename + ".bson", std::ios::binary);
                std::vector<std::uint8_t> packed(
                    (std::istreambuf_iterator<char>(f_bson)),
                    std::istreambuf_iterator<char>());
                json j2;
                CHECK_NOTHROW(j2 = json::from_bson(packed));
@@ -1294,7 +1296,10 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
                json j1 = json::parse(f_json);
                // parse BSON file
-                auto packed = utils::read_binary_file(filename + ".bson");
+                std::ifstream f_bson(filename + ".bson", std::ios::binary);
                std::vector<std::uint8_t> packed(
                    (std::istreambuf_iterator<char>(f_bson)),
                    std::istreambuf_iterator<char>());
                json j2;
                CHECK_NOTHROW(j2 = json::from_bson({packed.data(), packed.size()}));
@@ -1309,7 +1314,10 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
                json j1 = json::parse(f_json);
                // parse BSON file
-                auto packed = utils::read_binary_file(filename + ".bson");
+                std::ifstream f_bson(filename + ".bson", std::ios::binary);
                std::vector<std::uint8_t> packed(
                    (std::istreambuf_iterator<char>(f_bson)),
                    std::istreambuf_iterator<char>());
                {
                    INFO_WITH_TEMP(filename + ": output adapters: std::vector<std::uint8_t>");
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -39,7 +39,6 @@ using nlohmann::json;
 #include <iostream>
 #include <set>
 #include <test_data.hpp>
 #include "test_utils.hpp"
 namespace
 {
@@ -1012,21 +1011,21 @@ TEST_CASE("CBOR")
                    SECTION("0 (0 00000 0000000000)")
                    {
                        json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x00, 0x00}));
-                        json::number_float_t d{j};
+                        json::number_float_t d = j;
                        CHECK(d == 0.0);
                    }
                    SECTION("-0 (1 00000 0000000000)")
                    {
                        json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x80, 0x00}));
-                        json::number_float_t d{j};
+                        json::number_float_t d = j;
                        CHECK(d == -0.0);
                    }
                    SECTION("2**-24 (0 00000 0000000001)")
                    {
                        json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x00, 0x01}));
-                        json::number_float_t d{j};
+                        json::number_float_t d = j;
                        CHECK(d == std::pow(2.0, -24.0));
                    }
                }
@@ -1036,7 +1035,7 @@ TEST_CASE("CBOR")
                    SECTION("infinity (0 11111 0000000000)")
                    {
                        json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c, 0x00}));
-                        json::number_float_t d{j};
+                        json::number_float_t d = j;
                        CHECK(d == std::numeric_limits<json::number_float_t>::infinity());
                        CHECK(j.dump() == "null");
                    }
@@ -1044,7 +1043,7 @@ TEST_CASE("CBOR")
                    SECTION("-infinity (1 11111 0000000000)")
                    {
                        json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0xfc, 0x00}));
-                        json::number_float_t d{j};
+                        json::number_float_t d = j;
                        CHECK(d == -std::numeric_limits<json::number_float_t>::infinity());
                        CHECK(j.dump() == "null");
                    }
@@ -1055,21 +1054,21 @@ TEST_CASE("CBOR")
                    SECTION("1 (0 01111 0000000000)")
                    {
                        json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x3c, 0x00}));
-                        json::number_float_t d{j};
+                        json::number_float_t d = j;
                        CHECK(d == 1);
                    }
                    SECTION("-2 (1 10000 0000000000)")
                    {
                        json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0xc0, 0x00}));
-                        json::number_float_t d{j};
+                        json::number_float_t d = j;
                        CHECK(d == -2);
                    }
                    SECTION("65504 (0 11110 1111111111)")
                    {
                        json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7b, 0xff}));
-                        json::number_float_t d{j};
+                        json::number_float_t d = j;
                        CHECK(d == 65504);
                    }
                }
@@ -1077,7 +1076,7 @@ TEST_CASE("CBOR")
                SECTION("infinity")
                {
                    json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c, 0x00}));
-                    json::number_float_t d{j};
+                    json::number_float_t d = j;
                    CHECK(!std::isfinite(d));
                    CHECK(j.dump() == "null");
                }
@@ -1085,7 +1084,7 @@ TEST_CASE("CBOR")
                SECTION("NaN")
                {
                    json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7e, 0x00}));
-                    json::number_float_t d{j};
+                    json::number_float_t d = j;
                    CHECK(std::isnan(d));
                    CHECK(j.dump() == "null");
                }
@@ -1921,7 +1920,9 @@ TEST_CASE("single CBOR roundtrip")
        json j1 = json::parse(f_json);
        // parse CBOR file
-        auto packed = utils::read_binary_file(filename + ".cbor");
+        std::ifstream f_cbor(filename + ".cbor", std::ios::binary);
        std::vector<uint8_t> packed((std::istreambuf_iterator<char>(f_cbor)),
                                    std::istreambuf_iterator<char>());
        json j2;
        CHECK_NOTHROW(j2 = json::from_cbor(packed));
@@ -1993,7 +1994,10 @@ TEST_CASE("CBOR regressions")
            try
            {
                // parse CBOR file
-                auto vec1 = utils::read_binary_file(filename);
+                std::ifstream f_cbor(filename, std::ios::binary);
                std::vector<uint8_t> vec1(
                    (std::istreambuf_iterator<char>(f_cbor)),
                    std::istreambuf_iterator<char>());
                json j1 = json::from_cbor(vec1);
                try
@@ -2200,7 +2204,10 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
                json j1 = json::parse(f_json);
                // parse CBOR file
-                auto packed = utils::read_binary_file(filename + ".cbor");
+                std::ifstream f_cbor(filename + ".cbor", std::ios::binary);
                std::vector<uint8_t> packed(
                    (std::istreambuf_iterator<char>(f_cbor)),
                    std::istreambuf_iterator<char>());
                json j2;
                CHECK_NOTHROW(j2 = json::from_cbor(packed));
@@ -2230,7 +2237,10 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
                json j1 = json::parse(f_json);
                // parse CBOR file
-                auto packed = utils::read_binary_file(filename + ".cbor");
+                std::ifstream f_cbor(filename + ".cbor", std::ios::binary);
                std::vector<uint8_t> packed(
                    (std::istreambuf_iterator<char>(f_cbor)),
                    std::istreambuf_iterator<char>());
                json j2;
                CHECK_NOTHROW(j2 = json::from_cbor({packed.data(), packed.size()}));
@@ -2245,7 +2255,10 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
                json j1 = json::parse(f_json);
                // parse CBOR file
-                auto packed = utils::read_binary_file(filename + ".cbor");
+                std::ifstream f_cbor(filename + ".cbor", std::ios::binary);
                std::vector<uint8_t> packed(
                    (std::istreambuf_iterator<char>(f_cbor)),
                    std::istreambuf_iterator<char>());
                if (!exclude_packed.count(filename))
                {
@@ -2480,14 +2493,16 @@ TEST_CASE("examples from RFC 7049 Appendix A")
    SECTION("byte arrays")
    {
-        auto packed = utils::read_binary_file(TEST_DATA_DIRECTORY "/binary_data/cbor_binary.cbor");
+        std::ifstream f_cbor(TEST_DATA_DIRECTORY "/binary_data/cbor_binary.cbor", std::ios::binary);
        std::vector<uint8_t> packed((std::istreambuf_iterator<char>(f_cbor)),
                                    std::istreambuf_iterator<char>());
        json j;
        CHECK_NOTHROW(j = json::from_cbor(packed));
-        auto expected = utils::read_binary_file(TEST_DATA_DIRECTORY "/binary_data/cbor_binary.out");
+        std::ifstream f_bin(TEST_DATA_DIRECTORY "/binary_data/cbor_binary.out", std::ios::binary);
        std::vector<uint8_t> expected((std::istreambuf_iterator<char>(f_bin)),
                                      std::istreambuf_iterator<char>());
        CHECK(j == json::binary(expected));
        CHECK(json::to_cbor(json::binary(std::vector<uint8_t> {}, 0x42)) == std::vector<uint8_t> {0xd8, 0x42, 0x40});
    }
    SECTION("arrays")
@@ -2533,197 +2548,3 @@ TEST_CASE("examples from RFC 7049 Appendix A")
        CHECK(json::parse("{\"Fun\": true, \"Amt\": -2}") == json::from_cbor(std::vector<uint8_t>({0xbf, 0x63, 0x46, 0x75, 0x6e, 0xf5, 0x63, 0x41, 0x6d, 0x74, 0x21, 0xff})));
    }
 }
 TEST_CASE("Tagged values")
 {
    json j = "s";
    auto v = json::to_cbor(j);
    SECTION("0xC6..0xD4")
    {
        for (auto b : std::vector<std::uint8_t>
    {
        0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4
    })
        {
            // add tag to value
            auto v_tagged = v;
            v_tagged.insert(v_tagged.begin(), b);
            // check that parsing fails in error mode
            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
            // check that parsing succeeds and gets original value in ignore mode
            auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
            CHECK(j_tagged == j);
        }
    }
    SECTION("0xD8 - 1 byte follows")
    {
        SECTION("success")
        {
            // add tag to value
            auto v_tagged = v;
            v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0xD8); // tag
            // check that parsing fails in error mode
            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
            // check that parsing succeeds and gets original value in ignore mode
            auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
            CHECK(j_tagged == j);
        }
        SECTION("missing byte after tag")
        {
            // add tag to value
            auto v_tagged = v;
            v_tagged.insert(v_tagged.begin(), 0xD8); // tag
            // check that parsing fails in all modes
            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore), json::parse_error);
        }
    }
    SECTION("0xD9 - 2 byte follow")
    {
        SECTION("success")
        {
            // add tag to value
            auto v_tagged = v;
            v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0xD9); // tag
            // check that parsing fails in error mode
            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
            // check that parsing succeeds and gets original value in ignore mode
            auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
            CHECK(j_tagged == j);
        }
        SECTION("missing byte after tag")
        {
            // add tag to value
            auto v_tagged = v;
            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0xD9); // tag
            // check that parsing fails in all modes
            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore), json::parse_error);
        }
    }
    SECTION("0xDA - 4 bytes follow")
    {
        SECTION("success")
        {
            // add tag to value
            auto v_tagged = v;
            v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0xDA); // tag
            // check that parsing fails in error mode
            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
            // check that parsing succeeds and gets original value in ignore mode
            auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
            CHECK(j_tagged == j);
        }
        SECTION("missing bytes after tag")
        {
            // add tag to value
            auto v_tagged = v;
            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0xDA); // tag
            // check that parsing fails in all modes
            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore), json::parse_error);
        }
    }
    SECTION("0xDB - 8 bytes follow")
    {
        SECTION("success")
        {
            // add tag to value
            auto v_tagged = v;
            v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0xDB); // tag
            // check that parsing fails in error mode
            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
            // check that parsing succeeds and gets original value in ignore mode
            auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
            CHECK(j_tagged == j);
        }
        SECTION("missing byte after tag")
        {
            // add tag to value
            auto v_tagged = v;
            v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
            v_tagged.insert(v_tagged.begin(), 0xDB); // tag
            // check that parsing fails in all modes
            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore), json::parse_error);
        }
    }
    SECTION("tagged binary")
    {
        // create a binary value of subtype 42
        json j_binary;
        j_binary["binary"] = json::binary({0xCA, 0xFE, 0xBA, 0xBE}, 42);
        // convert to CBOR
        const auto vec = json::to_cbor(j_binary);
        CHECK(vec == std::vector<std::uint8_t> {0xA1, 0x66, 0x62, 0x69, 0x6E, 0x61, 0x72, 0x79, 0xD8, 0x2A, 0x44, 0xCA, 0xFE, 0xBA, 0xBE});
        // parse error when parsing tagged value
        CHECK_THROWS_AS(json::from_cbor(vec), json::parse_error);
        CHECK_THROWS_WITH(json::from_cbor(vec), "[json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: invalid byte: 0xD8");
        // binary without subtype when tags are ignored
        json jb = json::from_cbor(vec, true, true, json::cbor_tag_handler_t::ignore);
        CHECK(jb.is_object());
        CHECK(jb["binary"].is_binary());
        CHECK(!jb["binary"].get_binary().has_subtype());
    }
 }
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -341,7 +341,7 @@ TEST_CASE("constructors")
            CHECK(j.type() == json::value_t::array);
            CHECK(j == json({1, 2, 3, 4, 5}));
-            auto jva = j.get<std::valarray<int>>();
+            std::valarray<int> jva = j;
            CHECK(jva.size() == va.size());
            for (size_t i = 0; i < jva.size(); ++i)
            {
@@ -356,7 +356,7 @@ TEST_CASE("constructors")
            CHECK(j.type() == json::value_t::array);
            CHECK(j == json({1.2, 2.3, 3.4, 4.5, 5.6}));
-            auto jva = j.get<std::valarray<double>>();
+            std::valarray<double> jva = j;
            CHECK(jva.size() == va.size());
            for (size_t i = 0; i < jva.size(); ++i)
            {
@@ -846,7 +846,7 @@ TEST_CASE("constructors")
            CHECK(j.type() == json::value_t::number_float);
            // check round trip of NaN
-            json::number_float_t d{j};
+            json::number_float_t d = j;
            CHECK((std::isnan(d) && std::isnan(n)) == true);
            // check that NaN is serialized to null
@@ -861,7 +861,7 @@ TEST_CASE("constructors")
            CHECK(j.type() == json::value_t::number_float);
            // check round trip of infinity
-            json::number_float_t d{j};
+            json::number_float_t d = j;
            CHECK(d == n);
            // check that inf is serialized to null
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -189,7 +189,6 @@ TEST_CASE("value conversion")
        }
    }
 #if JSON_USE_IMPLICIT_CONVERSIONS
    SECTION("get an object (implicit)")
    {
        json::object_t o_reference = {{"object", json::object()},
@@ -231,7 +230,6 @@ TEST_CASE("value conversion")
            CHECK(json(o) == j);
        }
    }
 #endif
    SECTION("get an array (explicit)")
    {
@@ -278,8 +276,7 @@ TEST_CASE("value conversion")
            SECTION("reserve is called on containers that supports it")
            {
                // make sure all values are properly copied
-                json j2({1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+                std::vector<int> v2 = json({1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
                auto v2 = j2.get<std::vector<int>>();
                CHECK(v2.size() == 10);
            }
 #endif
@@ -408,7 +405,6 @@ TEST_CASE("value conversion")
        }
    }
 #if JSON_USE_IMPLICIT_CONVERSIONS
    SECTION("get an array (implicit)")
    {
        json::array_t a_reference{json(1),     json(1u),       json(2.2),
@@ -445,7 +441,6 @@ TEST_CASE("value conversion")
            CHECK(json(a) == j);
        }
    }
 #endif
    SECTION("get a string (explicit)")
    {
@@ -603,7 +598,6 @@ TEST_CASE("value conversion")
    }
 #if JSON_USE_IMPLICIT_CONVERSIONS
    SECTION("get a string (implicit)")
    {
        json::string_t s_reference{"Hello world"};
@@ -629,7 +623,6 @@ TEST_CASE("value conversion")
            CHECK(json(s) == j);
        }
    }
 #endif
    SECTION("get a boolean (explicit)")
    {
@@ -702,7 +695,6 @@ TEST_CASE("value conversion")
        }
    }
 #if JSON_USE_IMPLICIT_CONVERSIONS
    SECTION("get a boolean (implicit)")
    {
        json::boolean_t b_reference{true};
@@ -720,7 +712,6 @@ TEST_CASE("value conversion")
            CHECK(json(b) == j);
        }
    }
 #endif
    SECTION("get an integer number (explicit)")
    {
@@ -971,7 +962,6 @@ TEST_CASE("value conversion")
        }
    }
 #if JSON_USE_IMPLICIT_CONVERSIONS
    SECTION("get an integer number (implicit)")
    {
        json::number_integer_t n_reference{42};
@@ -1183,7 +1173,6 @@ TEST_CASE("value conversion")
            CHECK(json(n) == j_unsigned);
        }
    }
 #endif
    SECTION("get a floating-point number (explicit)")
    {
@@ -1245,7 +1234,6 @@ TEST_CASE("value conversion")
        }
    }
 #if JSON_USE_IMPLICIT_CONVERSIONS
    SECTION("get a floating-point number (implicit)")
    {
        json::number_float_t n_reference{42.23};
@@ -1269,7 +1257,6 @@ TEST_CASE("value conversion")
            CHECK(json(n).m_value.number_float == Approx(j.m_value.number_float));
        }
    }
 #endif
    SECTION("get a binary value (explicit)")
    {
@@ -1377,7 +1364,6 @@ TEST_CASE("value conversion")
        }
    }
 #if JSON_USE_IMPLICIT_CONVERSIONS
    SECTION("get a binary value (implicit)")
    {
        json::binary_t n_reference{{1, 2, 3}};
@@ -1389,7 +1375,6 @@ TEST_CASE("value conversion")
            CHECK(*json(b).m_value.binary == *j.m_value.binary);
        }
    }
 #endif
    SECTION("get an enum")
    {
@@ -1496,15 +1481,15 @@ TEST_CASE("value conversion")
                SECTION("std::array is larger than JSON")
                {
                    std::array<int, 6> arr6 = {{1, 2, 3, 4, 5, 6}};
-                    CHECK_THROWS_AS(j1.get_to(arr6), json::out_of_range&);
+                    CHECK_THROWS_AS(arr6 = j1, json::out_of_range&);
-                    CHECK_THROWS_WITH(j1.get_to(arr6), "[json.exception.out_of_range.401] "
+                    CHECK_THROWS_WITH(arr6 = j1, "[json.exception.out_of_range.401] "
                                      "array index 4 is out of range");
                }
                SECTION("std::array is smaller than JSON")
                {
                    std::array<int, 2> arr2 = {{8, 9}};
-                    j1.get_to(arr2);
+                    arr2 = j1;
                    CHECK(arr2[0] == 1);
                    CHECK(arr2[1] == 2);
                }
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,84 +0,0 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
 |  |  |__   |  |  | | | |  version 3.9.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
 SPDX-License-Identifier: MIT
 Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
 Permission is hereby  granted, free of charge, to any  person obtaining a copy
 of this software and associated  documentation files (the "Software"), to deal
 in the Software  without restriction, including without  limitation the rights
 to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
 copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
 IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
 FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
 AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
 LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 #include "doctest_compatibility.h"
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;
 #include <set>
 TEST_CASE("hash")
 {
    // Collect hashes for different JSON values and make sure that they are distinct
    // We cannot compare against fixed values, because the implementation of
    // std::hash may differ between compilers.
    std::set<std::size_t> hashes;
    // null
    hashes.insert(std::hash<json> {}(json(nullptr)));
    // boolean
    hashes.insert(std::hash<json> {}(json(true)));
    hashes.insert(std::hash<json> {}(json(false)));
    // string
    hashes.insert(std::hash<json> {}(json("")));
    hashes.insert(std::hash<json> {}(json("foo")));
    // number
    hashes.insert(std::hash<json> {}(json(0)));
    hashes.insert(std::hash<json> {}(json(unsigned(0))));
    hashes.insert(std::hash<json> {}(json(-1)));
    hashes.insert(std::hash<json> {}(json(0.0)));
    hashes.insert(std::hash<json> {}(json(42.23)));
    // array
    hashes.insert(std::hash<json> {}(json::array()));
    hashes.insert(std::hash<json> {}(json::array({1, 2, 3})));
    // object
    hashes.insert(std::hash<json> {}(json::object()));
    hashes.insert(std::hash<json> {}(json::object({{"foo", "bar"}})));
    // binary
    hashes.insert(std::hash<json> {}(json::binary({})));
    hashes.insert(std::hash<json> {}(json::binary({}, 0)));
    hashes.insert(std::hash<json> {}(json::binary({}, 42)));
    hashes.insert(std::hash<json> {}(json::binary({1, 2, 3})));
    hashes.insert(std::hash<json> {}(json::binary({1, 2, 3}, 0)));
    hashes.insert(std::hash<json> {}(json::binary({1, 2, 3}, 42)));
    // discarded
    hashes.insert(std::hash<json> {}(json(json::value_t::discarded)));
    CHECK(hashes.size() == 21);
 }
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1,7 +1,7 @@
 /*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.9.0
+|  |  |__   |  |  | | | |  version 3.8.0
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Niels Lohmann	c13ecd5344	💚 add trait for 128 bit integers	2020-07-13 14:03:04 +02:00
Niels Lohmann	0f1f5052bf	💚 add trait for 128 bit integers	2020-07-13 13:46:56 +02:00
Niels Lohmann	e3aace6dac	🔊 add test for type traits	2020-07-13 13:23:36 +02:00
Niels Lohmann	039c97694d	🔥 remove failing test	2020-07-13 12:51:39 +02:00
Niels Lohmann	23496a3abf	🔊 add test for type traits	2020-07-13 12:44:34 +02:00
Niels Lohmann	bffa18b46e	♻️ replace alternative operator	2020-07-12 17:44:39 +02:00
Niels Lohmann	de4933e093	🎨 fix format	2020-07-12 17:39:36 +02:00
Niels Lohmann	aba37d001e	Merge branch 'develop' of https://github.com/nlohmann/json into issue2228	2020-07-12 17:39:13 +02:00
Niels Lohmann	b6d0a4ab30	Merge branch 'develop' of https://github.com/nlohmann/json into issue2228	2020-07-10 12:46:43 +02:00
Niels Lohmann	2c231f9567	💚 remove failing test	2020-07-10 12:46:31 +02:00
Niels Lohmann	7fbcae2679	🚨 fix a warning	2020-07-09 22:17:59 +02:00
Niels Lohmann	3aa4c0b827	✅ add tests for number types	2020-07-09 22:07:07 +02:00
Niels Lohmann	612f326052	♻️ add proper SFINAE for 64 bit check	2020-07-09 21:31:01 +02:00
Niels Lohmann	0c4e6aa2cd	♻️ move integer conversion out of scan_number	2020-07-09 14:21:39 +02:00
		`@@ -1 +1 @@`
			`<a target="_blank" href="https://wandbox.org/permlink/shE8T6phAQiEzAad"><b>online</b></a>`				`<a target="_blank" href="https://wandbox.org/permlink/EezQxM0Nzi8tTUEe"><b>online</b></a>`