Sweep invalid UTF-8 at every position through dump()

Compare dump() of strings with ill-formed UTF-8 (stray continuation bytes, invalid lead bytes, overlong encodings, surrogates, code points above U+10FFFF, and sequences cut short by ASCII, a quote, a backslash, a lead byte, or the end of the string) with an independent reference serializer, for every error handler and with ensure_ascii on and off. The pattern is put at every position of short strings to cross the strides of the bulk scanners, and of longer ones to cross the end of the 512-byte string buffer. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Avoid raw string literals with backslashes in CHECK macros
2026-10-15 10:47:13 +00:00 · 2026-10-15 09:24:33 +02:00 · 2026-10-14 22:38:07 +02:00 · 2026-10-14 09:16:40 +02:00
69 changed files with 2065 additions and 4939 deletions
@@ -28,7 +28,7 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -22,7 +22,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -46,7 +46,7 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -20,7 +20,7 @@ jobs:
    timeout-minutes: 30
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-22.04
    steps:
    - name: Harden Runner
-      uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+      uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
      with:
        egress-policy: audit
@@ -27,7 +27,7 @@ jobs:
    steps:
    - name: Harden Runner
-      uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+      uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
      with:
        egress-policy: audit
@@ -20,7 +20,7 @@ jobs:
      pull-requests: write
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -21,7 +21,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -31,7 +31,7 @@ jobs:
      security-events: write
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -23,7 +23,7 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -37,7 +37,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -40,7 +40,7 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -36,7 +36,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -16,7 +16,7 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -80,7 +80,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -112,7 +112,7 @@ jobs:
        target: [ci_test_single_header, ci_cppcheck, ci_cpplint, ci_reproducible_tests, ci_non_git_tests, ci_offline_testdata, ci_reuse_compliance, ci_test_valgrind]
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -178,7 +178,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -433,7 +433,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -456,7 +456,7 @@ jobs:
        target: [ci_test_examples, ci_test_build_documentation, ci_test_documentation_mermaid]
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@351661ca32ac09a36dc5ee2d536e3128f2a3c8ed # v2.22.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -25,7 +25,6 @@ cc_library(
        "include/nlohmann/detail/conversions/from_json.hpp",
        "include/nlohmann/detail/conversions/to_chars.hpp",
        "include/nlohmann/detail/conversions/to_json.hpp",
        "include/nlohmann/detail/conversions/zmij.hpp",
        "include/nlohmann/detail/exceptions.hpp",
        "include/nlohmann/detail/hash.hpp",
        "include/nlohmann/detail/input/binary_reader.hpp",
@@ -116,7 +116,7 @@ There is also a [**docset**](https://github.com/Kapeli/Dash-User-Contributions/t
 - **Constructors**: [basic_json](https://json.nlohmann.me/api/basic_json/basic_json), [array](https://json.nlohmann.me/api/basic_json/array), [binary](https://json.nlohmann.me/api/basic_json/binary), [object](https://json.nlohmann.me/api/basic_json/object)
 - **Object inspection**: [type](https://json.nlohmann.me/api/basic_json/type), [operator value_t](https://json.nlohmann.me/api/basic_json/operator_value_t), [type_name](https://json.nlohmann.me/api/basic_json/type_name), [is_primitive](https://json.nlohmann.me/api/basic_json/is_primitive), [is_structured](https://json.nlohmann.me/api/basic_json/is_structured), [is_null](https://json.nlohmann.me/api/basic_json/is_null), [is_boolean](https://json.nlohmann.me/api/basic_json/is_boolean), [is_number](https://json.nlohmann.me/api/basic_json/is_number), [is_number_integer](https://json.nlohmann.me/api/basic_json/is_number_integer), [is_number_unsigned](https://json.nlohmann.me/api/basic_json/is_number_unsigned), [is_number_float](https://json.nlohmann.me/api/basic_json/is_number_float), [is_object](https://json.nlohmann.me/api/basic_json/is_object), [is_array](https://json.nlohmann.me/api/basic_json/is_array), [is_string](https://json.nlohmann.me/api/basic_json/is_string), [is_binary](https://json.nlohmann.me/api/basic_json/is_binary), [is_discarded](https://json.nlohmann.me/api/basic_json/is_discarded)
 - **Value access**: [get](https://json.nlohmann.me/api/basic_json/get), [get_to](https://json.nlohmann.me/api/basic_json/get_to), [get_ptr](https://json.nlohmann.me/api/basic_json/get_ptr), [get_ref](https://json.nlohmann.me/api/basic_json/get_ref), [operator ValueType](https://json.nlohmann.me/api/basic_json/operator_ValueType), [get_binary](https://json.nlohmann.me/api/basic_json/get_binary)
- **Element access**: [at](https://json.nlohmann.me/api/basic_json/at), [operator[]](https://json.nlohmann.me/api/basic_json/operator%5B%5D/), [value](https://json.nlohmann.me/api/basic_json/value), [front](https://json.nlohmann.me/api/basic_json/front), [back](https://json.nlohmann.me/api/basic_json/back)
+- **Element access**: [at](https://json.nlohmann.me/api/basic_json/at), [operator[]](https://json.nlohmann.me/api/basic_json/operator[]), [value](https://json.nlohmann.me/api/basic_json/value), [front](https://json.nlohmann.me/api/basic_json/front), [back](https://json.nlohmann.me/api/basic_json/back)
 - **Lookup**: [find](https://json.nlohmann.me/api/basic_json/find), [count](https://json.nlohmann.me/api/basic_json/count), [contains](https://json.nlohmann.me/api/basic_json/contains)
 - **Iterators**: [begin](https://json.nlohmann.me/api/basic_json/begin), [cbegin](https://json.nlohmann.me/api/basic_json/cbegin), [end](https://json.nlohmann.me/api/basic_json/end), [cend](https://json.nlohmann.me/api/basic_json/cend), [rbegin](https://json.nlohmann.me/api/basic_json/rbegin), [rend](https://json.nlohmann.me/api/basic_json/rend), [crbegin](https://json.nlohmann.me/api/basic_json/crbegin), [crend](https://json.nlohmann.me/api/basic_json/crend), [items](https://json.nlohmann.me/api/basic_json/items)
 - **Capacity**: [empty](https://json.nlohmann.me/api/basic_json/empty), [size](https://json.nlohmann.me/api/basic_json/size), [max_size](https://json.nlohmann.me/api/basic_json/max_size)
@@ -125,7 +125,7 @@ There is also a [**docset**](https://github.com/Kapeli/Dash-User-Contributions/t
 - **Serialization / Dumping**: [dump](https://json.nlohmann.me/api/basic_json/dump)
 - **Deserialization / Parsing**: [parse](https://json.nlohmann.me/api/basic_json/parse), [accept](https://json.nlohmann.me/api/basic_json/accept), [sax_parse](https://json.nlohmann.me/api/basic_json/sax_parse)
 - **JSON Pointer functions**: [flatten](https://json.nlohmann.me/api/basic_json/flatten), [unflatten](https://json.nlohmann.me/api/basic_json/unflatten)
- **JSON Patch functions**: [patch](https://json.nlohmann.me/api/basic_json/patch), [patch_inplace](https://json.nlohmann.me/api/basic_json/patch_inplace), [diff](https://json.nlohmann.me/api/basic_json/diff), [merge_patch](https://json.nlohmann.me/api/basic_json/merge_patch), [merge_diff](https://json.nlohmann.me/api/basic_json/merge_diff)
+- **JSON Patch functions**: [patch](https://json.nlohmann.me/api/basic_json/patch), [patch_inplace](https://json.nlohmann.me/api/basic_json/patch_inplace), [diff](https://json.nlohmann.me/api/basic_json/diff), [merge_patch](https://json.nlohmann.me/api/basic_json/merge_patch)
 - **Static functions**: [meta](https://json.nlohmann.me/api/basic_json/meta), [get_allocator](https://json.nlohmann.me/api/basic_json/get_allocator)
 - **Binary formats**: [from_bjdata](https://json.nlohmann.me/api/basic_json/from_bjdata), [from_bon8](https://json.nlohmann.me/api/basic_json/from_bon8), [from_bson](https://json.nlohmann.me/api/basic_json/from_bson), [from_cbor](https://json.nlohmann.me/api/basic_json/from_cbor), [from_msgpack](https://json.nlohmann.me/api/basic_json/from_msgpack), [from_ubjson](https://json.nlohmann.me/api/basic_json/from_ubjson), [to_bjdata](https://json.nlohmann.me/api/basic_json/to_bjdata), [to_bon8](https://json.nlohmann.me/api/basic_json/to_bon8), [to_bson](https://json.nlohmann.me/api/basic_json/to_bson), [to_cbor](https://json.nlohmann.me/api/basic_json/to_cbor), [to_msgpack](https://json.nlohmann.me/api/basic_json/to_msgpack), [to_ubjson](https://json.nlohmann.me/api/basic_json/to_ubjson)
 - **Non-member functions**: [operator<<](https://json.nlohmann.me/api/operator_ltlt/), [operator>>](https://json.nlohmann.me/api/operator_gtgt/), [to_string](https://json.nlohmann.me/api/basic_json/to_string)
@@ -360,7 +360,7 @@ std::cout << cpp_string << " == " << cpp_string2 << " == " << j_string.get<std::
 std::cout << j_string << " == " << serialized_string << std::endl;
 ```
-[`.dump()`](https://json.nlohmann.me/api/basic_json/dump/) returns the serialized JSON text, so a string value is enclosed in quotes and special characters are escaped. Use [`get<std::string>()`](https://json.nlohmann.me/api/basic_json/get/) to retrieve the originally stored string value.
+[`.dump()`](https://json.nlohmann.me/api/basic_json/dump/) returns the originally stored string value.
 Note the library only supports UTF-8. When you store strings with different encodings in the library, calling [`dump()`](https://json.nlohmann.me/api/basic_json/dump/) may throw an exception unless `json::error_handler_t::replace`, `json::error_handler_t::ignore`, or `json::error_handler_t::keep` are used as error handlers.
@@ -695,7 +695,7 @@ json::diff(j_result, j_original);
 ### JSON Merge Patch
-The library supports **JSON Merge Patch** ([RFC 7396](https://tools.ietf.org/html/rfc7396)) as a patch format. Instead of using JSON Pointer (see above) to specify values to be manipulated, it describes the changes using a syntax that closely mimics the document being modified.
+The library supports **JSON Merge Patch** ([RFC 7386](https://tools.ietf.org/html/rfc7386)) as a patch format. Instead of using JSON Pointer (see above) to specify values to be manipulated, it describes the changes using a syntax that closely mimics the document being modified.
 ```cpp
 // a JSON value
@@ -725,20 +725,6 @@ j_document.merge_patch(j_patch);
 // }
 ```
 Conversely, [`merge_diff`](https://json.nlohmann.me/api/basic_json/merge_diff/) creates a merge patch from two JSON values:
 ```cpp
 // create a merge patch that turns j_original into j_document
 json j_original = R"({"a": "b", "c": {"d": "e", "f": "g"}})"_json;
 json::merge_diff(j_original, j_document);
 // {
 //  "a": "z",
 //  "c": {
 //    "f": null
 //  }
 // }
 ```
 ### Implicit conversions
 Supported types can be implicitly converted to JSON values.
@@ -1280,9 +1266,13 @@ The package configuration file, `nlohmann_jsonConfig.cmake`, can be used either
 To embed the library directly into an existing CMake project, place the entire source tree in a subdirectory and call `add_subdirectory()` in your `CMakeLists.txt` file:
 ```cmake
 # Typically you don't care so much for a third party library's tests to be
 # run from your own project's code.
 set(JSON_BuildTests OFF CACHE INTERNAL "")
 # If you only include this third party in PRIVATE source files, you do not
 # need to install it when your main project gets installed.
-set(JSON_Install OFF CACHE INTERNAL "")
+# set(JSON_Install OFF CACHE INTERNAL "")
 # Don't use include(nlohmann_json/CMakeLists.txt) since that carries with it
 # unintended consequences that will break the build.  It's generally
@@ -1297,8 +1287,8 @@ target_link_libraries(foo PRIVATE nlohmann_json::nlohmann_json)
 ##### Embedded (FetchContent)
-Since CMake v3.14,
+Since CMake v3.11,
-[FetchContent](https://cmake.org/cmake/help/v3.14/module/FetchContent.html) can
+[FetchContent](https://cmake.org/cmake/help/v3.11/module/FetchContent.html) can
 be used to automatically download a release as a dependency at configure time.
 Example:
@@ -1363,9 +1353,7 @@ Use your favorite [**package manager**](https://json.nlohmann.me/integration/pac
 - <img src="https://raw.githubusercontent.com/nlohmann/json/refs/heads/develop/docs/mkdocs/docs/images/package_managers/swift.svg" height="20">&nbsp;[**Swift Package Manager**](https://json.nlohmann.me/integration/package_managers/#swift-package-manager) `nlohmann/json`
 - <img src="https://raw.githubusercontent.com/nlohmann/json/refs/heads/develop/docs/mkdocs/docs/images/package_managers/nuget.svg" height="20">&nbsp;[**Nuget**](https://json.nlohmann.me/integration/package_managers/#nuget) `nlohmann.json`
 - <img src="https://raw.githubusercontent.com/nlohmann/json/refs/heads/develop/docs/mkdocs/docs/images/package_managers/conda.svg" height="20">&nbsp;[**Conda**](https://json.nlohmann.me/integration/package_managers/#conda) `nlohmann_json`
 - [**MSYS2**](https://json.nlohmann.me/integration/package_managers/#msys2) `mingw-w64-nlohmann-json`
 - <img src="https://raw.githubusercontent.com/nlohmann/json/refs/heads/develop/docs/mkdocs/docs/images/package_managers/macports.svg" height="20">&nbsp;[**MacPorts**](https://json.nlohmann.me/integration/package_managers/#macports) `nlohmann-json`
 - [**build2**](https://json.nlohmann.me/integration/package_managers/#build2) `nlohmann-json`
 - <img src="https://raw.githubusercontent.com/nlohmann/json/refs/heads/develop/docs/mkdocs/docs/images/package_managers/CPM.png" height="20">&nbsp;[**cpm.cmake**](https://json.nlohmann.me/integration/package_managers/#cpmcmake) `gh:nlohmann/json`
 - <img src="https://raw.githubusercontent.com/nlohmann/json/refs/heads/develop/docs/mkdocs/docs/images/package_managers/xmake.svg" height="20">&nbsp;[**xmake**](https://json.nlohmann.me/integration/package_managers/#xmake) `nlohmann_json`
@@ -1397,10 +1385,9 @@ THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR I
 - The class contains the UTF-8 Decoder from Bjoern Hoehrmann which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2008-2009 [Björn Hoehrmann](https://bjoern.hoehrmann.de/) <bjoern@hoehrmann.de>
 - The class contains a slightly modified version of the Grisu2 algorithm from Florian Loitsch which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2009 [Florian Loitsch](https://florian.loitsch.com/)
 - The class contains a port of the shortest double-to-decimal conversion of [Żmij](https://github.com/vitaut/zmij) by Victor Zverovich, including the conversion of the digits to text by Xiang JunBo and the SIMD instruction sequence of Dougall Johnson, which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2025 [Victor Zverovich](https://github.com/vitaut)
 - The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).
 - The class contains parts of [Google Abseil](https://github.com/abseil/abseil-cpp) which is licensed under the [Apache 2.0 License](https://opensource.org/licenses/Apache-2.0).
- The class contains an adapted version of the Eisel-Lemire algorithm, its table of powers of five, and its digit comparison for long numbers from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
+- The class contains an adapted version of the Eisel-Lemire algorithm and its table of powers of five from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
 <img align="right" src="https://git.fsfe.org/reuse/reuse-ci/raw/branch/master/reuse-horizontal.png" alt="REUSE Software">
@@ -27,7 +27,7 @@ To store objects in C++, a type is defined by the template parameters explained
 ### Default type
-With the default values for `ArrayType` (`std::vector`) and `AllocatorType` (`std::allocator`), the default type for
+With the default values for `ArrayType` (`std::vector`) and `AllocatorType` (`std::allocator`), the default value for
 `array_t` is:
 ```cpp
@@ -23,7 +23,7 @@ To store boolean values in C++, a type is defined by the template parameter  `Bo
 ### Default type
-With the default values for `BooleanType` (`#!cpp bool`), the default type for `boolean_t` is `#!cpp bool`.
+With the default values for `BooleanType` (`#!cpp bool`), the default value for `boolean_t` is `#!cpp bool`.
 ### Storage
@@ -62,9 +62,6 @@ Linear.
 ## Notes
 Floating-point numbers are written with the fewest digits that read back as the same value (for `#!cpp double`; see
 [number handling](../../features/types/number_handling.md#number-serialization)).
 Binary values are serialized as an object containing two keys:
 - "bytes": an array of bytes as integers
@@ -100,5 +97,3 @@ Binary values are serialized as an object containing two keys:
 - Error handlers added in version 3.4.0.
 - Serialization of binary values added in version 3.8.0.
 - Error handler `keep` added in version 3.13.0.
 - Doubles are written with the shortest digits (Żmij instead of Grisu2) since version 3.13.0; about 0.1% of doubles are
  written differently, most of them with fewer digits.
@@ -85,7 +85,7 @@ The class satisfies the following concept requirements:
 - [EqualityComparable](https://en.cppreference.com/w/cpp/named_req/EqualityComparable): JSON values can be compared with
  `==`, see [`operator==`](operator_eq.md).
 - [LessThanComparable](https://en.cppreference.com/w/cpp/named_req/LessThanComparable): JSON values can be compared with
-  `<`, see [`operator<`](operator_lt.md).
+  `<`, see [`operator<`](operator_le.md).
 - [Swappable](https://en.cppreference.com/w/cpp/named_req/Swappable): Any JSON lvalue or rvalue of can be swapped with
  any lvalue or rvalue of other compatible types, using unqualified function `swap`.
 - [NullablePointer](https://en.cppreference.com/w/cpp/named_req/NullablePointer): JSON values can be compared against
@@ -11,7 +11,7 @@ added members with their new values, and removed members with the value `#!json
 member by member; any other value that differs, including an array, is replaced as a whole.
 For two JSON values `source` and `target`, where `target` contains no object member whose value is `#!json null`, the
-following code always yields `#!cpp true` (for [`ordered_json`](../ordered_json.md), see the notes below):
+following code always yields `#!cpp true`:
 ```cpp
 basic_json patched = source;
 patched.merge_patch(merge_diff(source, target));
@@ -23,10 +23,9 @@ type to use.
 ## Template parameters
 `NumberFloatType`
-:   the type to store floating-point numbers. The type must be `#!cpp float`, `#!cpp double`, or
+:   the type to store floating-point numbers. Parsing and serialization are implemented in terms of
-    `#!cpp long double`. The parser converts `#!cpp float`, `#!cpp double`, and a `#!cpp long double` that is IEEE 754
+    `#!cpp std::strtof`/`#!cpp std::strtod`/`#!cpp std::strtold` and `#!cpp std::snprintf`, so the type must be
-    binary64 itself. It converts other `#!cpp long double` formats with `#!cpp std::from_chars` where available, or
+    `#!cpp float`, `#!cpp double`, or `#!cpp long double`. The
    with `#!cpp std::strtold` otherwise. Serialization falls back to `#!cpp std::snprintf`. The
    [binary formats](../../features/binary_formats/index.md) additionally require `#!cpp float` or `#!cpp double`,
    because they have no encoding for `#!cpp long double`. See
    [Template Parameter Requirements](../../features/types/template_parameters.md#numberfloattype).
@@ -35,7 +34,7 @@ type to use.
 ### Default type
-With the default values for `NumberFloatType` (`double`), the default type for `number_float_t` is `#!cpp double`.
+With the default values for `NumberFloatType` (`double`), the default value for `number_float_t` is `#!cpp double`.
 ### Default behavior
@@ -52,11 +51,9 @@ With the default values for `NumberFloatType` (`double`), the default type for `
 > interoperability can be achieved by implementations that expect no more precision or range than these provide, in the
 > sense that implementations will approximate JSON numbers within the expected precision.
-This implementation does exactly follow this approach, as it uses double precision floating-point numbers by default.
+This implementation does exactly follow this approach, as it uses double precision floating-point numbers. Note values
-Note that with the default `double`, numbers smaller than `-1.79769313486232e+308` or greater than
+smaller than `-1.79769313486232e+308` and values greater than `1.79769313486232e+308` will be stored as NaN internally
-`1.79769313486232e+308` are rejected during parsing with
+and be serialized to `null`.
 [`out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406). Non-finite values (NaN and infinity) can
 only be stored by assigning them directly and are serialized to `null`.
 During deserialization (from JSON text or any of the binary formats), a finite number that does not fit into
 `number_float_t` is rejected with [`out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406), for
@@ -31,7 +31,7 @@ to use.
 ### Default type
-With the default values for `NumberIntegerType` (`std::int64_t`), the default type for `number_integer_t` is
+With the default values for `NumberIntegerType` (`std::int64_t`), the default value for `number_integer_t` is
 `#!cpp std::int64_t`.
 ### Default behavior
@@ -32,7 +32,7 @@ the type to use.
 ### Default type
-With the default values for `NumberUnsignedType` (`std::uint64_t`), the default type for `number_unsigned_t` is
+With the default values for `NumberUnsignedType` (`std::uint64_t`), the default value for `number_unsigned_t` is
 `#!cpp std::uint64_t`.
 ### Default behavior
@@ -36,7 +36,7 @@ To store objects in C++, a type is defined by the template parameters described
 ### Default type
 With the default values for `ObjectType` (`std::map`), `StringType` (`std::string`), and `AllocatorType`
-(`std::allocator`), the default type for `object_t` is:
+(`std::allocator`), the default value for `object_t` is:
 ```cpp
 // until C++14
@@ -20,8 +20,7 @@ bool operator==(ScalarType rhs) const noexcept(/* see below */); // (2)
 1. Compares two JSON values for equality according to the following rules:
    - Two JSON values are equal if (1) neither value is discarded, and (2) they are of the same type and their stored
      values are the same according to their respective `operator==`.
-    - Integer and floating-point numbers are compared by their exact values, without converting the integer to
+    - Integer and floating-point numbers are automatically converted before comparison.
      floating-point. For instance, `9007199254740993` and `9007199254740992.0` are not equal.
 2. Compares a JSON value and a scalar or a scalar and a JSON value for equality by converting the
   scalar to a JSON value and comparing both JSON values according to 1.
@@ -15,8 +15,7 @@ bool operator<(ScalarType lhs, const const_reference rhs) noexcept(/* see below
  following rules:
    - If either operand is discarded, the comparison yields `#!cpp false`.
    - If both operands have the same type, the values are compared using their respective `operator<`.
-    - Integer and floating-point numbers are compared by their exact values, without converting the integer to
+    - Integer and floating-point numbers are automatically converted before comparison.
      floating-point. For instance, `9007199254740992.0` is less than `9007199254740993`.
    - In case `lhs` and `rhs` have different types, the values are ignored and the order of the types
      is considered, which is:
        1. null
@@ -12,8 +12,10 @@ std::partial_ordering operator<=>(const ScalarType rhs) const noexcept(/* see be
    - Two JSON values compare with a result of `std::partial_ordering::unordered` if either value is discarded.
    - If both JSON values are of the same type, the result is produced by 3-way comparing their stored values using
      their respective `operator<=>`.
-    - Integer and floating-point numbers are 3-way compared by their exact values, without converting the integer to
+    - Integer and floating-point numbers are converted to their common type and then 3-way compared using their
-      floating-point. For instance, `9007199254740993` compares greater than `9007199254740992.0`.
+      respective `operator<=>`.
      For instance, comparing an integer and a floating-point value will 3-way compare the first value converted to
      floating-point with the second value.
    - Otherwise, yields a result by comparing the type (see [`value_t`](value_t.md)).
 2. 3-way compares a JSON value and a scalar or a scalar and a JSON value by converting the scalar to a JSON value and
@@ -45,7 +45,7 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  pointer inside the patch cannot be resolved, e.g., `-` in a "remove" operation or `1a` for an array; example:
  `"unresolved reference token '-'"`.
 - Throws [`out_of_range.405`](../../home/exceptions.md#jsonexceptionout_of_range405) if JSON pointer has no parent
-  ("remove", "move")
+  ("add", "remove", "move")
 - Throws [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) if an "add" operation's target
  location has a parent that is neither an object nor an array.
 - Throws [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) if a "remove" operation's target
@@ -41,7 +41,7 @@ No guarantees, value may be corrupted by an unsuccessful patch operation.
  pointer inside the patch cannot be resolved, e.g., `-` in a "remove" operation or `1a` for an array; example:
  `"unresolved reference token '-'"`.
 - Throws [`out_of_range.405`](../../home/exceptions.md#jsonexceptionout_of_range405) if JSON pointer has no parent
-  ("remove", "move")
+  ("add", "remove", "move")
 - Throws [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) if an "add" operation's target
  location has a parent that is neither an object nor an array.
 - Throws [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) if a "remove" operation's target
@@ -32,7 +32,7 @@ JSON class into byte-sized characters during deserialization.
 ### Default type
-With the default values for `StringType` (`std::string`), the default type for `string_t` is `#!cpp std::string`.
+With the default values for `StringType` (`std::string`), the default value for `string_t` is `#!cpp std::string`.
 ### Encoding
@@ -18,8 +18,7 @@ When enabled, comparisons involving at least one discarded JSON value yield resu
 | `>=`         | `#!cpp true`  |
 | `>`          | `#!cpp false` |
-Otherwise, comparisons involving at least one discarded JSON value yield `#!cpp false`, except for `!=`, which is the
+Otherwise, comparisons involving at least one discarded JSON value always yield `#!cpp false`.
 negation of `==` and yields `#!cpp true`.
 ## Default definition
@@ -54,9 +54,10 @@ flowchart LR
  user code. The destructor does not recurse, so destroying a deeply nested value does not exhaust the stack.
 - **Bounded recursion.** The JSON parser and the binary readers keep their state in explicit stacks instead of
  recursing per nesting level. Operations that walk a value, such as [`dump`](../api/basic_json/dump.md), copying,
-  comparison, hashing, [`merge_patch`](../api/basic_json/merge_patch.md), [`diff`](../api/basic_json/diff.md),
+  comparison, hashing, and [`merge_patch`](../api/basic_json/merge_patch.md), recurse only up to a fixed depth and
-  [`flatten`](../api/basic_json/flatten.md), and the binary writers, recurse only up to a fixed depth and continue with
+  continue with an explicit stack below it. Some operations, such as [`diff`](../api/basic_json/diff.md),
-  an explicit stack below it. Applications that process untrusted input can limit its nesting depth with a
+  [`flatten`](../api/basic_json/flatten.md), and the binary writers, still recurse once per nesting level; work on them
  is in progress. Applications that process untrusted input can limit its nesting depth with a
  [parser callback](../features/parsing/parser_callbacks.md).
 - **Invariants are checked.** The class invariant (for instance, that the pointer for the stored type is never null) is
  checked with runtime assertions throughout the test suite.
@@ -267,10 +267,9 @@ unsigned 8-bit integer. If no subtype is given, the generic binary subtype 0x00
 ### CBOR
-[CBOR](binary_formats/cbor.md) supports binary values and subtypes. Any binary value will be serialized as a byte
+[CBOR](binary_formats/cbor.md) supports binary values, but no subtypes. Subtypes will be serialized as tags. Any binary
-string; a subtype is serialized as a tag preceding it. When parsing, tags are only read back as subtypes with
+value will be serialized as byte strings. The library will choose the smallest representation using the length of the
-`cbor_tag_handler_t::store` (see [`from_cbor`](../api/basic_json/from_cbor.md)). The library will choose the smallest
+byte array.
 representation using the length of the byte array.
 ??? example "Example: serialize a binary value to CBOR"
@@ -243,9 +243,9 @@ See [full documentation of `JSON_USE_GLOBAL_UDLS`](../api/macros/json_use_global
 ## `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`
-When defined to `1`, the library restores the legacy behavior in which comparing a discarded value with `<=` or `>=`
+When defined to `1`, the library restores the legacy behavior in which a discarded value compared equal to itself. This
-yields `#!cpp true` instead of `#!cpp false`. This behavior is
+behavior is [deprecated](../integration/migration_guide.md#miscellaneous-functions) and switched off (`0`) by
-[deprecated](../integration/migration_guide.md#miscellaneous-functions) and switched off (`0`) by default.
+default.
 See [full documentation of `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../api/macros/json_use_legacy_discarded_value_comparison.md).
@@ -1,6 +1,6 @@
 # JSON Merge Patch
-The library supports JSON Merge Patch ([RFC 7396](https://tools.ietf.org/html/rfc7396)) as a patch format.
+The library supports JSON Merge Patch ([RFC 7386](https://tools.ietf.org/html/rfc7386)) as a patch format.
 The merge patch format is primarily intended for use with the HTTP PATCH method as a means of describing a set of
 modifications to a target resource's content. This function applies a merge patch to the current JSON value.
@@ -66,7 +66,7 @@ config.update(user_settings, true);
 // {"log":{"file":"app.log","level":"debug"},"retries":3}
 ```
-[JSON Merge Patch](merge_patch.md) ([RFC 7396](https://tools.ietf.org/html/rfc7396)) also merges objects recursively,
+[JSON Merge Patch](merge_patch.md) ([RFC 7386](https://tools.ietf.org/html/rfc7386)) also merges objects recursively,
 but it is a different tool: a `#!json null` in the patch means "remove this key". It is meant for applying merge patch
 documents (e.g., received via HTTP PATCH). To merge configuration-like objects, use `#!cpp update(..., true)`. To apply
 a sequence of well-defined edit operations, see [JSON Patch](json_patch.md).
@@ -90,6 +90,6 @@ a.erase(1);             // [1,3,4]  (erase by index)
 - [`push_back`](../api/basic_json/push_back.md) / [`emplace_back`](../api/basic_json/emplace_back.md) - append to an array
 - [`emplace`](../api/basic_json/emplace.md) - insert into an object if the key is absent
 - [`update`](../api/basic_json/update.md) - merge objects (shallow, or recursive with `merge_objects`)
- [`merge_patch`](../api/basic_json/merge_patch.md) - apply an RFC 7396 merge patch
+- [`merge_patch`](../api/basic_json/merge_patch.md) - apply an RFC 7386 merge patch
 - [`erase`](../api/basic_json/erase.md) / [`clear`](../api/basic_json/clear.md) - remove elements
 - [JSON Patch and Diff](json_patch.md) and [JSON Merge Patch](merge_patch.md) - structured modifications
@@ -50,13 +50,19 @@ stack, however deeply it is nested.
 Once a value has been parsed, operations that walk it recursively -- serializing it with
 [`dump`](../../api/basic_json/dump.md), hashing it, copying it, comparing two values with `#!cpp ==`, `#!cpp <`, or (in
-C++20) `#!cpp <=>`, merging with [`update`](../../api/basic_json/update.md), applying a
+C++20) `#!cpp <=>`, merging with [`update`](../../api/basic_json/update.md), and applying a
-[`merge_patch`](../../api/basic_json/merge_patch.md), creating a patch with [`diff`](../../api/basic_json/diff.md) or
+[`merge_patch`](../../api/basic_json/merge_patch.md) -- descend at most 128 levels on the call stack and continue
 [`merge_diff`](../../api/basic_json/merge_diff.md), [`flatten`](../../api/basic_json/flatten.md), and the binary
 writers (`to_cbor`, `to_msgpack`, ...) -- descend at most 128 levels on the call stack and continue
 below that with an explicit stack instead, so none of them can exhaust the stack either, however deeply the value is
 nested. Destroying a value (its destructor) never recurses at all, regardless of nesting depth, for the same reason.
 !!! note "Not every operation is bounded yet"
    [`diff`](../../api/basic_json/diff.md), [`flatten`](../../api/basic_json/flatten.md), and the binary writers
    (`to_cbor`, `to_msgpack`, ...) still recurse once per nesting level; this is called out as work in progress in the
    [assurance case](../../community/assurance_case.md#secure-design). A value deep enough to matter for these
    operations would typically first have to survive parsing without hitting a self-imposed depth limit, as described
    above.
 ## Input size
 The library does not limit the overall size of a JSON text; a value nested or wide enough will use memory
@@ -52,7 +52,7 @@ with `\uXXXX` sequences, so that the output contains only ASCII characters:
 ```cpp
 json j = "苹果";
 j.dump();               // "苹果"
-j.dump(-1, ' ', true);  // "\u82f9\u679c"
+j.dump(-1, ' ', true);  // "苹果"
 ```
 ## Handling invalid UTF-8
@@ -120,7 +120,7 @@ requirements are collected in [Template Parameter Requirements](template_paramet
 ### Default type
-With the default values for *ObjectType* (`std::map`), *StringType* (`std::string`), and *AllocatorType* (`std::allocator`), the default type for `object_t` is:
+With the default values for *ObjectType* (`std::map`), *StringType* (`std::string`), and *AllocatorType* (`std::allocator`), the default value for `object_t` is:
 ```cpp
 std::map<
@@ -177,7 +177,7 @@ json j = m;
 ### Default type
-With the default values for *ArrayType* (`std::vector`) and *AllocatorType* (`std::allocator`), the default type for `array_t` is:
+With the default values for *ArrayType* (`std::vector`) and *AllocatorType* (`std::allocator`), the default value for `array_t` is:
 ```cpp
 std::vector<
@@ -209,7 +209,7 @@ Unicode values are split by the JSON class into byte-sized characters during des
 ### Default type
-With the default values for *StringType* (`std::string`), the default type for `string_t` is `#!cpp std::string`.
+With the default values for *StringType* (`std::string`), the default value for `string_t` is `#!cpp std::string`.
 ### Encoding
@@ -234,7 +234,7 @@ String values are stored as pointers in a `basic_json` type. That is, for any ac
 ### Default type
-With the default values for *BooleanType* (`#!cpp bool`), the default type for `boolean_t` is `#!cpp bool`.
+With the default values for *BooleanType* (`#!cpp bool`), the default value for `boolean_t` is `#!cpp bool`.
 ### Storage
@@ -252,9 +252,9 @@ This description includes both integer and floating-point numbers. However, C++
 ### Default types
-With the default values for *NumberIntegerType* (`std::int64_t`), the default type for `number_integer_t` is `std::int64_t`.
+With the default values for *NumberIntegerType* (`std::int64_t`), the default value for `number_integer_t` is `std::int64_t`.
-With the default values for *NumberUnsignedType* (`std::uint64_t`), the default type for `number_unsigned_t` is `std::uint64_t`.
+With the default values for *NumberUnsignedType* (`std::uint64_t`), the default value for `number_unsigned_t` is `std::uint64_t`.
-With the default values for *NumberFloatType* (`#!cpp double`), the default type for `number_float_t` is `#!cpp double`.
+With the default values for *NumberFloatType* (`#!cpp double`), the default value for `number_float_t` is `#!cpp double`.
 ### Default behavior
@@ -281,7 +281,7 @@ As this range is a subrange of the exactly supported range [`INT64_MIN`, `INT64_
 > This specification allows implementations to set limits on the range and precision of numbers accepted. Since software that implements IEEE 754-2008 binary64 (double precision) numbers is generally available and widely used, good interoperability can be achieved by implementations that expect no more precision or range than these provide, in the sense that implementations will approximate JSON numbers within the expected precision.
-This implementation does exactly follow this approach, as it uses double precision floating-point numbers by default (see *NumberFloatType* above). Note that with the default `#!cpp double`, numbers smaller than `#!c -1.79769313486232e+308` or greater than `#!c 1.79769313486232e+308` are rejected during parsing with [`out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406). Non-finite values (NaN and infinity) can only be stored by assigning them directly and are serialized to `#!json null`.
+This implementation does exactly follow this approach, as it uses double precision floating-point numbers. Note values smaller than `#!c -1.79769313486232e+308` and values greater than `#!c 1.79769313486232e+308` will be stored as NaN internally and be serialized to `#!json null`.
 ### Storage
@@ -82,13 +82,12 @@ flowchart TD
    - Numbers with a decimal digit or scientific notation are always stored as `#!c double`.
    - The number types can be changed, see [Template number types](#template-number-types). 
-    - The library converts integers and floating-point numbers itself, independent of the locale. Floating-point
+    - Integers are converted by the library's own digit parser. Floating-point numbers are converted with
-      numbers are correctly rounded (to nearest, ties to even). Only a `#!c long double` that is not IEEE 754 binary64
+      [`std::from_chars`](https://en.cppreference.com/w/cpp/utility/from_chars) if the library is compiled with C++17
-      (e.g., the 80-bit x87 format) is converted with `#!cpp std::from_chars` where available, or else with
+      and the standard library supports it, then with an exact fast path for `#!c double` values with few significant
-      [`std::strtold`](https://en.cppreference.com/w/cpp/string/byte/strtof). For that call, the library temporarily
+      digits, and otherwise with the locale-aware
-      replaces the `.` with the decimal point of the current locale (which may be longer than one byte, e.g., in
+      [`std::strtod`](https://en.cppreference.com/w/cpp/string/byte/strtof) (`std::strtof`/`std::strtold` for the
-      `fa_IR.UTF-8`), so the result does not depend on the locale either. Changing the locale in another thread during
+      other floating-point types). Before version 3.13.0, the conversion was realized by
      parsing is undefined behavior of the C library, though. Before version 3.13.0, the conversion was realized by
      [`std::strtoull`](https://en.cppreference.com/w/cpp/string/byte/strtoul),
      [`std::strtoll`](https://en.cppreference.com/w/cpp/string/byte/strtol), and `std::strtod`, respectively.
@@ -101,10 +100,10 @@ flowchart TD
 ### Number limits
 - Any 64-bit signed or unsigned integer can be stored without loss of precision.
- Numbers exceeding the limits of `#!c double` (i.e., numbers whose rounded value is not satisfying
+- Numbers exceeding the limits of `#!c double` (i.e., numbers that after conversion via
 [`std::strtod`](https://en.cppreference.com/w/cpp/string/byte/strtof) are not satisfying
 [`std::isfinite`](https://en.cppreference.com/w/cpp/numeric/math/isfinite) such as `#!c 1E400`) will throw exception
-[`json.exception.out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406) during parsing. Numbers too
+[`json.exception.out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406) during parsing.
 small for `#!c double` (such as `#!c 1E-400`) become zero, with the sign of the number.
 - Floating-point numbers are rounded to the next number representable as `double`. For instance
 `#!c 3.141592653589793238462643383279` is stored as [`0x400921fb54442d18`](https://float.exposed/0x400921fb54442d18).
 This is the same behavior as the code `#!c double x = 3.141592653589793238462643383279;`.
@@ -134,10 +133,9 @@ That is, `-0` is stored as a signed integer, but the serialization does not repr
 ### Number serialization
 - Integer numbers are serialized as is; that is, no scientific notation is used.
- Floating-point numbers are serialized with the fewest digits that read back as the same value (the closest such
+- Floating-point numbers are serialized as specified by the `#!c %g` printf modifier with 
-  digits if there are several), in the layout of the `#!c %g` printf modifier: `#!c 1.5`, `#!c 100.0`, `#!c 1e+100`.
+  [`std::numeric_limits<double>::max_digits10`](https://en.cppreference.com/w/cpp/types/numeric_limits/max_digits10)
-  Doubles are converted with the algorithm of [Żmij](https://github.com/vitaut/zmij), floats with Grisu2, which
+  significant digits. The rationale is to use the shortest representation while still allowing round-tripping.
  can write more digits than necessary.
 !!! hint "Notes regarding precision of floating-point numbers"
@@ -30,9 +30,9 @@ Requirements are split into two groups:
    diagnosed with dedicated error messages, and violating most of them results in a compiler error somewhere inside
    the library. Four violations are not caught at compile time at all:
-    - A [`StringType`](#stringtype) whose `data()` is not null-terminated compiles and silently misparses numbers
+    - A [`StringType`](#stringtype) whose `data()` is not null-terminated compiles and can silently misparse
-      stored as a `#!cpp long double` that is not IEEE 754 binary64 (e.g., the 80-bit x87 format), because the lexer
+      floating-point numbers, because the lexer may hand the buffer to `#!cpp std::strtod`, which reads up to the
-      hands the buffer to `#!cpp std::strtold`.
+      terminating null character.
    - A stateful [`AllocatorType`](#allocatortype) compiles and silently ignores its state: allocation, deallocation,
      and [`get_allocator()`](../../api/basic_json/get_allocator.md) each use a different default-constructed instance.
    - The two [cross-specialization conversions](#cross-specialization-conversions) below. These abort on an assertion
@@ -353,21 +353,16 @@ using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
 ### Always required
 - A member type `value_type` that is one byte wide and `char`-compatible. The library stores and processes UTF-8
-  encoded `char` data and passes `data()` to functions that take a `#!cpp const char*`, such as `#!cpp std::strtold`
+  encoded `char` data and passes `data()` to functions that take a `#!cpp const char*`, such as `#!cpp std::strtod`.
  (only used to parse a `#!cpp long double` that is not IEEE 754 binary64, see
  [`NumberFloatType`](#numberfloattype)).
  `#!cpp std::wstring`, `#!cpp std::u16string`, and `#!cpp std::u32string` are **not** valid choices; see the FAQ on
  [wide string handling](../../home/faq.md#wide-string-handling).
 - Constructors: default, copy, move, from `#!cpp const char*` (which must not be `#!cpp explicit`), from
  `#!cpp (const char*, size_type)`, and from `#!cpp (size_type, char)`; and copy or move assignment.
 - Member functions `size()`, `clear()`, `resize(n, c)`, `data()`, `push_back(char)`, and `operator[]`
  (const and non-const, returning references). `c_str()` and `back()` are **not** required.
- `data()` must return a pointer to a contiguous, **null-terminated** buffer. `#!cpp float`, `#!cpp double`, and a
+- `data()` must return a pointer to a contiguous, **null-terminated** buffer -- the parser may hand it to
-  `#!cpp long double` that is IEEE 754 binary64 are converted by the library itself and do not depend on this. For any
+  `#!cpp std::strtod`, which reads up to the null character. A type whose `data()` is not null-terminated does not
-  other `NumberFloatType` (a `#!cpp long double` of another format), the parser falls back to `#!cpp std::strtold` when
+  fail to compile; it can silently misparse floating-point numbers.
  `#!cpp std::from_chars` is not available or declines the token, and `std::strtold` reads up to the null character. A type whose `data()`
  is not null-terminated does not fail to compile; with such a `NumberFloatType` it can silently misparse
  floating-point numbers.
 - `append(const char*, size_type)`, used by [`dump`](../../api/basic_json/dump.md), and `append(const StringType&)`,
  used by the CBOR reader for indefinite-length strings. The library's internal string concatenation additionally has
  to append a `#!cpp char` and a `#!cpp const char*`; for each it selects between `append(arg)`, `#!cpp operator+=`,
@@ -546,18 +541,16 @@ therefore silently changes parse results rather than raising an error. See
 `NumberFloatType` must be one of `#!cpp float`, `#!cpp double`, or `#!cpp long double`:
- The [parser](../parsing/index.md) converts number literals to `#!cpp float`, `#!cpp double`, and a
+- The [parser](../parsing/index.md) converts number literals with `#!cpp std::from_chars` or, as a fallback, with
-  `#!cpp long double` that is IEEE 754 binary64 itself; other `#!cpp long double` formats are converted with
+  `#!cpp std::strtof`, `#!cpp std::strtod`, or `#!cpp std::strtold`; the library provides overloads for exactly these
-  `#!cpp std::from_chars` where available, or with `#!cpp std::strtold`. The library provides overloads for exactly
+  three types.
  these three types.
 - [`dump`](../../api/basic_json/dump.md) falls back to `#!cpp std::snprintf` with the `%g` and `%Lg` conversion
  specifiers, for which the library likewise provides only `#!cpp double` and `#!cpp long double` overloads
  (`#!cpp float` is promoted to `#!cpp double`).
-If `#!cpp std::numeric_limits<NumberFloatType>` describes an IEEE 754 binary64 number, `dump` uses the algorithm of
+If `#!cpp std::numeric_limits<NumberFloatType>` describes an IEEE 754 binary32 or binary64 number, `dump` uses the
-Żmij, which produces the shortest representation that round-trips. For IEEE 754 binary32 numbers, it uses Grisu2,
+Grisu2 algorithm, which produces the shortest representation that round-trips. Otherwise the `snprintf` fallback with
-which produces a short representation that round-trips. Otherwise the `snprintf` fallback with `max_digits10` digits is
+`max_digits10` digits is used.
 used.
 ### Required for the binary formats
@@ -569,7 +562,7 @@ binary32 or binary64 field and have no encoding for `#!cpp long double`.
 | Type                     | Support                                                                                                               |
 |--------------------------|-----------------------------------------------------------------------------------------------------------------------|
-| `#!cpp double` (default) | full; shortest round-trip output through Żmij                                                                         |
+| `#!cpp double` (default) | full; short round-trip output through Grisu2                                                                          |
 | `#!cpp float`            | full; short round-trip output through Grisu2                                                                          |
 | `#!cpp long double`      | `dump` and `parse` only; the binary format writers do not compile, as they only handle IEEE 754 binary32 and binary64 |
 | any other type           | not usable                                                                                                            |
@@ -889,9 +889,7 @@ contains other characters (e.g., `1a`), or `-` where it cannot be used.
 ### json.exception.out_of_range.405
-The JSON Patch operations 'remove' and 'move' cannot be applied to the root element of the JSON value. The exception is
+The JSON Patch operations 'remove' and 'add' cannot be applied to the root element of the JSON value.
 also thrown when the parent or a reference token of an empty JSON Pointer is requested, for instance by
 [`back`](../api/json_pointer/back.md) or [`pop_back`](../api/json_pointer/pop_back.md).
 !!! failure "Example message"
@@ -916,23 +914,15 @@ double-precision number when `number_float_t` is `#!cpp float`.
 ### json.exception.out_of_range.407
-An unsigned integer number greater than 9223372036854775807 cannot be represented in the binary format. This exception
+This exception previously indicated that the UBJSON and BSON binary formats did not support integer numbers greater than
-is only thrown by [`to_bon8`](../api/basic_json/to_bon8.md), as [BON8](../features/binary_formats/bon8.md) has no
+9223372036854775807 due to limitations in the implemented mapping. However, these limitations have since been resolved,
-unsigned 64-bit integer type.
+and this exception no longer occurs.
-!!! note "Former occurrences"
+!!! success "Exception cannot occur any more"
    The UBJSON and BSON writers used to throw this exception as well:
    - Since version 3.9.0, integer numbers beyond int64 are serialized as high-precision UBJSON numbers.
    - Since version 3.12.0, integer numbers beyond int64 are serialized as uint64 BSON numbers.
 !!! failure "Example message"
    ```
    integer number 18446744073709551615 cannot be represented by BON8 as it does not fit int64
    ```
 ### json.exception.out_of_range.408
 The size of an array or object in a [binary format](../features/binary_formats/index.md) exceeds the maximal capacity:
@@ -66,9 +66,7 @@ Without the macro (default behavior), `json j{obj}` creates `[{"key":"value"}]`.
    Can you add an option to ignore trailing commas?
-Yes, trailing commas in arrays and objects can be allowed by setting parameter `ignore_trailing_commas` of
+This library does not support any feature that would jeopardize interoperability.
 [`parse`](../api/basic_json/parse.md) to `#!cpp true`; see [trailing commas](../features/trailing_commas.md). They are
 rejected by default, and the library never adds them when serializing.
 ### Parse errors reading non-ASCII characters
@@ -232,11 +230,11 @@ Yes, you can. Please define the symbol [`JSON_DIAGNOSTICS`](../api/macros/json_d
    - It seems that precision is lost when serializing a double.
    - Can I change the precision for floating-point serialization?
-The library serializes floating-point numbers with the shortest representation that parses back to the same value, using at most `std::numeric_limits<number_float_t>::max_digits10` (17 for IEEE `double`s) significant digits. This guarantees that value -> string -> value round-trips. The reverse direction, string -> value -> string, is only guaranteed for numbers with at most `std::numeric_limits<number_float_t>::digits10` (15 for IEEE `double`s) significant digits; a number with more digits may not be representable exactly and is then serialized as the closest `double`.
+The library uses `std::numeric_limits<number_float_t>::digits10` (15 for IEEE `double`s) digits for serialization. This value is sufficient to guarantee roundtripping. If one uses more than this number of digits of precision, then string -> value -> string is not guaranteed to round-trip.
-!!! quote "[cppreference.com](https://en.cppreference.com/w/cpp/types/numeric_limits/max_digits10)"
+!!! quote "[cppreference.com](https://en.cppreference.com/w/cpp/types/numeric_limits/digits10)"
-    The value of `std::numeric_limits<T>::max_digits10` is the number of base-10 digits that are necessary to uniquely represent all distinct values of the type T, such as necessary for serialization/deserialization to text.
+    The value of `std::numeric_limits<T>::digits10` is the number of base-10 digits that can be represented by the type T without change, that is, any number with this many significant decimal digits can be converted to a value of type T and back to decimal form, without change due to rounding or overflow. 
 !!! tip
@@ -18,8 +18,6 @@ The class contains the UTF-8 Decoder from Bjoern Hoehrmann which is licensed und
 The class contains a slightly modified version of the Grisu2 algorithm from Florian Loitsch which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2009 [Florian Loitsch](https://florian.loitsch.com/)
 The class contains a port of the shortest double-to-decimal conversion of [Żmij](https://github.com/vitaut/zmij) by Victor Zverovich, including the conversion of the digits to text by Xiang JunBo and the SIMD instruction sequence of Dougall Johnson, which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2025 [Victor Zverovich](https://github.com/vitaut)
 The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).
-The class contains an adapted version of the Eisel-Lemire algorithm, its table of powers of five, and its digit comparison for long numbers from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
+The class contains an adapted version of the Eisel-Lemire algorithm and its table of powers of five from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
@@ -90,13 +90,13 @@ to the following.
 ### FetchContent
-Since CMake v3.14, [FetchContent](https://cmake.org/cmake/help/v3.14/module/FetchContent.html) can be used to
+Since CMake v3.11, [FetchContent](https://cmake.org/cmake/help/v3.11/module/FetchContent.html) can be used to
 automatically download a release as a dependency at configure time.
 !!! example
    ```cmake title="CMakeLists.txt"
-    cmake_minimum_required(VERSION 3.14)
+    cmake_minimum_required(VERSION 3.11)
    project(ExampleProject LANGUAGES CXX)
    include(FetchContent)
@@ -14,8 +14,7 @@ that cost, ordered by how much they typically save.
 Header files that only need to *name* the `json` type — for function declarations, members held by pointer or
 reference, or friend declarations — can include `<nlohmann/json_fwd.hpp>` instead of `<nlohmann/json.hpp>`. It only
-forward-declares `basic_json`, `json_pointer`, `adl_serializer`, and `ordered_map`, and defines the aliases `json` and
+forward-declares `basic_json`, `json`, `ordered_json`, `json_pointer`, and `adl_serializer`. The translation units that
 `ordered_json`. The translation units that
 actually use the values then include `<nlohmann/json.hpp>`.
 ```cpp title="person.hpp"
@@ -453,12 +453,8 @@ plugins:
      # package badges (the fetch fails, then reading the missing cache entry
      # raises FileNotFoundError). Readers' browsers are served normally, so
      # leave these badges as external references instead of self-hosting them.
      # The same goes for img.shields.io, whose version badges time out from
      # time to time (strict mode turns the failed download into an error) and
      # would go stale between builds if they were self-hosted anyway.
      assets_exclude:
        - repology.org/*
        - img.shields.io/*
  - llmstxt:
      markdown_description: >
        JSON for Modern C++ is a C++11 header-only library implementing a JSON
@@ -7,6 +7,6 @@ mkdocs-material-extensions==1.3.1                   # extensions
 mkdocs-minify-plugin==0.8.0                         # plugin "minify"
 mkdocs-redirects==1.2.3                             # plugin "redirects"
 mkdocs-htmlproofer-plugin==1.6.0                    # plugin "htmlproofer"
-mkdocs-llmstxt==0.5.1                               # plugin "llmstxt"
+mkdocs-llmstxt==0.5.0                               # plugin "llmstxt"
 PyYAML==6.0.3                                       # linter
@@ -6,7 +6,7 @@
    "": {
      "name": "check-mermaid",
      "dependencies": {
-        "jsdom": "30.1.2",
+        "jsdom": "30.1.1",
        "mermaid": "11.17.2"
      }
    },
@@ -24,14 +24,14 @@
      }
    },
    "node_modules/@asamuzakjp/css-color": {
-      "version": "7.1.3",
+      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-7.1.3.tgz",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-7.1.2.tgz",
-      "integrity": "sha512-1t1U8Cm3RBl9vh3RAZhjkPaduzLSvQJRToRrxpGR/eDRW99mOREleuu+mWfiFa795bUzjwht7NgphCKTs2ianQ==",
+      "integrity": "sha512-99DHAnXDB5z6EEK+9GMpVI7Mw4oxj97dY5bpOzMnjADQWxI8rN6TvTduuFLUhUMlS7/CfVZ06tcZsus6cltnNw==",
      "license": "MIT",
      "dependencies": {
-        "@csstools/css-calc": "^3.4.2",
+        "@csstools/css-calc": "^3.4.1",
-        "@csstools/css-color-parser": "^4.2.5",
+        "@csstools/css-color-parser": "^4.2.4",
-        "@csstools/css-parser-algorithms": "^4.0.2",
+        "@csstools/css-parser-algorithms": "^4.0.1",
        "@csstools/css-tokenizer": "^4.0.2",
        "lru-cache": "^11.5.3"
      },
@@ -40,9 +40,9 @@
      }
    },
    "node_modules/@asamuzakjp/dom-selector": {
-      "version": "9.2.4",
+      "version": "9.2.2",
-      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-9.2.4.tgz",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-9.2.2.tgz",
-      "integrity": "sha512-YnVzxDxLaqL0t7Q4wfcgHZjg55Wm6y5EaO7Bhu3q9J7wq/8iw3PhsnWiOQhYekx4VexnbkgWpTT6n+QIV7kczw==",
+      "integrity": "sha512-lSWTBMjAcmu2xn5yEDU7jh6QDV+C8GEKtdJ4pIQhXh26RkKQ7S3FuQlt+zZkUbTdJ4d3XyV1kPI/G0zWXxqaqw==",
      "license": "MIT",
      "dependencies": {
        "bidi-js": "^1.1.0",
@@ -98,9 +98,9 @@
      }
    },
    "node_modules/@csstools/css-calc": {
-      "version": "3.4.3",
+      "version": "3.4.1",
-      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.4.3.tgz",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.4.1.tgz",
-      "integrity": "sha512-iex20d8CHVkyvg6B7UKV7uHnI2Bqo9g+EFfT9E0y+GvTvhZ/DwONJ+9aKb1dlqm0ZiGsL5RXjp0fCoJYnkeDjA==",
+      "integrity": "sha512-EtC7SoN1j6J4E4DCwg5QgbO5TGxgxIA1RXqe+W+qUM+BUcezx9wT+/tiQ/WO2yCX4i5X+Cuf9ciJ22aP4UEwWw==",
      "funding": [
        {
          "type": "github",
@@ -116,14 +116,14 @@
        "node": ">=20.19.0"
      },
      "peerDependencies": {
-        "@csstools/css-parser-algorithms": "^4.0.2",
+        "@csstools/css-parser-algorithms": "^4.0.1",
        "@csstools/css-tokenizer": "^4.0.2"
      }
    },
    "node_modules/@csstools/css-color-parser": {
-      "version": "4.2.6",
+      "version": "4.2.4",
-      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.2.6.tgz",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.2.4.tgz",
-      "integrity": "sha512-iiPQ3iRWwnJkeEn6RIu6SJPr7hYrLz6XZ9s/QZl+2/LI5KQVjpl2fdmDSZKuD4xP6GMmMPgHFFXg6k1Wkz0Trg==",
+      "integrity": "sha512-DyefytAZ735mX4Dq/WcDAXFtXhaEFvme0ZS9tVEBAc2whxUthXr0R0L2rmEPm59SrMBkGrFzQviBXMs/UtnABQ==",
      "funding": [
        {
          "type": "github",
@@ -137,20 +137,20 @@
      "license": "MIT",
      "dependencies": {
        "@csstools/color-helpers": "^6.1.2",
-        "@csstools/css-calc": "^3.4.3"
+        "@csstools/css-calc": "^3.4.1"
      },
      "engines": {
        "node": ">=20.19.0"
      },
      "peerDependencies": {
-        "@csstools/css-parser-algorithms": "^4.0.2",
+        "@csstools/css-parser-algorithms": "^4.0.1",
        "@csstools/css-tokenizer": "^4.0.2"
      }
    },
    "node_modules/@csstools/css-parser-algorithms": {
-      "version": "4.0.2",
+      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.2.tgz",
+      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.1.tgz",
-      "integrity": "sha512-40cSKyMvK+tq4qz6Awrlye2WGuOKt3FwPgtGg6KTfbHOWNw+Rk1rzbAtZnZ6IBhsY491HLRnDXwoyBAijmmILA==",
+      "integrity": "sha512-ShL8BqPfbKJrJiKFH0xBbN0i7Nrh9HXYRuF+pzyj93R/BL2YAsUxJeqANErzqM+0JGl7vjHp+3OIgd/DL69YIA==",
      "funding": [
        {
          "type": "github",
@@ -170,9 +170,9 @@
      }
    },
    "node_modules/@csstools/css-syntax-patches-for-csstree": {
-      "version": "1.1.15",
+      "version": "1.1.14",
-      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.15.tgz",
+      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.14.tgz",
-      "integrity": "sha512-J0u7HkVl2nzSlhsiTOp4AmwcUQ3D+mGEEKfBy/7To5/y7F2OHwyLrXfrhR0SMgr4p5Lo+eaMVSeai24zUcBIxA==",
+      "integrity": "sha512-HpbVXyrofRXpHpgkNIjU/3EWR4WJvOkO3emNK/L6X/mTJU7bGUI3AkkpoTNXznQLp0KRjLHELTGeKI5dIkI9JQ==",
      "funding": [
        {
          "type": "github",
@@ -1071,16 +1071,30 @@
      }
    },
    "node_modules/data-urls": {
-      "version": "8.0.0",
+      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-8.0.0.tgz",
+      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-7.0.0.tgz",
-      "integrity": "sha512-JQUCCK+/CAGbGGx618PlFZMXH81Jtj7t73CHv9dd/zVWvxgGT2zLFRjnKb+Ng46GIwcy+f7f88qd4duqllK+WQ==",
+      "integrity": "sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==",
      "license": "MIT",
      "dependencies": {
        "whatwg-mimetype": "^5.0.0",
-        "whatwg-url": "^17.1.2"
+        "whatwg-url": "^16.0.0"
      },
      "engines": {
-        "node": "^22.14.0 || >=24.0.0"
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
      }
    },
    "node_modules/data-urls/node_modules/whatwg-url": {
      "version": "16.0.1",
      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-16.0.1.tgz",
      "integrity": "sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==",
      "license": "MIT",
      "dependencies": {
        "@exodus/bytes": "^1.11.0",
        "tr46": "^6.0.0",
        "webidl-conversions": "^8.0.1"
      },
      "engines": {
        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
      }
    },
    "node_modules/dayjs": {
@@ -1202,30 +1216,30 @@
      "license": "MIT"
    },
    "node_modules/jsdom": {
-      "version": "30.1.2",
+      "version": "30.1.1",
-      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-30.1.2.tgz",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-30.1.1.tgz",
-      "integrity": "sha512-0FFE/jE1rppmVfUrJUgxqXjcwolZYIGtAgj1pTussMhNZxIxi7W/PvfWaMNroGi2B36X1IKHbexpZ9DhkoOPiQ==",
+      "integrity": "sha512-FahmoPK5vbPc+jxV1iErMHmAZypCZ942NHF4+qqaWAuvaKKTBZxawnmAtrbGWLU7MtlxfqIP0qw6aSI+aWGtLg==",
      "license": "MIT",
      "dependencies": {
-        "@asamuzakjp/css-color": "^7.1.3",
+        "@asamuzakjp/css-color": "^7.0.0",
-        "@asamuzakjp/dom-selector": "^9.2.4",
+        "@asamuzakjp/dom-selector": "^9.2.1",
        "@bramus/specificity": "^2.4.2",
-        "@csstools/css-syntax-patches-for-csstree": "^1.1.15",
+        "@csstools/css-syntax-patches-for-csstree": "^1.1.13",
-        "@exodus/bytes": "^1.16.0",
+        "@exodus/bytes": "^1.15.1",
        "css-tree": "^3.2.1",
-        "data-urls": "^8.0.0",
+        "data-urls": "^7.0.0",
        "decimal.js": "^10.6.0",
        "html-encoding-sniffer": "^7.0.0",
        "is-potential-custom-element-name": "^1.0.1",
-        "lru-cache": "^11.5.3",
+        "lru-cache": "^11.5.2",
        "parse5": "^8.0.1",
        "saxes": "^6.0.0",
        "tough-cookie": "^6.0.2",
-        "undici": "^8.11.2",
+        "undici": "^8.10.2",
        "w3c-xmlserializer": "^6.0.0",
        "webidl-conversions": "^8.0.1",
        "whatwg-mimetype": "^5.0.0",
-        "whatwg-url": "^17.2.0",
+        "whatwg-url": "^17.1.1",
        "xml-name-validator": "^5.0.0"
      },
      "engines": {
@@ -1500,15 +1514,15 @@
      }
    },
    "node_modules/tr46": {
-      "version": "7.0.0",
+      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-7.0.0.tgz",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",
-      "integrity": "sha512-BcDSDW+SIGWVOns1Zm6Yg91q9AEj7eaID0QDY9oIqJD1A8dscNwMcl9Sms2DeuWCNov1X0/oXanHGYQBSLwZsg==",
+      "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==",
      "license": "MIT",
      "dependencies": {
        "punycode": "^2.3.1"
      },
      "engines": {
-        "node": "^22.14.0 || >=24.0.0"
+        "node": ">=20"
      }
    },
    "node_modules/ts-dedent": {
@@ -1573,13 +1587,13 @@
      }
    },
    "node_modules/whatwg-url": {
-      "version": "17.2.0",
+      "version": "17.1.2",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-17.2.0.tgz",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-17.1.2.tgz",
-      "integrity": "sha512-IhLIHNcBrzIixC5XXsbr4DxdjajyA5vQ5RwGZMtrUp+GbtE5Nrsge9QKau7jXrC0aTXLYGV0xiW7Tb4YS2aomw==",
+      "integrity": "sha512-TEZA+Zqxin7Jjsm2cjRohCmen5awh+hT6Zi3VZdqZlNRk7zvOI/9WpBFg/DWlA56bWnzwm6DuB8NS0EsxQH9uQ==",
      "license": "MIT",
      "dependencies": {
-        "@exodus/bytes": "^1.16.0",
+        "@exodus/bytes": "^1.15.1",
-        "tr46": "^7.0.0",
+        "tr46": "^6.0.0",
        "webidl-conversions": "^8.0.1"
      },
      "engines": {
@@ -4,7 +4,7 @@
  "description": "Validate the Mermaid diagrams of the documentation (see check_mermaid.mjs)",
  "type": "module",
  "dependencies": {
-    "jsdom": "30.1.2",
+    "jsdom": "30.1.1",
    "mermaid": "11.17.2"
  }
 }
@@ -9,12 +9,11 @@
 #pragma once
 #include <cstdint> // uint64_t
-#include <cstring> // memcpy
+#if !defined(__SIZEOF_INT128__) && defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
-#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64)) && (!defined(__SIZEOF_INT128__) || (!defined(__GNUC__) && !defined(__clang__)))
+    #include <intrin0.h> // __umulh, _umul128
    #include <intrin0.h> // __umulh, _umul128, _BitScanForward64, _BitScanReverse64
 #endif
-#include <nlohmann/detail/macro_scope.hpp> // JSON_HEDLEY_ALWAYS_INLINE, NLOHMANN_JSON_NAMESPACE_BEGIN
+#include <nlohmann/detail/abi_macros.hpp>
 // Portable bit-level helpers for the number and string scanners. They use
 // compiler builtins or platform-specific intrinsics where available and plain
@@ -29,10 +28,6 @@ inline int count_leading_zeros(std::uint64_t x) noexcept
 {
 #if defined(__GNUC__) || defined(__clang__)
    return __builtin_clzll(x);
 #elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
    unsigned long index = 0; // NOLINT(runtime/int): the type _BitScan*64 takes
    _BitScanReverse64(&index, x);
    return 63 - static_cast<int>(index);
 #else
    int n = 0;
    for (int shift = 32; shift != 0; shift >>= 1)
@@ -52,10 +47,6 @@ inline int count_trailing_zeros(std::uint64_t x) noexcept
 {
 #if defined(__GNUC__) || defined(__clang__)
    return __builtin_ctzll(x);
 #elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
    unsigned long index = 0; // NOLINT(runtime/int): the type _BitScan*64 takes
    _BitScanForward64(&index, x);
    return static_cast<int>(index);
 #else
    int n = 0;
    for (int shift = 32; shift != 0; shift >>= 1)
@@ -103,27 +94,15 @@ inline uint128_parts full_multiplication(std::uint64_t a, std::uint64_t b) noexc
 #endif
 }
-/// eight bytes as a little-endian word (a single load on little-endian
+/// eight bytes as a little-endian word (compilers fold this into one load on
-/// targets; always inlined, as GCC otherwise calls it in the number loops)
+/// little-endian targets)
-JSON_HEDLEY_ALWAYS_INLINE std::uint64_t read_eight_bytes(const unsigned char* b) noexcept
+inline std::uint64_t read_eight_bytes(const char* p) noexcept
 {
-#if defined(_MSC_VER) || defined(__x86_64__) || defined(__i386__) || (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+    const auto* b = reinterpret_cast<const unsigned char*>(p); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
    // the byte order already matches (all MSVC targets are little-endian)
    std::uint64_t result = 0;
    std::memcpy(&result, b, sizeof(result));
    return result;
 #else
    return static_cast<std::uint64_t>(b[0]) | (static_cast<std::uint64_t>(b[1]) << 8u)
           | (static_cast<std::uint64_t>(b[2]) << 16u) | (static_cast<std::uint64_t>(b[3]) << 24u)
           | (static_cast<std::uint64_t>(b[4]) << 32u) | (static_cast<std::uint64_t>(b[5]) << 40u)
           | (static_cast<std::uint64_t>(b[6]) << 48u) | (static_cast<std::uint64_t>(b[7]) << 56u);
 #endif
 }
 /// eight bytes as a little-endian word
 JSON_HEDLEY_ALWAYS_INLINE std::uint64_t read_eight_bytes(const char* p) noexcept
 {
    return read_eight_bytes(reinterpret_cast<const unsigned char*>(p)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 }
 }  // namespace detail
@@ -4,7 +4,6 @@
 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 //
 // SPDX-FileCopyrightText: 2009 Florian Loitsch <https://florian.loitsch.com/>
 // SPDX-FileCopyrightText: 2025 Victor Zverovich <https://github.com/vitaut/zmij>
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT
@@ -12,32 +11,11 @@
 #include <array> // array
 #include <cmath>   // signbit, isfinite
 #include <cstddef> // size_t
 #include <cstdint> // intN_t, uintN_t
 #include <cstring> // memcpy, memmove
 #include <limits> // numeric_limits
 #include <type_traits> // conditional
 #ifdef _MSC_VER
    #include <cstdlib> // _byteswap_uint64
 #endif
 // SSE2 (every x86-64 CPU) and NEON (every 64-bit Arm CPU) convert the 16
 // digits of a double at once
 #if defined(__x86_64__) || (defined(_M_X64) && !defined(_M_ARM64EC))
    #include <emmintrin.h>
    #define JSON_DTOA_SSE2 1
    #define JSON_DTOA_NEON 0
 #elif (defined(__aarch64__) || defined(_M_ARM64)) && !defined(_M_ARM64EC) && !defined(__ARM_BIG_ENDIAN)
    #include <arm_neon.h>
    #define JSON_DTOA_SSE2 0
    #define JSON_DTOA_NEON 1
 #else
    #define JSON_DTOA_SSE2 0
    #define JSON_DTOA_NEON 0
 #endif
 #include <nlohmann/detail/conversions/zmij.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -1069,381 +1047,6 @@ inline char* format_buffer(char* buf, int len, int decimal_exponent,
    return append_exponent(buf, n - 1);
 }
 /// eight decimal digits (a value below 10^8) as bytes 0..9, the first digit
 /// in the most significant byte: three steps that divide all lanes at once
 /// by a multiplication (the conversion of Xiang JunBo, as in Zmij)
 inline std::uint64_t eight_digit_bytes(std::uint64_t abcdefgh) noexcept
 {
    const std::uint64_t abcd_efgh = abcdefgh + (((std::uint64_t{1} << 32u) - 10000u) * ((abcdefgh * (((std::uint64_t{1} << 40u) / 10000u) + 1u)) >> 40u));
    const std::uint64_t ab_cd_ef_gh = abcd_efgh + (((std::uint64_t{1} << 16u) - 100u) * (((abcd_efgh * (((std::uint64_t{1} << 19u) / 100u) + 1u)) >> 19u) & 0x7F0000007Fu));
    return ab_cd_ef_gh + (((std::uint64_t{1} << 8u) - 10u) * (((ab_cd_ef_gh * (((std::uint64_t{1} << 10u) / 10u) + 1u)) >> 10u) & 0x000F000F000F000Fu));
 }
 /// store the bytes of v, the most significant one first (one byte swap and
 /// one store where the byte order is known: compilers do not reliably merge
 /// the byte stores once this is inlined)
 inline void store_msb_first(char* p, std::uint64_t v) noexcept
 {
 #if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    v = __builtin_bswap64(v);
    std::memcpy(p, &v, sizeof(v));
 #elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
    std::memcpy(p, &v, sizeof(v));
 #elif defined(_MSC_VER) // (little-endian on all its targets)
    v = _byteswap_uint64(v);
    std::memcpy(p, &v, sizeof(v));
 #else
    for (unsigned i = 0; i < 8; ++i)
    {
        p[i] = static_cast<char>(v >> (56u - (8u * i)));
    }
 #endif
 }
 /*!
@brief digits * 10^exp for a double, in the layout of format_buffer()
 The layout is that of format_buffer() with min_exp -4 and max_exp 15 (the
 digits10 of double). The digits are converted eight at a time and placed
 with fixed-size moves instead of per-digit loops and moves of the buffer.
@param[in] digits  the digits (not 0, at most 17 digits; trailing zeros allowed)
@param[in] exp     the decimal exponent of the last digit
@return a pointer past the text; up to 41 bytes at @a first are written
        (some beyond the returned end)
 */
 JSON_HEDLEY_NON_NULL(1)
 JSON_HEDLEY_RETURNS_NON_NULL
 inline char* write_decimal(char* first, std::uint64_t digits, int exp) noexcept
 {
    JSON_ASSERT(digits != 0 && digits < 100000000000000000u);
    const std::uint64_t upper = digits / 100000000u;
    const std::uint64_t b0 = upper / 100000000u; // (one digit: it is its own byte)
    const std::uint64_t b1 = eight_digit_bytes(upper % 100000000u);
    const std::uint64_t b2 = eight_digit_bytes(digits % 100000000u);
    // leading and trailing zero digits: zero bytes, counted without division
    int leading = 16;
    int zeros = 16;
    if (b0 != 0)
    {
        leading = count_leading_zeros(b0) / 8;
    }
    else if (b1 != 0)
    {
        leading = 8 + (count_leading_zeros(b1) / 8);
    }
    else
    {
        leading += count_leading_zeros(b2) / 8;
    }
    if (b2 != 0)
    {
        zeros = count_trailing_zeros(b2) / 8;
    }
    else if (b1 != 0)
    {
        zeros = 8 + (count_trailing_zeros(b1) / 8);
    }
    // (else: 16, b0 is the one digit that is not 0)
    // the digits as text at text + leading, then '0's, so that fixed-size
    // moves need not check how many digits there are
    std::array<char, 64> text; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
    store_msb_first(text.data(), b0 + 0x3030303030303030u);
    store_msb_first(text.data() + 8, b1 + 0x3030303030303030u);
    store_msb_first(text.data() + 16, b2 + 0x3030303030303030u);
    std::memset(text.data() + 24, '0', 40);
    const int k = 24 - leading - zeros; // significant digits
    const int n = k + exp + zeros;      // position of the decimal point after the first digit
    const char* const s0 = text.data() + leading;
    if (-4 < n && n <= 15)
    {
        // "0.[000]digits" (n <= 0) is the digits after 1 - n leading '0's
        // with the point after the first; "digits[000].0" (n >= k) and
        // "dig.its" put the point after n characters
        const int pad = n <= 0 ? 1 - n : 0;
        const char* const s = s0 - pad;
        const int len = k + pad;
        const int point = n + pad;
        std::memcpy(first, s, 16);
        std::memcpy(first + point + 1, s + point, 24);
        first[point] = '.';
        return first + (point >= len ? point + 2 : len + 1);
    }
    // d.igitse+XX, with at least two exponent digits (as append_exponent())
    std::memcpy(first, s0, 16);
    std::memcpy(first + 2, s0 + 1, 16);
    first[1] = '.';
    char* const end = first + (k == 1 ? 1 : k + 1);
    const int e = n - 1;
    const auto ea = e < 0 ? 0u - static_cast<unsigned>(e) : static_cast<unsigned>(e); // (unsigned: no signed overflow to assume)
    const bool three = ea >= 100;
    end[0] = 'e';
    end[1] = e < 0 ? '-' : '+';
    end[2] = static_cast<char>('0' + (three ? ea / 100 : (ea / 10) % 10));
    end[3] = static_cast<char>('0' + (three ? (ea / 10) % 10 : ea % 10));
    end[4] = static_cast<char>('0' + (ea % 10));
    return end + (three ? 5 : 4);
 }
 /*!
@brief the shortest decimal of a positive double (Zmij), as write_decimal()
 writes it
 For a normal double, the shorter candidate has 15 or 16 digits: they are
 converted at once (two halves of eight digits) and followed by the digit
 after them, if there is one, without the multiplication and division by 10
 that counting the digits of one number would take. The fixed layouts move
 the digits after the point by one byte.
@return a pointer past the text; up to 41 bytes at @a first are written
        (some beyond the returned end)
 */
 JSON_HEDLEY_NON_NULL(1)
 JSON_HEDLEY_RETURNS_NON_NULL
 inline char* write_shortest(char* first, const zmij::shortest_decimal d) noexcept
 {
    const std::uint64_t sig = d.integral;
    if (JSON_HEDLEY_UNLIKELY(sig < 100000000000000u || sig >= 10000000000000000u))
    {
        // (subnormals)
        return d.has_digit ? write_decimal(first, (sig * 10) + d.digit, d.exponent) : write_decimal(first, sig, d.exponent + 1);
    }
    const bool sixteen = sig >= 1000000000000000u; // (else 15 digits)
    const int last = d.has_digit ? d.digit : 0;
    const std::uint64_t upper = sig / 100000000u;
 #if JSON_DTOA_SSE2
    // NOLINTBEGIN(portability-simd-intrinsics)
    // the two halves in the 64-bit lanes, each as abcd * 2^32 + efgh, then as
    // bytes (as eight_digit_bytes(), one lane each)
    const __m128i x = _mm_set_epi64x(static_cast<long long>(sig - (upper * 100000000u)), static_cast<long long>(upper)); // NOLINT(runtime/int)
    const __m128i abcd = _mm_srli_epi64(_mm_mul_epu32(x, _mm_set1_epi64x(109951163)), 40); // 2^40 / 10000 + 1
    const __m128i abcd_efgh = _mm_add_epi64(x, _mm_mul_epu32(abcd, _mm_set1_epi64x(4294957296))); // 2^32 - 10000
    // 32-bit lanes in the order of the text: abcd, efgh of both halves
    const __m128i fours = _mm_shuffle_epi32(abcd_efgh, _MM_SHUFFLE(2, 3, 0, 1));
    const __m128i ab = _mm_srli_epi16(_mm_mulhi_epu16(fours, _mm_set1_epi32(5243)), 3);
    const __m128i ab_cd = _mm_or_si128(_mm_slli_epi32(_mm_sub_epi16(fours, _mm_mullo_epi16(ab, _mm_set1_epi32(100))), 16), ab);
    // 16-bit lanes ab (< 100) -> bytes a, b: 256 * ab - 2559 * (ab / 10)
    const __m128i bytes = _mm_sub_epi16(_mm_slli_epi16(ab_cd, 8), _mm_mullo_epi16(_mm_set1_epi16(2559), _mm_mulhi_epu16(ab_cd, _mm_set1_epi16(6554))));
    // the last digit that is not 0 (sig is not 0)
    const auto nonzero = static_cast<std::uint64_t>(_mm_movemask_epi8(_mm_cmpgt_epi8(bytes, _mm_setzero_si128())));
    const int digits = 63 - count_leading_zeros(nonzero) + (sixteen ? 1 : 0); // without trailing zeros
    const __m128i chars = _mm_add_epi8(bytes, _mm_set1_epi8('0'));
    // the 16 characters from the first digit
    const __m128i s = sixteen ? chars : _mm_or_si128(_mm_srli_si128(chars, 1), _mm_slli_si128(_mm_cvtsi32_si128('0' + last), 15));
    const char s16 = static_cast<char>(sixteen ? '0' + last : '0'); // the 17th
    const auto store_16 = [&s](char* p) noexcept
    {
        std::memcpy(p, &s, 16);
    };
    const char first_digit = static_cast<char>(_mm_cvtsi128_si32(s));
    // NOLINTEND(portability-simd-intrinsics)
 #elif JSON_DTOA_NEON
    // as with SSE2: the halves in 32-bit lanes, then abcd, efgh of both
    const uint32x2_t halves = vcreate_u32(upper | ((sig - (upper * 100000000u)) << 32u));
    const uint32x2_t abcd = vmovn_u64(vshrq_n_u64(vmull_n_u32(halves, static_cast<std::uint32_t>(((std::uint64_t{1} << 40u) / 10000u) + 1u)), 40));
    const uint32x2_t efgh = vmls_n_u32(halves, abcd, 10000u);
    const uint32x4_t fours = vcombine_u32(vzip1_u32(abcd, efgh), vzip2_u32(abcd, efgh));
    const uint32x4_t ab = vshrq_n_u32(vmulq_n_u32(fours, 5243u), 19);
    const uint16x8_t ab_cd = vreinterpretq_u16_u32(vorrq_u32(ab, vshlq_n_u32(vmlsq_n_u32(fours, ab, 100u), 16)));
    const uint16x8_t tens = vshrq_n_u16(vmulq_n_u16(ab_cd, 103u), 10);
    const uint8x16_t bytes = vreinterpretq_u8_u16(vorrq_u16(tens, vshlq_n_u16(vmlsq_n_u16(ab_cd, tens, 10u), 8)));
    // the last digit that is not 0 (sig is not 0): a nibble per byte
    const std::uint64_t nonzero = vget_lane_u64(vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(vtstq_u8(bytes, bytes)), 4)), 0);
    const int digits = ((63 - count_leading_zeros(nonzero)) / 4) + (sixteen ? 1 : 0); // without trailing zeros
    const uint8x16_t chars = vaddq_u8(bytes, vdupq_n_u8('0'));
    // the 16 characters from the first digit
    const uint8x16_t s = sixteen ? chars : vextq_u8(chars, vdupq_n_u8(static_cast<std::uint8_t>('0' + last)), 1);
    const char s16 = static_cast<char>(sixteen ? '0' + last : '0'); // the 17th
    const auto store_16 = [&s](char* p) noexcept
    {
        vst1q_u8(reinterpret_cast<std::uint8_t*>(p), s); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
    };
    const auto first_digit = static_cast<char>(vgetq_lane_u8(s, 0));
 #else
    const std::uint64_t hi = eight_digit_bytes(upper);
    const std::uint64_t lo = eight_digit_bytes(sig - (upper * 100000000u));
    // trailing zero digits: zero bytes (sig is not 0)
    const int zeros = lo != 0 ? count_trailing_zeros(lo) / 8 : 8 + (count_trailing_zeros(hi) / 8);
    const int digits = 15 - zeros + (sixteen ? 1 : 0); // without trailing zeros
    // the 16 characters from the first digit
    const std::uint64_t s_hi = (sixteen ? hi : (hi << 8u) | (lo >> 56u)) + 0x3030303030303030u;
    const std::uint64_t s_lo = (sixteen ? lo : (lo << 8u) | static_cast<std::uint64_t>(last)) + 0x3030303030303030u;
    const char s16 = static_cast<char>(sixteen ? '0' + last : '0'); // the 17th
    const auto store_16 = [s_hi, s_lo](char* p) noexcept
    {
        store_msb_first(p, s_hi);
        store_msb_first(p + 8, s_lo);
    };
    const auto first_digit = static_cast<char>(s_hi >> 56u);
 #endif
    const int len = d.has_digit ? 16 + (sixteen ? 1 : 0) : digits; // significant digits
    const int n = 16 + (sixteen ? 1 : 0) + d.exponent;           // digits before the point
    if (JSON_HEDLEY_LIKELY(n >= 1 && n <= 15))
    {
        // "dig.its" and "digits[000].0": the digits after the point move by
        // one byte ('0's follow the digits)
 #if JSON_DTOA_SSE2
        // NOLINTBEGIN(portability-simd-intrinsics)
        // (in the register: reading the digits back from memory right after
        // storing them waits until the stores are done)
        const __m128i at = _mm_set1_epi8(static_cast<char>(n));
        const __m128i index = _mm_setr_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
        const __m128i before = _mm_cmpgt_epi8(at, index);
        const __m128i after = _mm_cmpgt_epi8(index, at);
        const __m128i text = _mm_or_si128(_mm_or_si128(_mm_and_si128(s, before), _mm_and_si128(_mm_slli_si128(s, 1), after)),
                                          _mm_andnot_si128(_mm_or_si128(before, after), _mm_set1_epi8('.')));
        std::memcpy(first, &text, 16);
        first[16] = static_cast<char>(_mm_extract_epi16(s, 7) >> 8);
        first[17] = s16;
        // NOLINTEND(portability-simd-intrinsics)
 #elif JSON_DTOA_NEON
        const uint8x16_t index = vcombine_u8(vcreate_u8(0x0706050403020100u), vcreate_u8(0x0F0E0D0C0B0A0908u));
        const uint8x16_t at = vdupq_n_u8(static_cast<std::uint8_t>(n));
        const uint8x16_t after_point = vbslq_u8(vcgtq_u8(index, at), vextq_u8(vdupq_n_u8(0), s, 15), vdupq_n_u8('.'));
        vst1q_u8(reinterpret_cast<std::uint8_t*>(first), vbslq_u8(vcltq_u8(index, at), s, after_point)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
        first[16] = static_cast<char>(vgetq_lane_u8(s, 15));
        first[17] = s16;
 #else
        store_16(first);
        first[16] = s16;
        std::uint64_t after_point[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
        std::memcpy(after_point, first + n, 16);
        std::memcpy(first + n + 1, after_point, 16);
        first[n] = '.';
 #endif
        return first + (n >= len ? n + 2 : len + 1);
    }
    if (n <= 0 && n > -4)
    {
        // "0.[000]digits"
        std::memset(first, '0', 8);
        first[1] = '.';
        store_16(first + 2 - n);
        first[18 - n] = s16;
        return first + 2 - n + len;
    }
    // d.igitse+XX, with at least two exponent digits (as append_exponent())
    store_16(first + 1);
    first[17] = s16;
    first[0] = first_digit;
    first[1] = '.';
    char* const end = first + (len == 1 ? 1 : len + 1);
    const int e = n - 1;
    const auto ea = e < 0 ? 0u - static_cast<unsigned>(e) : static_cast<unsigned>(e); // (unsigned: no signed overflow to assume)
    const bool three = ea >= 100;
    end[0] = 'e';
    end[1] = e < 0 ? '-' : '+';
    end[2] = static_cast<char>('0' + (three ? ea / 100 : (ea / 10) % 10));
    end[3] = static_cast<char>('0' + (three ? (ea / 10) % 10 : ea % 10));
    end[4] = static_cast<char>('0' + (ea % 10));
    return end + (three ? 5 : 4);
 }
 /*!
@brief whether FloatType is an IEEE 754 binary64 type (a double, or a long double
 that has the same format, as with MSVC and on Apple's Arm CPUs)
 These are the types the conversion of Zmij (see zmij.hpp) is used for; all
 others (binary32, or a format the library does not know) use Grisu2.
 */
 template<typename FloatType>
 constexpr bool has_binary64_format() noexcept
 {
    return std::numeric_limits<FloatType>::is_iec559
           && std::numeric_limits<FloatType>::digits == 53
           && std::numeric_limits<FloatType>::max_exponent == 1024
           && sizeof(FloatType) == sizeof(std::uint64_t);
 }
 template<typename FloatType>
 struct is_binary64 : std::integral_constant<bool, has_binary64_format<FloatType>()> {};
 /// a positive finite float (other than binary64): Grisu2 and format_buffer()
 template<typename FloatType>
 JSON_HEDLEY_NON_NULL(1, 2)
 JSON_HEDLEY_RETURNS_NON_NULL
 char* write_positive_grisu2(char* first, const char* last, FloatType value)
 {
    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
    static_cast<void>(last); // (only used in the assertion)
    // Compute v = buffer * 10^decimal_exponent.
    // The decimal digits are stored in the buffer, which needs to be interpreted
    // as an unsigned decimal integer.
    // len is the length of the buffer, i.e., the number of decimal digits.
    int len = 0;
    int decimal_exponent = 0;
    grisu2(first, len, decimal_exponent, value);
    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
    // Format the buffer like printf("%.*g", prec, value)
    constexpr int kMinExp = -4;
    // Use digits10 here to increase compatibility with version 2.
    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
    JSON_ASSERT(last - first >= kMaxExp + 2);
    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
    return format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
 }
 /// a positive finite binary64 number: the shortest digits (Zmij), laid out by
 /// write_shortest() (through a local buffer if [first, last) is shorter than
 /// the 41 bytes it may write)
 template<typename FloatType>
 JSON_HEDLEY_NON_NULL(1, 2)
 JSON_HEDLEY_RETURNS_NON_NULL
 char* write_positive_zmij(char* first, const char* last, FloatType value)
 {
    static_assert(is_binary64<FloatType>::value,
                  "internal error: the conversion of Zmij needs IEEE 754 binary64 numbers");
    std::uint64_t bits = 0;
    std::memcpy(&bits, &value, sizeof(bits));
    const zmij::shortest_decimal d = zmij::to_shortest(bits);
    if (JSON_HEDLEY_LIKELY(last - first >= 41))
    {
        return write_shortest(first, d);
    }
    std::array<char, 64> buf; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
    const auto len = static_cast<std::size_t>(write_shortest(buf.data(), d) - buf.data());
    JSON_ASSERT(last - first >= static_cast<std::ptrdiff_t>(len));
    std::memcpy(first, buf.data(), len);
    return first + len;
 }
 /// a positive finite binary64 number: Zmij (as a long double has the format of
 /// a double here, its bits are those of the double of the same value)
 template<typename FloatType>
 JSON_HEDLEY_NON_NULL(1, 2)
 JSON_HEDLEY_RETURNS_NON_NULL
 char* write_positive(char* first, const char* last, FloatType value, std::true_type /*is_binary64*/)
 {
    return write_positive_zmij(first, last, value);
 }
 /// a positive finite float of any other format: Grisu2
 template<typename FloatType>
 JSON_HEDLEY_NON_NULL(1, 2)
 JSON_HEDLEY_RETURNS_NON_NULL
 char* write_positive(char* first, const char* last, FloatType value, std::false_type /*is_binary64*/)
 {
    return write_positive_grisu2(first, last, value);
 }
 /// a positive finite float: Zmij for binary64 numbers, Grisu2 otherwise
 template<typename FloatType>
 JSON_HEDLEY_NON_NULL(1, 2)
 JSON_HEDLEY_RETURNS_NON_NULL
 char* write_positive(char* first, const char* last, FloatType value)
 {
    return write_positive(first, last, value, is_binary64<FloatType> {});
 }
 }  // namespace dtoa_impl
 /*!
@@ -1461,6 +1064,7 @@ JSON_HEDLEY_NON_NULL(1, 2)
 JSON_HEDLEY_RETURNS_NON_NULL
 char* to_chars(char* first, const char* last, FloatType value)
 {
    static_cast<void>(last); // maybe unused - fix warning
    JSON_ASSERT(std::isfinite(value));
    // Use signbit(value) instead of (value < 0) since signbit works for -0.
@@ -1486,7 +1090,28 @@ char* to_chars(char* first, const char* last, FloatType value)
    JSON_HEDLEY_DIAGNOSTIC_POP
 #endif
-    return dtoa_impl::write_positive(first, last, value);
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
    // Compute v = buffer * 10^decimal_exponent.
    // The decimal digits are stored in the buffer, which needs to be interpreted
    // as an unsigned decimal integer.
    // len is the length of the buffer, i.e., the number of decimal digits.
    int len = 0;
    int decimal_exponent = 0;
    dtoa_impl::grisu2(first, len, decimal_exponent, value);
    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
    // Format the buffer like printf("%.*g", prec, value)
    constexpr int kMinExp = -4;
    // Use digits10 here to increase compatibility with version 2.
    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
    JSON_ASSERT(last - first >= kMaxExp + 2);
    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
 }
 }  // namespace detail
@@ -1,219 +0,0 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++
 // |  |  |__   |  |  | | | |  version 3.12.0
 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 //
 // SPDX-FileCopyrightText: 2025 Victor Zverovich <https://github.com/vitaut/zmij>
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT
 #pragma once
 #include <array> // array
 #include <cstddef> // size_t
 #include <cstdint> // uint32_t, uint64_t
 #include <nlohmann/detail/abi_macros.hpp>
 #include <nlohmann/detail/bit_ops.hpp>
 #include <nlohmann/detail/input/pow5_table.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
 {
 /*!
@brief the shortest decimal representation of a double
 A C++11 port of the conversion of Zmij by Victor Zverovich
 (https://github.com/vitaut/zmij, MIT license): the shortest decimal in the
 rounding interval of a double, the closest one if there are several. Zmij
 credits Xiang JunBo (producing the shorter candidate without a division) and
 Dougall Johnson (the compressed powers of ten). The powers of ten are taken
 from the table for number parsing (pow5_table.hpp) where it holds them, and
 computed from the compressed tables of Zmij beyond it.
 */
 namespace zmij
 {
 /// the compressed powers of ten of Zmij
 inline const std::array<std::uint64_t, 28>& pow10_minor() noexcept
 {
    static const std::array<std::uint64_t, 28> table =
    {
        {
            0x8000000000000000u, 0xa000000000000000u, 0xc800000000000000u, 0xfa00000000000000u, 0x9c40000000000000u,
            0xc350000000000000u, 0xf424000000000000u, 0x9896800000000000u, 0xbebc200000000000u, 0xee6b280000000000u,
            0x9502f90000000000u, 0xba43b74000000000u, 0xe8d4a51000000000u, 0x9184e72a00000000u, 0xb5e620f480000000u,
            0xe35fa931a0000000u, 0x8e1bc9bf04000000u, 0xb1a2bc2ec5000000u, 0xde0b6b3a76400000u, 0x8ac7230489e80000u,
            0xad78ebc5ac620000u, 0xd8d726b7177a8000u, 0x878678326eac9000u, 0xa968163f0a57b400u, 0xd3c21bcecceda100u,
            0x84595161401484a0u, 0xa56fa5b99019a5c8u, 0xcecb8f27f4200f3au
        }
    };
    return table;
 }
 /// (high, low) pairs
 inline const std::array<std::uint64_t, 50>& pow10_major() noexcept
 {
    static const std::array<std::uint64_t, 50> table =
    {
        {
            0xaddcb9e83c6b1793u, 0xdf4abe242a1bbf3eu, 0xaf8e5410288e1b6fu, 0x07ecf0ae5ee44ddau, 0xb1442798f49ffb4au, 0x99cd11cfdf41779du,
            0xb2fe3f0b8599ef07u, 0x861fa7e6dcb4aa15u, 0xb4bca50b065abe63u, 0x0fed077a756b53aau, 0xb67f6455292cbf08u, 0x1a3bc84c17b1d543u,
            0xb84687c269ef3bfbu, 0x3d5d514f40eea742u, 0xba121a4650e4ddebu, 0x92f34d62616ce413u, 0xbbe226efb628afeau, 0x890489f70a55368cu,
            0xbdb6b8e905cb600fu, 0x5400e987bbc1c921u, 0xbf8fdb78849a5f96u, 0xde98520472bdd034u, 0xc16d9a0095928a27u, 0x75b7053c0f178294u,
            0xc350000000000000u, 0x0000000000000000u, 0xc5371912364ce305u, 0x6c28000000000000u, 0xc722f0ef9d80aad6u, 0x424d3ad2b7b97ef6u,
            0xc913936dd571c84cu, 0x03bc3a19cd1e38eau, 0xcb090c8001ab551cu, 0x5cadf5bfd3072cc6u, 0xcd036837130890a1u, 0x36dba887c37a8c10u,
            0xcf02b2c21207ef2eu, 0x94f967e45e03f4bcu, 0xd106f86e69d785c7u, 0xe13336d701beba52u, 0xd31045a8341ca07cu, 0x1ede48111209a051u,
            0xd51ea6fa85785631u, 0x552a74227f3ea566u, 0xd732290fbacaf133u, 0xa97c177947ad4096u, 0xd94ad8b1c7380874u, 0x18375281ae7822bdu,
            0xdb68c2ca82ed2a05u, 0xa67398db9f6820e1u
        }
    };
    return table;
 }
 /// one bit per power: whether the computed value is one unit too large
 inline const std::array<std::uint32_t, 21>& pow10_fixups() noexcept
 {
    static const std::array<std::uint32_t, 21> table =
    {
        {
            0x8d8fc810u, 0x06100293u, 0x19000000u, 0x00100000u, 0x00000908u, 0x00000000u, 0x04e00300u, 0x3807e0b2u, 0x3d83d793u, 0x0006f5ccu,
            0x00000000u, 0xffff0000u, 0x8076337du, 0x4ff45ba0u, 0x09405033u, 0x034376d9u, 0x09000000u, 0x4e100501u, 0x076d14dcu, 0xf964f45eu,
            0x0000003du
        }
    };
    return table;
 }
 /// the 128-bit significand of 10^k, rounded down, for k in [-307, 341]
 /// (compute_pow10 of Zmij)
 inline uint128_parts compute_pow10(int k) noexcept
 {
    const auto i = static_cast<unsigned>(k + 307);
    const std::uint64_t m = pow10_minor()[(i + 24) % 28];
    const std::size_t j = 2 * static_cast<std::size_t>((i + 24) / 28);
    const std::uint64_t h_hi = pow10_major()[j];
    const std::uint64_t h_lo = pow10_major()[j + 1];
    const std::uint64_t h1 = full_multiplication(h_lo, m).high;
    const std::uint64_t c0 = h_lo * m;
    const std::uint64_t c1 = h1 + (h_hi * m);
    const std::uint64_t c2 = (c1 < h1 ? 1u : 0u) + full_multiplication(h_hi, m).high;
    uint128_parts r{};
    if ((c2 >> 63u) != 0)
    {
        r.high = c2;
        r.low = c1;
    }
    else
    {
        r.high = (c2 << 1u) | (c1 >> 63u);
        r.low = (c1 << 1u) | (c0 >> 63u);
    }
    r.low -= (pow10_fixups()[i >> 5u] >> (i & 31u)) & 1u;
    return r;
 }
 /// The 128-bit significand of 10^k, rounded down, for k in [-342, 341].
 /// Up to 10^308, the table for number parsing holds the same significands
 /// (those of 5^k), except for k in [-27, -1], where it holds them one unit
 /// larger (as the Eisel-Lemire algorithm needs them).
 inline uint128_parts pow10(int k) noexcept
 {
    if (k > pow5_128_largest_power)
    {
        return compute_pow10(k); // (only for the smallest doubles)
    }
    const auto i = 2 * static_cast<std::size_t>(k - pow5_128_smallest_power);
    uint128_parts r{pow5_128()[i + 1], pow5_128()[i]};
    const std::uint64_t adjust = static_cast<unsigned>(k + 27) < 27u ? 1u : 0u;
    r.high -= r.low < adjust ? 1u : 0u;
    r.low -= adjust;
    return r;
 }
 /// (x_hi * 2^64 + x_lo) * y >> 64, as 128 bits
 inline uint128_parts umul192_hi128(std::uint64_t x_hi, std::uint64_t x_lo, std::uint64_t y) noexcept
 {
    const uint128_parts p = full_multiplication(x_hi, y);
    uint128_parts r{};
    r.low = p.low + full_multiplication(x_lo, y).high;
    r.high = p.high + (r.low < p.low ? 1u : 0u);
    return r;
 }
 /// (x * y + c) >> 64
 inline std::uint64_t umul128_add_hi64(std::uint64_t x, std::uint64_t y, std::uint64_t c) noexcept
 {
    const uint128_parts p = full_multiplication(x, y);
    return p.high + (p.low + c < p.low ? 1u : 0u);
 }
 /// the result of Zmij: the shorter candidate and, if that is outside the
 /// rounding interval, the digit after it (16 bytes: returned in registers)
 struct shortest_decimal
 {
    std::uint64_t integral;  ///< the shorter candidate (15 or 16 digits for normal doubles)
    int exponent;            ///< the decimal exponent of the digit after it
    unsigned char digit;     ///< the digit after it (if has_digit)
    bool has_digit;          ///< whether the shortest decimal is integral * 10 + digit
 };
 /// The shortest decimal in the rounding interval of a positive finite double
 /// given by its bits, the closest one if there are several (to_decimal of
 /// Zmij, which keeps the last digit apart: the 15 or 16 digits before it can be
 /// converted without a multiplication by 10 first). Always inlined: GCC
 /// otherwise calls it, and its result goes through memory.
 JSON_HEDLEY_ALWAYS_INLINE shortest_decimal to_shortest(std::uint64_t bits) noexcept
 {
    constexpr int extra_shift = 9;
    const auto raw_exp = static_cast<int>((bits >> 52u) & 0x7FFu);
    std::uint64_t bin_sig = bits & ((std::uint64_t{1} << 52u) - 1);
    // a power of two has a narrower interval below (except the smallest normal)
    const bool regular = bin_sig != 0 || raw_exp <= 1;
    const int bin_exp = (raw_exp == 0 ? 1 : raw_exp) - 1075;
    if (raw_exp != 0)
    {
        bin_sig |= std::uint64_t{1} << 52u;
    }
    // floor(log10(2^bin_exp)), or floor(log10(3/4 * 2^bin_exp)) for the irregular case
    const int dec_exp = ((bin_exp * 315653) - (regular ? 0 : 131072)) >> 20;
    // scaled by 10^(-dec_exp - 1): the integral part is the shorter candidate
    const int shift = bin_exp + ((-(dec_exp + 1) * 217707) >> 16) + 1 + extra_shift;
    const uint128_parts p10 = pow10(-dec_exp - 1);
    const uint128_parts p = umul192_hi128(p10.high, p10.low, bin_sig << static_cast<unsigned>(shift));
    std::uint64_t integral = p.high >> static_cast<unsigned>(extra_shift);
    const std::uint64_t fractional = (p.high << static_cast<unsigned>(64 - extra_shift)) | (p.low >> static_cast<unsigned>(extra_shift));
    std::uint64_t digit = 0;
    bool round_up = false;
    bool round_down = false;
    if (JSON_HEDLEY_LIKELY(regular))
    {
        const std::uint64_t half_ulp = (p10.high >> static_cast<unsigned>(extra_shift + 1 - shift)) + (1 - (bin_sig & 1u));
        round_up = fractional + half_ulp < fractional;
        round_down = half_ulp > fractional;
        // the last digit of the longer candidate, rounded to nearest
        digit = umul128_add_hi64(fractional, 10, (std::uint64_t{1} << 63u) + 6);
        if (fractional == (std::uint64_t{1} << 62u))
        {
            digit = 2; // 2.5 rounds to 2
        }
    }
    else
    {
        const std::uint64_t half_ulp = p10.high >> static_cast<unsigned>(extra_shift + 1 - shift);
        round_up = half_ulp > ~std::uint64_t{0} - fractional;
        round_down = (half_ulp >> 1u) > fractional;
        digit = umul128_add_hi64(fractional, 10, (std::uint64_t{1} << 63u) - 1);
        const std::uint64_t lowest = umul128_add_hi64(fractional - (half_ulp >> 1u), 10, ~std::uint64_t{0});
        digit = digit < lowest ? lowest : digit;
    }
    integral += round_up ? 1u : 0u;
    // if the shorter candidate is outside the rounding interval: one digit more
    return shortest_decimal{integral, dec_exp, static_cast<unsigned char>(digit), !round_up && !round_down};
 }
 }  // namespace zmij
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -233,41 +233,6 @@ class lexer : public lexer_base<BasicJsonType>
    // scan functions
    /////////////////////
    /// contiguous input: try to decode the 4 hex digits following `\\u`
    /// directly from the input buffer via hex_codepoint(), instead of 4 calls
    /// to get(). On success, advances the adapter exactly as those 4 get()
    /// calls would (bulk_scan implies lazy_position, so there are no position
    /// counters to advance) and leaves @a current holding the last of
    /// the 4 digits, just as the last such get() would; the codepoint is
    /// written to @a out. Makes no state change and returns false for a
    /// pending unget, fewer than 4 remaining bytes, or any of the 4 bytes not
    /// being a hex digit, so the caller falls back unchanged to the
    /// per-character loop, which then reports the same diagnostic (stopping
    /// at the first invalid digit) as before this optimization.
    bool get_codepoint_bulk(std::true_type /*bulk*/, int& out)
    {
        if (next_unget || ia.bulk_remaining() < 4)
        {
            return false;
        }
        const char_type* const raw = ia.bulk_data();
        const int codepoint = hex_codepoint(reinterpret_cast<const unsigned char*>(raw));
        if (codepoint < 0)
        {
            return false;
        }
        ia.bulk_skip(4);
        current = char_traits<char_type>::to_int_type(raw[3]);
        out = codepoint;
        return true;
    }
    /// streaming input: no bulk fast path
    bool get_codepoint_bulk(std::false_type /*bulk*/, int& /*out*/) const noexcept
    {
        return false;
    }
    /*!
    @brief get codepoint from 4 hex characters following `\\u`
@@ -287,14 +252,6 @@ class lexer : public lexer_base<BasicJsonType>
    {
        // this function only makes sense after reading `\u`
        JSON_ASSERT(current == 'u');
        // contiguous input: decode all 4 hex digits directly from the buffer
        int fast_codepoint = 0;
        if (get_codepoint_bulk(std::integral_constant<bool, bulk_scan> {}, fast_codepoint))
        {
            return fast_codepoint;
        }
        int codepoint = 0;
        const auto factors = { 12u, 8u, 4u, 0u };
@@ -1095,11 +1052,9 @@ class lexer : public lexer_base<BasicJsonType>
            token_type::parse_error otherwise
    @note The scanner is independent of the current locale: token_buffer
-          always holds `.`. The conversion of float and double does not use
+          always holds `.`. Only the std::strtod fallback of convert_number()
-          the locale either. Only the std::strtold fallback of
+          depends on the locale, and it looks up the decimal point right
-          convert_number() for long double formats other than binary64
+          before converting (see detail::convert_float_locale_aware()).
          depends on it, and it looks up the decimal point right before
          converting (see detail::convert_float_locale_aware()).
    */
    token_type scan_number()  // lgtm [cpp/use-of-goto] `goto` is used in this function to implement the number-parsing state machine described above. By design, any finite input will eventually reach the "done" state or return token_type::parse_error. In each intermediate state, 1 byte of the input is appended to the token_buffer vector, and only the already initialized variables token_buffer, number_type, and error_message are manipulated.
    {
@@ -1112,7 +1067,7 @@ class lexer : public lexer_base<BasicJsonType>
        // offset just past the last mantissa byte in token_buffer (i.e. the
        // index of 'e'/'E', or the whole token when there is no exponent).
-        // convert_number() uses it to split the token; npos means
+        // convert_number() uses it to count significant digits; npos means
        // "not seen an exponent yet" and is resolved at scan_number_done
        std::size_t mantissa_end = std::string::npos;
@@ -1442,8 +1397,8 @@ scan_number_done:
    @param[in] mantissa_end  offset just past the last mantissa byte in
                             token_buffer (the index of 'e'/'E', or
                             token_buffer.size() when there is no exponent);
-                             with decimal_point_position, it locates the parts
+                             used to skip Clinger's fast path when it cannot
-                             of a float token without scanning it again
+                             possibly succeed - see detail::mantissa_fits_clinger()
    */
    token_type convert_number(token_type number_type, std::size_t mantissa_end)
    {
@@ -1497,11 +1452,10 @@ scan_number_done:
        }
        // this code is reached if we parse a floating-point number or if an
-        // integer conversion above overflowed. float and double (and long
+        // integer conversion above overflowed. Prefer std::from_chars
-        // double where it is binary64) are converted by the library itself,
+        // (Eisel-Lemire, locale-independent, correctly rounded) when available;
-        // correctly rounded and independent of the locale; other long double
+        // otherwise the exact Clinger fast path (double only); otherwise the
-        // formats use std::from_chars when available, otherwise the
+        // locale-aware strtof/strtod/strtold.
        // locale-aware strtold.
        if (convert_float_fast(num_begin, num_end, decimal_point_position, mantissa_end, value_float))
        {
            return token_type::value_float;
@@ -22,10 +22,6 @@ namespace detail
 constexpr std::int64_t pow5_128_smallest_power = -342;
 constexpr std::int64_t pow5_128_largest_power = 308;
 // every entry of pow5_128() holds two 64-bit halves of 5^q, one per covered power of 5
 static_assert((pow5_128_largest_power - pow5_128_smallest_power + 1) * 2 == 1302,
              "pow5_128_smallest_power/pow5_128_largest_power must match the size of the pow5_128() table");
 /*!
@brief 128-bit approximations of 5^q for q in [-342, 308]
@@ -8,12 +8,10 @@
 #pragma once
 #include <array> // array
 #include <cstddef> // size_t
-#include <cstdint> // uint64_t, uint8_t
+#include <cstdint> // uint64_t
 #include <cstring> // memcpy
 #include <nlohmann/detail/bit_ops.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
 // Optional SIMD backend for bulk UTF-8 validation. This is an opt-in external
@@ -71,12 +69,18 @@ inline std::size_t find_string_special(const unsigned char* data, std::size_t n)
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
-        const std::uint64_t special = swar_string_special(read_eight_bytes(data + i));
+        std::uint64_t word = 0;
-        if (special != 0)
+        std::memcpy(&word, data + i, sizeof(word));
        if (swar_string_special(word) != 0)
        {
-            // the lowest flagged byte is the first special one: the borrows of
+            // a special byte is in this word; locate it (endian-agnostic)
-            // the subtractions can only flag bytes above a true hit
+            for (std::size_t j = 0; j < 8; ++j)
-            return i + (static_cast<std::size_t>(count_trailing_zeros(special)) / 8);
+            {
                if (is_string_special(data[i + j]))
                {
                    return i + j;
                }
            }
        }
    }
    for (; i < n; ++i)
@@ -110,7 +114,8 @@ inline std::size_t find_ascii_copyable_run(const unsigned char* data, std::size_
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
-        const std::uint64_t v = read_eight_bytes(data + i);
+        std::uint64_t v = 0;
        std::memcpy(&v, data + i, sizeof(v));
        const std::uint64_t q = v ^ 0x2222222222222222ull; // '"'  (0x22)
        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull; // '\\' (0x5C)
        const std::uint64_t d = v ^ 0x7F7F7F7F7F7F7F7Full; // DEL  (0x7F)
@@ -121,9 +126,7 @@ inline std::size_t find_ascii_copyable_run(const unsigned char* data, std::size_
                                   | (v & high);               // >= 0x80
        if (stop != 0)
        {
-            // the lowest flagged byte is the first one to stop at (see
+            break;
            // find_string_special())
            return i + (static_cast<std::size_t>(count_trailing_zeros(stop)) / 8);
        }
    }
    for (; i < n; ++i)
@@ -250,19 +253,13 @@ inline std::size_t scalar_string_bulk_run(const unsigned char* data, std::size_t
        {
            break; // end of buffer, or a quote/escape/control byte
        }
        // a run of multi-byte sequences (e.g. CJK text) is validated sequence
        // by sequence without searching for the next special byte in between
        do
        {
        const std::size_t seq = validate_one_utf8(data + pos, n - pos);
        if (seq == 0)
        {
-                return pos; // ill-formed or truncated: let the byte path diagnose it
+            break; // ill-formed or truncated: let the byte path diagnose it
        }
        pos += seq;
    }
        while (pos < n && data[pos] >= 0x80u);
    }
    return pos;
 }
@@ -276,7 +273,8 @@ inline std::size_t find_string_delimiter(const unsigned char* data, std::size_t
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
-        const std::uint64_t v = read_eight_bytes(data + i);
+        std::uint64_t v = 0;
        std::memcpy(&v, data + i, sizeof(v));
        const std::uint64_t q = v ^ 0x2222222222222222ull;
        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull;
        const std::uint64_t hit = ((q - ones) & ~q & high)
@@ -284,8 +282,14 @@ inline std::size_t find_string_delimiter(const unsigned char* data, std::size_t
                                  | ((v - 0x2020202020202020ull) & ~v & high);
        if (hit != 0)
        {
-            // the lowest flagged byte is the first delimiter (see find_string_special())
+            for (std::size_t j = 0; j < 8; ++j)
-            return i + (static_cast<std::size_t>(count_trailing_zeros(hit)) / 8);
+            {
                const unsigned char c = data[i + j];
                if (c == '\"' || c == '\\' || c < 0x20u)
                {
                    return i + j;
                }
            }
        }
    }
    for (; i < n; ++i)
@@ -316,50 +320,5 @@ inline std::size_t string_bulk_run(const unsigned char* data, std::size_t n) noe
    return scalar_string_bulk_run(data, n);
 }
 // Decode the 4 hex digits at [data, data+4) - the digits following a `\u`
 // escape - into a codepoint 0x0000..0xFFFF via one table lookup per byte
 // (after yyjson's read_hex_u16), or return -1 if any of the 4 bytes is not a
 // hex digit ('0'..'9', 'A'..'F', 'a'..'f'). The caller must already have
 // checked that 4 bytes are available; used by lexer::get_codepoint()'s
 // contiguous fast path. On -1 it falls back to the byte-at-a-time loop, which
 // stops at the first invalid digit, so the reported error and position are
 // unaffected by this fast path.
 inline int hex_codepoint(const unsigned char* data) noexcept
 {
    static const std::array<std::uint8_t, 256> hex_digit_table = // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
    {
        {
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 00..0F
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 10..1F
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 20..2F
            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 30..3F ('0'..'9')
            0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 40..4F ('A'..'F')
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 50..5F
            0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 60..6F ('a'..'f')
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 70..7F
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 80..8F
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 90..9F
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // A0..AF
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // B0..BF
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // C0..CF
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // D0..DF
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // E0..EF
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF  // F0..FF
        }
    };
    const std::uint8_t d0 = hex_digit_table[data[0]];
    const std::uint8_t d1 = hex_digit_table[data[1]];
    const std::uint8_t d2 = hex_digit_table[data[2]];
    const std::uint8_t d3 = hex_digit_table[data[3]];
    // every valid digit is <= 0xF; the combined OR only exceeds it if at
    // least one of the four bytes was not a hex digit (looked up as 0xFF)
    if ((d0 | d1 | d2 | d3) > 0x0F)
    {
        return -1;
    }
    return (d0 << 12) | (d1 << 8) | (d2 << 4) | d3;
 }
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -21,8 +21,6 @@
 #undef JSON_NO_UNIQUE_ADDRESS
 #undef JSON_DISABLE_ENUM_SERIALIZATION
 #undef JSON_DISABLE_TUPLE_REFERENCE_CONVERSION
 #undef JSON_DTOA_SSE2
 #undef JSON_DTOA_NEON
 #ifndef JSON_TEST_KEEP_MACROS
    #undef JSON_CATCH
@@ -772,6 +772,33 @@ class serializer
                        break;
                    }
                }
                // A byte below 0x60 is a complete code point and needs no
                // UTF-8 decoding. The scanner stops only at a control
                // character, a quote, or a backslash in that range, so look up
                // its escape sequence and write all 8 bytes of the table entry
                // straight into the write buffer; only the length stored in the
                // last byte of the entry is kept.
                if (data[i] < 0x60)
                {
                    // emit any bytes still pending in string_buffer first to
                    // preserve output order
                    if (bytes != 0)
                    {
                        put_buffer(string_buffer, bytes);
                        bytes = 0;
                    }
                    const auto& escape = ascii_escapes()[data[i]];
                    if (JSON_HEDLEY_UNLIKELY(write_buffer.size() - write_buffer_pos < escape.size()))
                    {
                        flush();
                    }
                    std::memcpy(write_buffer.data() + write_buffer_pos, escape.data(), escape.size());
                    write_buffer_pos += static_cast<std::size_t>(escape[7]);
                    bytes_after_last_accept = 0;
                    undumped_chars = 0;
                    continue;
                }
            }
            const auto byte = static_cast<std::uint8_t>(s[i]);
@@ -780,71 +807,21 @@ class serializer
            {
                case UTF8_ACCEPT:  // decode found a new code point
                {
-                    switch (codepoint)
+                    // the code point is at least 0x60 (smaller ones are handled
                    // above) and is not printable ASCII (which the scanner
                    // copies): it is DEL (0x7F) under EnsureAscii or a non-ASCII
                    // character
                    if (EnsureAscii)
                    {
-                        case 0x08: // backspace
+                        JSON_ASSERT(codepoint >= 0x7F);
                        if (error_handler == error_handler_t::keep)
                        {
-                            string_buffer[bytes++] = '\\';
+                            // this character was buffered as raw bytes below
-                            string_buffer[bytes++] = 'b';
+                            // in case it turned out to be part of an
-                            break;
+                            // ill-formed sequence (which is kept as is); now
-                        }
+                            // that it decoded to a well-formed code point,
-
+                            // undo that and \u-escape it like any other
-                        case 0x09: // horizontal tab
+                            // character instead
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 't';
                            break;
                        }
                        case 0x0A: // newline
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 'n';
                            break;
                        }
                        case 0x0C: // formfeed
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 'f';
                            break;
                        }
                        case 0x0D: // carriage return
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 'r';
                            break;
                        }
                        case 0x22: // quotation mark
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = '"';
                            break;
                        }
                        case 0x5C: // reverse solidus
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = '\\';
                            break;
                        }
                        default:
                        {
                            // escape control characters (0x00..0x1F) or, if
                            // EnsureAscii parameter is used, non-ASCII characters
                            if ((codepoint <= 0x1F) || (EnsureAscii && (codepoint >= 0x7F)))
                            {
                                if (EnsureAscii && error_handler == error_handler_t::keep)
                                {
                                    // this character was buffered as raw bytes
                                    // below in case it turned out to be part of
                                    // an ill-formed sequence (which is kept as
                                    // is); now that it decoded to a well-formed
                                    // code point, undo that and \u-escape it
                                    // like any other character instead
                            bytes = bytes_after_last_accept;
                        }
                        if (codepoint <= 0xFFFF)
@@ -859,13 +836,10 @@ class serializer
                    }
                    else
                    {
-                                // copy byte to buffer (all previous bytes
+                        // copy byte to buffer (all previous bytes of the
-                                // been copied have in default case above)
+                        // sequence have been copied in the default case below)
                        string_buffer[bytes++] = s[i];
                    }
                            break;
                        }
                    }
                    // write buffer and reset index; there must be 13 bytes
                    // left, as this is the maximal number of bytes to be
@@ -1253,6 +1227,121 @@ class serializer
        }
    }
    /*!
    @brief the JSON form of each character below 0x60
    Entry c holds the escape sequence of character c - the short form for
    \\b, \\t, \\n, \\f, \\r, \\" and \\\\, \\u00xx for the other control characters -
    or c itself if it needs no escaping, padded with zeros to 7 bytes. The last
    byte is the length of the sequence. The 8 bytes of an entry are copied at
    once, so writing an escape needs neither a branch nor a byte-wise loop.
    */
    static const std::array<std::array<char, 8>, 0x60>& ascii_escapes() noexcept
    {
        static const std::array<std::array<char, 8>, 0x60> escapes =
        {
            {
                {{'\\', 'u', '0', '0', '0', '0', 0, 6}}, // 0x00
                {{'\\', 'u', '0', '0', '0', '1', 0, 6}}, // 0x01
                {{'\\', 'u', '0', '0', '0', '2', 0, 6}}, // 0x02
                {{'\\', 'u', '0', '0', '0', '3', 0, 6}}, // 0x03
                {{'\\', 'u', '0', '0', '0', '4', 0, 6}}, // 0x04
                {{'\\', 'u', '0', '0', '0', '5', 0, 6}}, // 0x05
                {{'\\', 'u', '0', '0', '0', '6', 0, 6}}, // 0x06
                {{'\\', 'u', '0', '0', '0', '7', 0, 6}}, // 0x07
                {{'\\', 'b', 0, 0, 0, 0, 0, 2}}, // 0x08
                {{'\\', 't', 0, 0, 0, 0, 0, 2}}, // 0x09
                {{'\\', 'n', 0, 0, 0, 0, 0, 2}}, // 0x0A
                {{'\\', 'u', '0', '0', '0', 'b', 0, 6}}, // 0x0B
                {{'\\', 'f', 0, 0, 0, 0, 0, 2}}, // 0x0C
                {{'\\', 'r', 0, 0, 0, 0, 0, 2}}, // 0x0D
                {{'\\', 'u', '0', '0', '0', 'e', 0, 6}}, // 0x0E
                {{'\\', 'u', '0', '0', '0', 'f', 0, 6}}, // 0x0F
                {{'\\', 'u', '0', '0', '1', '0', 0, 6}}, // 0x10
                {{'\\', 'u', '0', '0', '1', '1', 0, 6}}, // 0x11
                {{'\\', 'u', '0', '0', '1', '2', 0, 6}}, // 0x12
                {{'\\', 'u', '0', '0', '1', '3', 0, 6}}, // 0x13
                {{'\\', 'u', '0', '0', '1', '4', 0, 6}}, // 0x14
                {{'\\', 'u', '0', '0', '1', '5', 0, 6}}, // 0x15
                {{'\\', 'u', '0', '0', '1', '6', 0, 6}}, // 0x16
                {{'\\', 'u', '0', '0', '1', '7', 0, 6}}, // 0x17
                {{'\\', 'u', '0', '0', '1', '8', 0, 6}}, // 0x18
                {{'\\', 'u', '0', '0', '1', '9', 0, 6}}, // 0x19
                {{'\\', 'u', '0', '0', '1', 'a', 0, 6}}, // 0x1A
                {{'\\', 'u', '0', '0', '1', 'b', 0, 6}}, // 0x1B
                {{'\\', 'u', '0', '0', '1', 'c', 0, 6}}, // 0x1C
                {{'\\', 'u', '0', '0', '1', 'd', 0, 6}}, // 0x1D
                {{'\\', 'u', '0', '0', '1', 'e', 0, 6}}, // 0x1E
                {{'\\', 'u', '0', '0', '1', 'f', 0, 6}}, // 0x1F
                {{' ', 0, 0, 0, 0, 0, 0, 1}}, // 0x20
                {{'!', 0, 0, 0, 0, 0, 0, 1}}, // 0x21
                {{'\\', '"', 0, 0, 0, 0, 0, 2}}, // 0x22
                {{'#', 0, 0, 0, 0, 0, 0, 1}}, // 0x23
                {{'$', 0, 0, 0, 0, 0, 0, 1}}, // 0x24
                {{'%', 0, 0, 0, 0, 0, 0, 1}}, // 0x25
                {{'&', 0, 0, 0, 0, 0, 0, 1}}, // 0x26
                {{'\'', 0, 0, 0, 0, 0, 0, 1}}, // 0x27
                {{'(', 0, 0, 0, 0, 0, 0, 1}}, // 0x28
                {{')', 0, 0, 0, 0, 0, 0, 1}}, // 0x29
                {{'*', 0, 0, 0, 0, 0, 0, 1}}, // 0x2A
                {{'+', 0, 0, 0, 0, 0, 0, 1}}, // 0x2B
                {{',', 0, 0, 0, 0, 0, 0, 1}}, // 0x2C
                {{'-', 0, 0, 0, 0, 0, 0, 1}}, // 0x2D
                {{'.', 0, 0, 0, 0, 0, 0, 1}}, // 0x2E
                {{'/', 0, 0, 0, 0, 0, 0, 1}}, // 0x2F
                {{'0', 0, 0, 0, 0, 0, 0, 1}}, // 0x30
                {{'1', 0, 0, 0, 0, 0, 0, 1}}, // 0x31
                {{'2', 0, 0, 0, 0, 0, 0, 1}}, // 0x32
                {{'3', 0, 0, 0, 0, 0, 0, 1}}, // 0x33
                {{'4', 0, 0, 0, 0, 0, 0, 1}}, // 0x34
                {{'5', 0, 0, 0, 0, 0, 0, 1}}, // 0x35
                {{'6', 0, 0, 0, 0, 0, 0, 1}}, // 0x36
                {{'7', 0, 0, 0, 0, 0, 0, 1}}, // 0x37
                {{'8', 0, 0, 0, 0, 0, 0, 1}}, // 0x38
                {{'9', 0, 0, 0, 0, 0, 0, 1}}, // 0x39
                {{':', 0, 0, 0, 0, 0, 0, 1}}, // 0x3A
                {{';', 0, 0, 0, 0, 0, 0, 1}}, // 0x3B
                {{'<', 0, 0, 0, 0, 0, 0, 1}}, // 0x3C
                {{'=', 0, 0, 0, 0, 0, 0, 1}}, // 0x3D
                {{'>', 0, 0, 0, 0, 0, 0, 1}}, // 0x3E
                {{'?', 0, 0, 0, 0, 0, 0, 1}}, // 0x3F
                {{'@', 0, 0, 0, 0, 0, 0, 1}}, // 0x40
                {{'A', 0, 0, 0, 0, 0, 0, 1}}, // 0x41
                {{'B', 0, 0, 0, 0, 0, 0, 1}}, // 0x42
                {{'C', 0, 0, 0, 0, 0, 0, 1}}, // 0x43
                {{'D', 0, 0, 0, 0, 0, 0, 1}}, // 0x44
                {{'E', 0, 0, 0, 0, 0, 0, 1}}, // 0x45
                {{'F', 0, 0, 0, 0, 0, 0, 1}}, // 0x46
                {{'G', 0, 0, 0, 0, 0, 0, 1}}, // 0x47
                {{'H', 0, 0, 0, 0, 0, 0, 1}}, // 0x48
                {{'I', 0, 0, 0, 0, 0, 0, 1}}, // 0x49
                {{'J', 0, 0, 0, 0, 0, 0, 1}}, // 0x4A
                {{'K', 0, 0, 0, 0, 0, 0, 1}}, // 0x4B
                {{'L', 0, 0, 0, 0, 0, 0, 1}}, // 0x4C
                {{'M', 0, 0, 0, 0, 0, 0, 1}}, // 0x4D
                {{'N', 0, 0, 0, 0, 0, 0, 1}}, // 0x4E
                {{'O', 0, 0, 0, 0, 0, 0, 1}}, // 0x4F
                {{'P', 0, 0, 0, 0, 0, 0, 1}}, // 0x50
                {{'Q', 0, 0, 0, 0, 0, 0, 1}}, // 0x51
                {{'R', 0, 0, 0, 0, 0, 0, 1}}, // 0x52
                {{'S', 0, 0, 0, 0, 0, 0, 1}}, // 0x53
                {{'T', 0, 0, 0, 0, 0, 0, 1}}, // 0x54
                {{'U', 0, 0, 0, 0, 0, 0, 1}}, // 0x55
                {{'V', 0, 0, 0, 0, 0, 0, 1}}, // 0x56
                {{'W', 0, 0, 0, 0, 0, 0, 1}}, // 0x57
                {{'X', 0, 0, 0, 0, 0, 0, 1}}, // 0x58
                {{'Y', 0, 0, 0, 0, 0, 0, 1}}, // 0x59
                {{'Z', 0, 0, 0, 0, 0, 0, 1}}, // 0x5A
                {{'[', 0, 0, 0, 0, 0, 0, 1}}, // 0x5B
                {{'\\', '\\', 0, 0, 0, 0, 0, 2}}, // 0x5C
                {{']', 0, 0, 0, 0, 0, 0, 1}}, // 0x5D
                {{'^', 0, 0, 0, 0, 0, 0, 1}}, // 0x5E
                {{'_', 0, 0, 0, 0, 0, 0, 1}}, // 0x5F
            }
        };
        return escapes;
    }
    /*!
     * @brief write a lowercase "\\uXXXX" escape sequence into @a string_buffer
     *
@@ -1366,9 +1455,8 @@ class serializer
    /*!
    @brief dump an integer
-    Dump a given integer, appending it to @ref write_buffer (directly: copying
+    Dump a given integer, appending it to @ref write_buffer. Works internally with
-    the digits from another buffer right after writing them waits until the
+    @a number_buffer.
    stores are done).
    @param[in] x  integer number (signed or unsigned) to dump
    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
@@ -1403,57 +1491,33 @@ class serializer
            return;
        }
-        // use a pointer to fill the buffer (room for as much as number_buffer holds)
+        // use a pointer to fill the buffer
-        if (JSON_HEDLEY_UNLIKELY(write_buffer_pos + number_buffer.size() > write_buffer.size()))
+        auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto)
        {
            flush();
        }
        auto* buffer_ptr = write_buffer.data() + write_buffer_pos;
        number_unsigned_t abs_value;
-        // one byte for the minus sign
+        unsigned int n_chars{};
        unsigned int n_chars = 0;
        if (is_negative_number(x))
        {
            *buffer_ptr = '-';
            abs_value = remove_sign(static_cast<number_integer_t>(x));
-            n_chars = 1;
+
            // account one more byte for the minus sign
            n_chars = 1 + count_digits(abs_value);
        }
        else
        {
            abs_value = static_cast<number_unsigned_t>(x);
            n_chars = count_digits(abs_value);
        }
        // up to 16 digits: eight at a time (as the digits of floats), written
        // without leading zeros
        if (abs_value < 10000000000000000u)
        {
            const std::uint64_t value = abs_value;
            const std::uint64_t upper = value / 100000000u;
            const std::uint64_t first = dtoa_impl::eight_digit_bytes(upper != 0 ? upper : value);
            const auto leading = static_cast<unsigned>(count_leading_zeros(first) / 8); // (first is not 0)
            char* const p = buffer_ptr + n_chars;
            dtoa_impl::store_msb_first(p, (first << (8 * leading)) + 0x3030303030303030u);
            n_chars += 8 - leading;
            if (upper != 0)
            {
                dtoa_impl::store_msb_first(p + 8 - leading, dtoa_impl::eight_digit_bytes(value - (upper * 100000000u)) + 0x3030303030303030u);
                n_chars += 8;
            }
            write_buffer_pos += n_chars;
            return;
        }
        n_chars += count_digits(abs_value);
        // spare 1 byte for '\0'
        JSON_ASSERT(n_chars < number_buffer.size() - 1);
        // jump to the end to generate the string from backward,
        // so we later avoid reversing the result
-        buffer_ptr += n_chars;
+        buffer_ptr += static_cast<typename decltype(number_buffer)::difference_type>(n_chars);
        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
@@ -1476,13 +1540,14 @@ class serializer
            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
        }
-        write_buffer_pos += n_chars;
+        put_buffer(number_buffer, n_chars);
    }
    /*!
    @brief dump a floating-point number
-    Dump a given floating-point number, appending it to @ref write_buffer.
+    Dump a given floating-point number, appending it to @ref write_buffer. Works internally
    with @a number_buffer.
    @param[in] x  floating-point number to dump
    */
@@ -1509,15 +1574,10 @@ class serializer
    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
    {
-        // directly into the write buffer: copying the text from number_buffer
+        auto* begin = number_buffer.data();
        // right after to_chars() wrote it waits until its stores are done
        if (JSON_HEDLEY_UNLIKELY(write_buffer_pos + number_buffer.size() > write_buffer.size()))
        {
            flush();
        }
        auto* begin = write_buffer.data() + write_buffer_pos;
        auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
-        write_buffer_pos += static_cast<std::size_t>(end - begin);
+
        put_buffer(number_buffer, static_cast<std::size_t>(end - begin));
    }
    JSON_HEDLEY_NON_NULL(1)
@@ -6,9 +6,8 @@ if((CMAKE_CXX_COMPILER_ID MATCHES GNU) OR (CMAKE_CXX_COMPILER_ID MATCHES Clang))
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto -DNDEBUG -O3")
 endif()
-# configure Google Benchmark; a fixed release with a checksum, so that builds are reproducible. Update it like any
+# configure Google Benchmark; a fixed release, so that results stay comparable
-# other dependency; comparisons stay fair because both sides are built with the same version (see README.md)
+set(JSON_GOOGLE_BENCHMARK_VERSION 1.9.5)
 set(JSON_GOOGLE_BENCHMARK_VERSION 1.10.0)
 include(FetchContent)
 # only the library is needed; -Werror would break the pinned release as soon as
@@ -19,7 +18,7 @@ set(BENCHMARK_ENABLE_WERROR OFF CACHE BOOL "" FORCE)
 FetchContent_Declare(benchmark
    URL https://github.com/google/benchmark/archive/refs/tags/v${JSON_GOOGLE_BENCHMARK_VERSION}.tar.gz
-    URL_HASH SHA256=acc5c7c0fbed855c4aaa2d7c3c36fb82b0c15c28f4e151e3f679c2fc0aa404af
+    URL_HASH SHA256=9631341c82bac4a288bef951f8b26b41f69021794184ece969f8473977eaa340
    DOWNLOAD_EXTRACT_TIMESTAMP TRUE
 )
 FetchContent_MakeAvailable(benchmark)
@@ -27,11 +27,8 @@ The input files are those of [nativejson-benchmark](https://github.com/miloyip/n
 - Network access on the first configure: CMake downloads Google Benchmark and the
  [test data](https://github.com/nlohmann/json_test_data) into the build directory. To reuse a download of the test
  data, pass `-DJSON_TestDataDirectory=<build directory>/test_files`.
- Google Benchmark is fetched as a fixed release with a checksum, so that every build uses the same
+- Google Benchmark is pinned to a release (1.9.5), so that results from different days stay comparable. To update it,
-  code and a download cannot change under you. It is updated like any other dependency when a new release comes out:
+  change `JSON_GOOGLE_BENCHMARK_VERSION` and the archive's `URL_HASH` in `CMakeLists.txt` together.
  change `JSON_GOOGLE_BENCHMARK_VERSION` and the archive's `URL_HASH` in `CMakeLists.txt` together. Results are kept
  comparable by building both sides of a comparison with the same version, not by keeping that version forever (see
  [Comparing two versions](#comparing-two-versions)).
 - The benchmarks include `single_include/nlohmann/json.hpp`, so run `make amalgamate` after changing anything in
  `include/`.
@@ -113,18 +110,13 @@ Python, unpinned versions work as well. In its output:
 - `OVERALL_GEOMEAN` summarizes all benchmarks;
 - `-a` shows only the aggregates, not every repetition.
 Both builds use the same Google Benchmark, the one `CMakeLists.txt` names, so only the header differs. For the same
 reason, do not compare against result files from an earlier checkout: a different Google Benchmark, compiler or
 machine state can shift the numbers as much as the change under test. Rerun the baseline instead.
 The header you compare with must support everything the benchmarks use. The current benchmarks build against 3.12.0.
 Only benchmarks present in both result files are compared, so for older releases, either filter the benchmarks or
 build that release's own `tests/benchmarks` against its own header.
 ## Getting stable numbers
- Build and run both versions on the same machine with the same compiler and Google Benchmark, one right after the
+- Build and run both versions on the same machine, one right after the other.
  other.
 - Keep the machine otherwise idle: no builds, no browser, and a laptop plugged in.
 - On Linux, set the CPU frequency governor to `performance`, e.g. `sudo cpupower frequency-set --governor performance`.
  Google Benchmark prints a warning when frequency scaling is enabled. Pinning the process to a core
@@ -1,599 +0,0 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
 // |  |  |__   |  |  | | | |  version 3.12.0
 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 //
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT
 #pragma once
 #include <array> // array
 #include <cstdint> // uint32_t, uint64_t
 // Number tokens that are hard to round correctly, with the IEEE-754 binary64
 // and binary32 bits of their correctly rounded values (ties to even; infinity
 // for an overflow, a signed zero for an underflow).
 //
 // For doubles and floats around 0, the smallest normal number, 1, 2^24, 2^53,
 // 0.1, and the largest finite number, and for random ones, the exact midpoint
 // m to the next number gives: m, m with one unit more and less in the last
 // digit, m with "01" and "0...01" appended, m with trailing zeros, and m cut
 // after 17 to 30 digits (rounded down and up, so that the rounding is decided
 // after the 19th digit), in fixed and exponent notation, 30% of them negative.
 // Tokens longer than 80 characters are left out, except for four of 700 digits
 // and more. Zeros, underflow, overflow, huge exponents, and integers beyond 64
 // bits complete the set. Of the 508 tokens, 134 (as double) and 150 (as
 // float) need the exact comparison with the midpoint (detail::digit_comparison()).
 //
 // The expected bits were computed with exact rational arithmetic in Python
 // (fractions.Fraction) and cross-checked with Python's float(); strtod_l and
 // strtof_l of Apple's libc and of glibc agree. Generated by
 // compact_hard_cases.py 5 (with hard_cases.py), see the pull request that
 // added this file.
 namespace float_hard_cases
 {
 struct hard_case
 {
    const char* token;
    std::uint64_t bits64;
    std::uint32_t bits32;
 };
 inline const std::array<hard_case, 508>& cases()
 {
    static const std::array<hard_case, 508> table =
    {
        {
            {"-2.4703282292062327e-324", 0x8000000000000000u, 0x80000000u},
            {"24703282292062328e-340", 0x0000000000000001u, 0x00000000u},
            {"247032822920623272e-341", 0x0000000000000000u, 0x00000000u},
            {"-0.2470328229206232721e-323", 0x8000000000000001u, 0x80000000u},
            {"-0.24703282292062327208e-323", 0x8000000000000000u, 0x80000000u},
            {"-2.4703282292062327209e-324", 0x8000000000000001u, 0x80000000u},
            {"2.47032822920623272088e-324", 0x0000000000000000u, 0x00000000u},
            {"247032822920623272089e-344", 0x0000000000000001u, 0x00000000u},
            {"-247032822920623272088284396434e-353", 0x8000000000000000u, 0x80000000u},
            {"0.247032822920623272088284396435e-323", 0x0000000000000001u, 0x00000000u},
            {"-74109846876186981e-340", 0x8000000000000001u, 0x80000000u},
            {"0.74109846876186982e-323", 0x0000000000000002u, 0x00000000u},
            {"-0.7410984687618698162e-323", 0x8000000000000001u, 0x80000000u},
            {"-7.410984687618698163e-324", 0x8000000000000002u, 0x80000000u},
            {"7.4109846876186981626e-324", 0x0000000000000001u, 0x00000000u},
            {"-74109846876186981627e-343", 0x8000000000000002u, 0x80000000u},
            {"-741098468761869816264e-344", 0x8000000000000001u, 0x80000000u},
            {"0.741098468761869816265e-323", 0x0000000000000002u, 0x00000000u},
            {"0.741098468761869816264853189302e-323", 0x0000000000000001u, 0x00000000u},
            {"-7.41098468761869816264853189303e-324", 0x8000000000000002u, 0x80000000u},
            {"0.22250738585072006e-307", 0x000FFFFFFFFFFFFEu, 0x00000000u},
            {"2.2250738585072007e-308", 0x000FFFFFFFFFFFFFu, 0x00000000u},
            {"2.225073858507200641e-308", 0x000FFFFFFFFFFFFEu, 0x00000000u},
            {"-2225073858507200642e-326", 0x800FFFFFFFFFFFFFu, 0x80000000u},
            {"22250738585072006419e-327", 0x000FFFFFFFFFFFFEu, 0x00000000u},
            {"0.2225073858507200642e-307", 0x000FFFFFFFFFFFFFu, 0x00000000u},
            {"0.222507385850720064199e-307", 0x000FFFFFFFFFFFFEu, 0x00000000u},
            {"2.225073858507200642e-308", 0x000FFFFFFFFFFFFFu, 0x00000000u},
            {"-2.22507385850720064199176395546e-308", 0x800FFFFFFFFFFFFEu, 0x80000000u},
            {"222507385850720064199176395547e-337", 0x000FFFFFFFFFFFFFu, 0x00000000u},
            {"-2.2250738585072011e-308", 0x800FFFFFFFFFFFFFu, 0x80000000u},
            {"-22250738585072012e-324", 0x8010000000000000u, 0x80000000u},
            {"-2225073858507201136e-326", 0x800FFFFFFFFFFFFFu, 0x80000000u},
            {"0.2225073858507201137e-307", 0x0010000000000000u, 0x00000000u},
            {"0.2225073858507201136e-307", 0x000FFFFFFFFFFFFFu, 0x00000000u},
            {"-2.2250738585072011361e-308", 0x8010000000000000u, 0x80000000u},
            {"2.22507385850720113605e-308", 0x000FFFFFFFFFFFFFu, 0x00000000u},
            {"222507385850720113606e-328", 0x0010000000000000u, 0x00000000u},
            {"22250738585072011360574097967e-336", 0x000FFFFFFFFFFFFFu, 0x00000000u},
            {"0.222507385850720113605740979671e-307", 0x0010000000000000u, 0x00000000u},
            {"22250738585072016e-324", 0x0010000000000000u, 0x00000000u},
            {"0.22250738585072017e-307", 0x0010000000000001u, 0x00000000u},
            {"0.222507385850720163e-307", 0x0010000000000000u, 0x00000000u},
            {"2.225073858507201631e-308", 0x0010000000000001u, 0x00000000u},
            {"-2.2250738585072016301e-308", 0x8010000000000000u, 0x80000000u},
            {"22250738585072016302e-327", 0x0010000000000001u, 0x00000000u},
            {"-222507385850720163012e-328", 0x8010000000000000u, 0x80000000u},
            {"0.222507385850720163013e-307", 0x0010000000000001u, 0x00000000u},
            {"0.222507385850720163012305563795e-307", 0x0010000000000000u, 0x00000000u},
            {"-2.22507385850720163012305563796e-308", 0x8010000000000001u, 0x80000000u},
            {"0.17976931348623156E+309", 0x7FEFFFFFFFFFFFFEu, 0x7F800000u},
            {"1.7976931348623157e308", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
            {"1.797693134862315608e308", 0x7FEFFFFFFFFFFFFEu, 0x7F800000u},
            {"-1797693134862315609e290", 0xFFEFFFFFFFFFFFFFu, 0xFF800000u},
            {"-17976931348623156083e289", 0xFFEFFFFFFFFFFFFEu, 0xFF800000u},
            {"-0.17976931348623156084E+309", 0xFFEFFFFFFFFFFFFFu, 0xFF800000u},
            {"0.179769313486231560835E+309", 0x7FEFFFFFFFFFFFFEu, 0x7F800000u},
            {"-1.79769313486231560836e308", 0xFFEFFFFFFFFFFFFFu, 0xFF800000u},
            {"1.79769313486231560835325876058e308", 0x7FEFFFFFFFFFFFFEu, 0x7F800000u},
            {"179769313486231560835325876059e279", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
            {"1.7976931348623158e308", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
            {"17976931348623159e292", 0x7FF0000000000000u, 0x7F800000u},
            {"1797693134862315807e290", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
            {"0.1797693134862315808E+309", 0x7FF0000000000000u, 0x7F800000u},
            {"0.17976931348623158079E+309", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
            {"-1.797693134862315808e308", 0xFFF0000000000000u, 0xFF800000u},
            {"1.79769313486231580793e308", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
            {"179769313486231580794e288", 0x7FF0000000000000u, 0x7F800000u},
            {"179769313486231580793728971405e279", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
            {"-0.179769313486231580793728971406E+309", 0xFFF0000000000000u, 0xFF800000u},
            {"100000000000000011102230246251565404236316680908203125e-53", 0x3FF0000000000000u, 0x3F800000u},
            {"-1.00000000000000011102230246251565404236316680908203126", 0xBFF0000000000001u, 0xBF800000u},
            {"1.00000000000000011102230246251565404236316680908203124e0", 0x3FF0000000000000u, 0x3F800000u},
            {"10000000000000001110223024625156540423631668090820312501e-55", 0x3FF0000000000001u, 0x3F800000u},
            {"1.00000000000000011102230246251565404236316680908203125000000000000000000001", 0x3FF0000000000001u, 0x3F800000u},
            {"10000000000000001e-16", 0x3FF0000000000000u, 0x3F800000u},
            {"1.0000000000000002", 0x3FF0000000000001u, 0x3F800000u},
            {"1.000000000000000111", 0x3FF0000000000000u, 0x3F800000u},
            {"1.000000000000000112e0", 0x3FF0000000000001u, 0x3F800000u},
            {"1.000000000000000111e0", 0x3FF0000000000000u, 0x3F800000u},
            {"-10000000000000001111e-19", 0xBFF0000000000001u, 0xBF800000u},
            {"-100000000000000011102e-20", 0xBFF0000000000000u, 0xBF800000u},
            {"-1.00000000000000011103", 0xBFF0000000000001u, 0xBF800000u},
            {"1.00000000000000011102230246251", 0x3FF0000000000000u, 0x3F800000u},
            {"1.00000000000000011102230246252e0", 0x3FF0000000000001u, 0x3F800000u},
            {"-0.999999999999999944488848768742172978818416595458984375", 0xBFF0000000000000u, 0xBF800000u},
            {"-9.99999999999999944488848768742172978818416595458984376e-1", 0xBFF0000000000000u, 0xBF800000u},
            {"999999999999999944488848768742172978818416595458984374e-54", 0x3FEFFFFFFFFFFFFFu, 0x3F800000u},
            {"0.99999999999999994448884876874217297881841659545898437501", 0x3FF0000000000000u, 0x3F800000u},
            {"9.99999999999999944488848768742172978818416595458984375000000000000000000001e-1", 0x3FF0000000000000u, 0x3F800000u},
            {"-0.99999999999999994", 0xBFEFFFFFFFFFFFFFu, 0xBF800000u},
            {"9.9999999999999995e-1", 0x3FF0000000000000u, 0x3F800000u},
            {"9.999999999999999444e-1", 0x3FEFFFFFFFFFFFFFu, 0x3F800000u},
            {"9999999999999999445e-19", 0x3FF0000000000000u, 0x3F800000u},
            {"99999999999999994448e-20", 0x3FEFFFFFFFFFFFFFu, 0x3F800000u},
            {"-0.99999999999999994449", 0xBFF0000000000000u, 0xBF800000u},
            {"0.999999999999999944488", 0x3FEFFFFFFFFFFFFFu, 0x3F800000u},
            {"-9.99999999999999944489e-1", 0xBFF0000000000000u, 0xBF800000u},
            {"9.99999999999999944488848768742e-1", 0x3FEFFFFFFFFFFFFFu, 0x3F800000u},
            {"999999999999999944488848768743e-30", 0x3FF0000000000000u, 0x3F800000u},
            {"-9.007199254740993e15", 0xC340000000000000u, 0xDA000000u},
            {"9007199254740994e0", 0x4340000000000001u, 0x5A000000u},
            {"9007199254740992", 0x4340000000000000u, 0x5A000000u},
            {"9.00719925474099301e15", 0x4340000000000001u, 0x5A000000u},
            {"9007199254740993000000000000000000001e-21", 0x4340000000000001u, 0x5A000000u},
            {"-9007199254740993.000000000000000000000000000000", 0xC340000000000000u, 0xDA000000u},
            {"90071992547409915e-1", 0x4340000000000000u, 0x5A000000u},
            {"-9007199254740991.6", 0xC340000000000000u, 0xDA000000u},
            {"9.0071992547409914e15", 0x433FFFFFFFFFFFFFu, 0x5A000000u},
            {"-9007199254740991501e-3", 0xC340000000000000u, 0xDA000000u},
            {"9007199254740991.5000000000000000000001", 0x4340000000000000u, 0x5A000000u},
            {"9.0071992547409915000000000000000000000000000000e15", 0x4340000000000000u, 0x5A000000u},
            {"0.100000000000000012490009027033011079765856266021728515625", 0x3FB999999999999Au, 0x3DCCCCCDu},
            {"1.00000000000000012490009027033011079765856266021728515626e-1", 0x3FB999999999999Bu, 0x3DCCCCCDu},
            {"100000000000000012490009027033011079765856266021728515624e-57", 0x3FB999999999999Au, 0x3DCCCCCDu},
            {"0.10000000000000001249000902703301107976585626602172851562501", 0x3FB999999999999Bu, 0x3DCCCCCDu},
            {"0.10000000000000001", 0x3FB999999999999Au, 0x3DCCCCCDu},
            {"1.0000000000000002e-1", 0x3FB999999999999Bu, 0x3DCCCCCDu},
            {"-1.000000000000000124e-1", 0xBFB999999999999Au, 0xBDCCCCCDu},
            {"1000000000000000125e-19", 0x3FB999999999999Bu, 0x3DCCCCCDu},
            {"-10000000000000001249e-20", 0xBFB999999999999Au, 0xBDCCCCCDu},
            {"0.1000000000000000125", 0x3FB999999999999Bu, 0x3DCCCCCDu},
            {"0.10000000000000001249", 0x3FB999999999999Au, 0x3DCCCCCDu},
            {"1.00000000000000012491e-1", 0x3FB999999999999Bu, 0x3DCCCCCDu},
            {"1.00000000000000012490009027033e-1", 0x3FB999999999999Au, 0x3DCCCCCDu},
            {"100000000000000012490009027034e-30", 0x3FB999999999999Bu, 0x3DCCCCCDu},
            {"2.45134755833537796875e14", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
            {"-245134755833537796876e-6", 0xC2EBDE5C4164D83Au, 0xD75EF2E2u},
            {"-245134755833537.796874", 0xC2EBDE5C4164D839u, 0xD75EF2E2u},
            {"2.4513475583353779687501e14", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
            {"245134755833537796875000000000000000000001e-27", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
            {"245134755833537.796875000000000000000000000000000000", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
            {"2.4513475583353779e14", 0x42EBDE5C4164D839u, 0x575EF2E2u},
            {"2451347558335378e-1", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
            {"2451347558335377968e-4", 0x42EBDE5C4164D839u, 0x575EF2E2u},
            {"245134755833537.7969", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
            {"245134755833537.79687", 0x42EBDE5C4164D839u, 0x575EF2E2u},
            {"2.4513475583353779688e14", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
            {"181510327827821147441864013671875e-23", 0x41DB0C11CB91CE38u, 0x4ED8608Eu},
            {"-1815103278.27821147441864013671876", 0xC1DB0C11CB91CE38u, 0xCED8608Eu},
            {"1.81510327827821147441864013671874e9", 0x41DB0C11CB91CE37u, 0x4ED8608Eu},
            {"18151032782782114744186401367187501e-25", 0x41DB0C11CB91CE38u, 0x4ED8608Eu},
            {"1815103278.27821147441864013671875000000000000000000001", 0x41DB0C11CB91CE38u, 0x4ED8608Eu},
            {"-1.81510327827821147441864013671875000000000000000000000000000000e9", 0xC1DB0C11CB91CE38u, 0xCED8608Eu},
            {"18151032782782114e-7", 0x41DB0C11CB91CE37u, 0x4ED8608Eu},
            {"1815103278.2782115", 0x41DB0C11CB91CE38u, 0x4ED8608Eu},
            {"1815103278.278211474", 0x41DB0C11CB91CE37u, 0x4ED8608Eu},
            {"-1.815103278278211475e9", 0xC1DB0C11CB91CE38u, 0xCED8608Eu},
            {"1.8151032782782114744e9", 0x41DB0C11CB91CE37u, 0x4ED8608Eu},
            {"-18151032782782114745e-10", 0xC1DB0C11CB91CE38u, 0xCED8608Eu},
            {"181510327827821147441e-11", 0x41DB0C11CB91CE37u, 0x4ED8608Eu},
            {"1815103278.27821147442", 0x41DB0C11CB91CE38u, 0x4ED8608Eu},
            {"1815103278.27821147441864013671", 0x41DB0C11CB91CE37u, 0x4ED8608Eu},
            {"1.81510327827821147441864013672e9", 0x41DB0C11CB91CE38u, 0x4ED8608Eu},
            {"3809325632181785344", 0x43CA6EB8BD69FE2Au, 0x5E5375C6u},
            {"3.809325632181785345e18", 0x43CA6EB8BD69FE2Au, 0x5E5375C6u},
            {"3809325632181785343e0", 0x43CA6EB8BD69FE29u, 0x5E5375C6u},
            {"3809325632181785344.01", 0x43CA6EB8BD69FE2Au, 0x5E5375C6u},
            {"3.809325632181785344000000000000000000001e18", 0x43CA6EB8BD69FE2Au, 0x5E5375C6u},
            {"3809325632181785344000000000000000000000000000000e-30", 0x43CA6EB8BD69FE2Au, 0x5E5375C6u},
            {"3809325632181785300", 0x43CA6EB8BD69FE29u, 0x5E5375C6u},
            {"3.8093256321817854e18", 0x43CA6EB8BD69FE2Au, 0x5E5375C6u},
            {"4.046966549916366943359375e12", 0x428D7210076CE2F0u, 0x546B9080u},
            {"4046966549916366943359376e-12", 0x428D7210076CE2F0u, 0x546B9080u},
            {"4046966549916.366943359374", 0x428D7210076CE2EFu, 0x546B9080u},
            {"4.04696654991636694335937501e12", 0x428D7210076CE2F0u, 0x546B9080u},
            {"4046966549916366943359375000000000000000000001e-33", 0x428D7210076CE2F0u, 0x546B9080u},
            {"-4046966549916.366943359375000000000000000000000000000000", 0xC28D7210076CE2F0u, 0xD46B9080u},
            {"4.0469665499163669e12", 0x428D7210076CE2EFu, 0x546B9080u},
            {"4046966549916367e-3", 0x428D7210076CE2F0u, 0x546B9080u},
            {"4046966549916366943e-6", 0x428D7210076CE2EFu, 0x546B9080u},
            {"4046966549916.366944", 0x428D7210076CE2F0u, 0x546B9080u},
            {"4046966549916.3669433", 0x428D7210076CE2EFu, 0x546B9080u},
            {"4.0469665499163669434e12", 0x428D7210076CE2F0u, 0x546B9080u},
            {"-4.04696654991636694335e12", 0xC28D7210076CE2EFu, 0xD46B9080u},
            {"404696654991636694336e-8", 0x428D7210076CE2F0u, 0x546B9080u},
            {"28093802557000874e154", 0x63529C3B77330BDBu, 0x7F800000u},
            {"0.28093802557000875E+171", 0x63529C3B77330BDCu, 0x7F800000u},
            {"0.2809380255700087447E+171", 0x63529C3B77330BDBu, 0x7F800000u},
            {"2.809380255700087448e170", 0x63529C3B77330BDCu, 0x7F800000u},
            {"2.8093802557000874472e170", 0x63529C3B77330BDBu, 0x7F800000u},
            {"28093802557000874473e151", 0x63529C3B77330BDCu, 0x7F800000u},
            {"280938025570008744728e150", 0x63529C3B77330BDBu, 0x7F800000u},
            {"-0.280938025570008744729E+171", 0xE3529C3B77330BDCu, 0xFF800000u},
            {"-0.280938025570008744728403667979E+171", 0xE3529C3B77330BDBu, 0xFF800000u},
            {"2.8093802557000874472840366798e170", 0x63529C3B77330BDCu, 0x7F800000u},
            {"0.39523280297734525e-154", 0x1FE0F51BF17FD374u, 0x00000000u},
            {"-3.9523280297734526e-155", 0x9FE0F51BF17FD375u, 0x80000000u},
            {"3.952328029773452547e-155", 0x1FE0F51BF17FD374u, 0x00000000u},
            {"3952328029773452548e-173", 0x1FE0F51BF17FD375u, 0x00000000u},
            {"-39523280297734525478e-174", 0x9FE0F51BF17FD374u, 0x80000000u},
            {"0.39523280297734525479e-154", 0x1FE0F51BF17FD375u, 0x00000000u},
            {"-0.395232802977345254787e-154", 0x9FE0F51BF17FD374u, 0x80000000u},
            {"-3.95232802977345254788e-155", 0x9FE0F51BF17FD375u, 0x80000000u},
            {"-3.95232802977345254787245825501e-155", 0x9FE0F51BF17FD374u, 0x80000000u},
            {"395232802977345254787245825502e-184", 0x1FE0F51BF17FD375u, 0x00000000u},
            {"-1.0790205420931879e-276", 0x86A3209CA6233255u, 0x80000000u},
            {"-1079020542093188e-291", 0x86A3209CA6233256u, 0x80000000u},
            {"-1079020542093187947e-294", 0x86A3209CA6233255u, 0x80000000u},
            {"0.1079020542093187948e-275", 0x06A3209CA6233256u, 0x00000000u},
            {"0.1079020542093187947e-275", 0x06A3209CA6233255u, 0x00000000u},
            {"1.0790205420931879471e-276", 0x06A3209CA6233256u, 0x00000000u},
            {"1.07902054209318794701e-276", 0x06A3209CA6233255u, 0x00000000u},
            {"-107902054209318794702e-296", 0x86A3209CA6233256u, 0x80000000u},
            {"107902054209318794701153285302e-305", 0x06A3209CA6233255u, 0x00000000u},
            {"-0.107902054209318794701153285303e-275", 0x86A3209CA6233256u, 0x80000000u},
            {"58530471071351308e-228", 0x1413B446E6A16A3Bu, 0x00000000u},
            {"-0.58530471071351309e-211", 0x9413B446E6A16A3Cu, 0x80000000u},
            {"0.5853047107135130893e-211", 0x1413B446E6A16A3Bu, 0x00000000u},
            {"-5.853047107135130894e-212", 0x9413B446E6A16A3Cu, 0x80000000u},
            {"5.853047107135130893e-212", 0x1413B446E6A16A3Bu, 0x00000000u},
            {"58530471071351308931e-231", 0x1413B446E6A16A3Cu, 0x00000000u},
            {"-585304710713513089304e-232", 0x9413B446E6A16A3Bu, 0x80000000u},
            {"0.585304710713513089305e-211", 0x1413B446E6A16A3Cu, 0x00000000u},
            {"-0.585304710713513089304248824438e-211", 0x9413B446E6A16A3Bu, 0x80000000u},
            {"5.85304710713513089304248824439e-212", 0x1413B446E6A16A3Cu, 0x00000000u},
            {"0.19334214893983531e-78", 0x2F96ECBF1CFB10F6u, 0x00000000u},
            {"1.9334214893983532e-79", 0x2F96ECBF1CFB10F7u, 0x00000000u},
            {"1.933421489398353102e-79", 0x2F96ECBF1CFB10F6u, 0x00000000u},
            {"1933421489398353103e-97", 0x2F96ECBF1CFB10F7u, 0x00000000u},
            {"19334214893983531023e-98", 0x2F96ECBF1CFB10F6u, 0x00000000u},
            {"0.19334214893983531024e-78", 0x2F96ECBF1CFB10F7u, 0x00000000u},
            {"0.193342148939835310231e-78", 0x2F96ECBF1CFB10F6u, 0x00000000u},
            {"1.93342148939835310232e-79", 0x2F96ECBF1CFB10F7u, 0x00000000u},
            {"-1.93342148939835310231359014704e-79", 0xAF96ECBF1CFB10F6u, 0x80000000u},
            {"193342148939835310231359014705e-108", 0x2F96ECBF1CFB10F7u, 0x00000000u},
            {"2.9873358928024455e227", 0x6F2938807814E8A2u, 0x7F800000u},
            {"29873358928024456e211", 0x6F2938807814E8A3u, 0x7F800000u},
            {"298733589280244551e210", 0x6F2938807814E8A2u, 0x7F800000u},
            {"0.2987335892802445511E+228", 0x6F2938807814E8A3u, 0x7F800000u},
            {"0.29873358928024455109E+228", 0x6F2938807814E8A2u, 0x7F800000u},
            {"2.987335892802445511e227", 0x6F2938807814E8A3u, 0x7F800000u},
            {"-2.98733589280244551098e227", 0xEF2938807814E8A2u, 0xFF800000u},
            {"-298733589280244551099e207", 0xEF2938807814E8A3u, 0xFF800000u},
            {"298733589280244551098081559931e198", 0x6F2938807814E8A2u, 0x7F800000u},
            {"0.298733589280244551098081559932E+228", 0x6F2938807814E8A3u, 0x7F800000u},
            {"7.0064923216240853e-46", 0x3690000000000000u, 0x00000000u},
            {"70064923216240854e-62", 0x3690000000000000u, 0x00000001u},
            {"7006492321624085354e-64", 0x3690000000000000u, 0x00000000u},
            {"-0.7006492321624085355e-45", 0xB690000000000000u, 0x80000001u},
            {"0.70064923216240853546e-45", 0x3690000000000000u, 0x00000000u},
            {"7.0064923216240853547e-46", 0x3690000000000000u, 0x00000001u},
            {"7.00649232162408535461e-46", 0x3690000000000000u, 0x00000000u},
            {"-700649232162408535462e-66", 0xB690000000000000u, 0x80000001u},
            {"-700649232162408535461864791644e-75", 0xB690000000000000u, 0x80000000u},
            {"0.700649232162408535461864791645e-45", 0x3690000000000000u, 0x00000001u},
            {"21019476964872256e-61", 0x36A8000000000000u, 0x00000001u},
            {"0.21019476964872257e-44", 0x36A8000000000000u, 0x00000002u},
            {"-0.2101947696487225606e-44", 0xB6A8000000000000u, 0x80000001u},
            {"-2.101947696487225607e-45", 0xB6A8000000000000u, 0x80000002u},
            {"2.1019476964872256063e-45", 0x36A8000000000000u, 0x00000001u},
            {"21019476964872256064e-64", 0x36A8000000000000u, 0x00000002u},
            {"-210194769648722560638e-65", 0xB6A8000000000000u, 0x80000001u},
            {"-0.210194769648722560639e-44", 0xB6A8000000000000u, 0x80000002u},
            {"-0.210194769648722560638559437493e-44", 0xB6A8000000000000u, 0x80000001u},
            {"2.10194769648722560638559437494e-45", 0x36A8000000000000u, 0x00000002u},
            {"0.11754941406275178e-37", 0x380FFFFFA0000000u, 0x007FFFFEu},
            {"1.1754941406275179e-38", 0x380FFFFFA0000000u, 0x007FFFFFu},
            {"-1.175494140627517859e-38", 0xB80FFFFFA0000000u, 0x807FFFFEu},
            {"117549414062751786e-55", 0x380FFFFFA0000000u, 0x007FFFFFu},
            {"-11754941406275178592e-57", 0xB80FFFFFA0000000u, 0x807FFFFEu},
            {"0.11754941406275178593e-37", 0x380FFFFFA0000000u, 0x007FFFFFu},
            {"0.117549414062751785924e-37", 0x380FFFFFA0000000u, 0x007FFFFEu},
            {"1.17549414062751785925e-38", 0x380FFFFFA0000000u, 0x007FFFFFu},
            {"-1.17549414062751785924617589866e-38", 0xB80FFFFFA0000000u, 0x807FFFFEu},
            {"117549414062751785924617589867e-67", 0x380FFFFFA0000000u, 0x007FFFFFu},
            {"1.1754942807573642e-38", 0x380FFFFFDFFFFFFFu, 0x007FFFFFu},
            {"11754942807573643e-54", 0x380FFFFFE0000000u, 0x00800000u},
            {"1175494280757364291e-56", 0x380FFFFFE0000000u, 0x007FFFFFu},
            {"0.1175494280757364292e-37", 0x380FFFFFE0000000u, 0x00800000u},
            {"0.11754942807573642917e-37", 0x380FFFFFE0000000u, 0x007FFFFFu},
            {"-1.1754942807573642918e-38", 0xB80FFFFFE0000000u, 0x80800000u},
            {"-1.17549428075736429172e-38", 0xB80FFFFFE0000000u, 0x807FFFFFu},
            {"-117549428075736429173e-58", 0xB80FFFFFE0000000u, 0x80800000u},
            {"117549428075736429172788299103e-67", 0x380FFFFFE0000000u, 0x007FFFFFu},
            {"0.117549428075736429172788299104e-37", 0x380FFFFFE0000000u, 0x00800000u},
            {"11754944208872107e-54", 0x3810000010000000u, 0x00800000u},
            {"-0.11754944208872108e-37", 0xB810000010000000u, 0x80800001u},
            {"0.1175494420887210724e-37", 0x3810000010000000u, 0x00800000u},
            {"1.175494420887210725e-38", 0x3810000010000000u, 0x00800001u},
            {"1.1754944208872107242e-38", 0x3810000010000000u, 0x00800000u},
            {"-11754944208872107243e-57", 0xB810000010000000u, 0x80800001u},
            {"-11754944208872107242e-57", 0xB810000010000000u, 0x80800000u},
            {"0.117549442088721072421e-37", 0x3810000010000000u, 0x00800001u},
            {"0.11754944208872107242095900834e-37", 0x3810000010000000u, 0x00800000u},
            {"-1.17549442088721072420959008341e-38", 0xB810000010000000u, 0x80800001u},
            {"340282336497324057985868971510891282432", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
            {"-3.40282336497324057985868971510891282433e38", 0xC7EFFFFFD0000000u, 0xFF7FFFFFu},
            {"340282336497324057985868971510891282431e0", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
            {"340282336497324057985868971510891282432.01", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
            {"3.40282336497324057985868971510891282432000000000000000000001e38", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
            {"340282336497324057985868971510891282432000000000000000000000000000000e-30", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
            {"340282336497324050000000000000000000000", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
            {"3.4028233649732406e38", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
            {"3.402823364973240579e38", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
            {"340282336497324058e21", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
            {"34028233649732405798e19", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
            {"340282336497324057990000000000000000000", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
            {"340282336497324057985000000000000000000", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
            {"3.40282336497324057986e38", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
            {"3.4028233649732405798586897151e38", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
            {"340282336497324057985868971511e9", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
            {"3.40282356779733661637539395458142568448e38", 0x47EFFFFFF0000000u, 0x7F800000u},
            {"-340282356779733661637539395458142568449e0", 0xC7EFFFFFF0000000u, 0xFF800000u},
            {"340282356779733661637539395458142568447", 0x47EFFFFFF0000000u, 0x7F7FFFFFu},
            {"3.4028235677973366163753939545814256844801e38", 0x47EFFFFFF0000000u, 0x7F800000u},
            {"340282356779733661637539395458142568448000000000000000000001e-21", 0x47EFFFFFF0000000u, 0x7F800000u},
            {"340282356779733661637539395458142568448.000000000000000000000000000000", 0x47EFFFFFF0000000u, 0x7F800000u},
            {"3.4028235677973366e38", 0x47EFFFFFF0000000u, 0x7F7FFFFFu},
            {"-34028235677973367e22", 0xC7EFFFFFF0000000u, 0xFF800000u},
            {"3402823567797336616e20", 0x47EFFFFFF0000000u, 0x7F7FFFFFu},
            {"340282356779733661700000000000000000000", 0x47EFFFFFF0000000u, 0x7F800000u},
            {"340282356779733661630000000000000000000", 0x47EFFFFFF0000000u, 0x7F7FFFFFu},
            {"3.4028235677973366164e38", 0x47EFFFFFF0000000u, 0x7F800000u},
            {"3.40282356779733661637e38", 0x47EFFFFFF0000000u, 0x7F7FFFFFu},
            {"340282356779733661638e18", 0x47EFFFFFF0000000u, 0x7F800000u},
            {"-340282356779733661637539395458e9", 0xC7EFFFFFF0000000u, 0xFF7FFFFFu},
            {"340282356779733661637539395459000000000", 0x47EFFFFFF0000000u, 0x7F800000u},
            {"-1000000059604644775390625e-24", 0xBFF0000010000000u, 0xBF800000u},
            {"-1.000000059604644775390626", 0xBFF0000010000000u, 0xBF800001u},
            {"-1.000000059604644775390624e0", 0xBFF0000010000000u, 0xBF800000u},
            {"100000005960464477539062501e-26", 0x3FF0000010000000u, 0x3F800001u},
            {"1.000000059604644775390625000000000000000000001", 0x3FF0000010000000u, 0x3F800001u},
            {"1.000000059604644775390625000000000000000000000000000000e0", 0x3FF0000010000000u, 0x3F800000u},
            {"-10000000596046447e-16", 0xBFF0000010000000u, 0xBF800000u},
            {"1.0000000596046448", 0x3FF0000010000000u, 0x3F800001u},
            {"1.000000059604644775", 0x3FF0000010000000u, 0x3F800000u},
            {"-1.000000059604644776e0", 0xBFF0000010000000u, 0xBF800001u},
            {"-1.0000000596046447753e0", 0xBFF0000010000000u, 0xBF800000u},
            {"10000000596046447754e-19", 0x3FF0000010000000u, 0x3F800001u},
            {"100000005960464477539e-20", 0x3FF0000010000000u, 0x3F800000u},
            {"-1.0000000596046447754", 0xBFF0000010000000u, 0xBF800001u},
            {"0.9999999701976776123046875", 0x3FEFFFFFF0000000u, 0x3F800000u},
            {"9.999999701976776123046876e-1", 0x3FEFFFFFF0000000u, 0x3F800000u},
            {"9999999701976776123046874e-25", 0x3FEFFFFFF0000000u, 0x3F7FFFFFu},
            {"0.999999970197677612304687501", 0x3FEFFFFFF0000000u, 0x3F800000u},
            {"-9.999999701976776123046875000000000000000000001e-1", 0xBFEFFFFFF0000000u, 0xBF800000u},
            {"-9999999701976776123046875000000000000000000000000000000e-55", 0xBFEFFFFFF0000000u, 0xBF800000u},
            {"0.99999997019767761", 0x3FEFFFFFF0000000u, 0x3F7FFFFFu},
            {"-9.9999997019767762e-1", 0xBFEFFFFFF0000000u, 0xBF800000u},
            {"-9.999999701976776123e-1", 0xBFEFFFFFF0000000u, 0xBF7FFFFFu},
            {"9999999701976776124e-19", 0x3FEFFFFFF0000000u, 0x3F800000u},
            {"9999999701976776123e-19", 0x3FEFFFFFF0000000u, 0x3F7FFFFFu},
            {"0.99999997019767761231", 0x3FEFFFFFF0000000u, 0x3F800000u},
            {"-0.999999970197677612304", 0xBFEFFFFFF0000000u, 0xBF7FFFFFu},
            {"9.99999970197677612305e-1", 0x3FEFFFFFF0000000u, 0x3F800000u},
            {"-1.6777217e7", 0xC170000010000000u, 0xCB800000u},
            {"16777218e0", 0x4170000020000000u, 0x4B800001u},
            {"16777216", 0x4170000000000000u, 0x4B800000u},
            {"-1.677721701e7", 0xC17000001028F5C3u, 0xCB800001u},
            {"-16777217000000000000000000001e-21", 0xC170000010000000u, 0xCB800001u},
            {"16777217.000000000000000000000000000000", 0x4170000010000000u, 0x4B800000u},
            {"167772155e-1", 0x416FFFFFF0000000u, 0x4B800000u},
            {"16777215.6", 0x416FFFFFF3333333u, 0x4B800000u},
            {"1.67772154e7", 0x416FFFFFECCCCCCDu, 0x4B7FFFFFu},
            {"16777215501e-3", 0x416FFFFFF0083127u, 0x4B800000u},
            {"-16777215.5000000000000000000001", 0xC16FFFFFF0000000u, 0xCB800000u},
            {"-1.67772155000000000000000000000000000000e7", 0xC16FFFFFF0000000u, 0xCB800000u},
            {"0.1000000052154064178466796875", 0x3FB99999B0000000u, 0x3DCCCCCEu},
            {"1.000000052154064178466796876e-1", 0x3FB99999B0000000u, 0x3DCCCCCEu},
            {"-1000000052154064178466796874e-28", 0xBFB99999B0000000u, 0xBDCCCCCDu},
            {"0.100000005215406417846679687501", 0x3FB99999B0000000u, 0x3DCCCCCEu},
            {"1.000000052154064178466796875000000000000000000001e-1", 0x3FB99999B0000000u, 0x3DCCCCCEu},
            {"-1000000052154064178466796875000000000000000000000000000000e-58", 0xBFB99999B0000000u, 0xBDCCCCCEu},
            {"-0.10000000521540641", 0xBFB99999AFFFFFFFu, 0xBDCCCCCDu},
            {"-1.0000000521540642e-1", 0xBFB99999B0000000u, 0xBDCCCCCEu},
            {"1.000000052154064178e-1", 0x3FB99999B0000000u, 0x3DCCCCCDu},
            {"-1000000052154064179e-19", 0xBFB99999B0000000u, 0xBDCCCCCEu},
            {"10000000521540641784e-20", 0x3FB99999B0000000u, 0x3DCCCCCDu},
            {"0.10000000521540641785", 0x3FB99999B0000000u, 0x3DCCCCCEu},
            {"0.100000005215406417846", 0x3FB99999B0000000u, 0x3DCCCCCDu},
            {"1.00000005215406417847e-1", 0x3FB99999B0000000u, 0x3DCCCCCEu},
            {"5.429001220703125e3", 0x40B5350050000000u, 0x45A9A802u},
            {"-5429001220703126e-12", 0xC0B5350050000001u, 0xC5A9A803u},
            {"-5429.001220703124", 0xC0B535004FFFFFFFu, 0xC5A9A802u},
            {"5.42900122070312501e3", 0x40B5350050000000u, 0x45A9A803u},
            {"5429001220703125000000000000000000001e-33", 0x40B5350050000000u, 0x45A9A803u},
            {"-5429.001220703125000000000000000000000000000000", 0xC0B5350050000000u, 0xC5A9A802u},
            {"503719056e0", 0x41BE062490000000u, 0x4DF03124u},
            {"503719057", 0x41BE062491000000u, 0x4DF03125u},
            {"5.03719055e8", 0x41BE06248F000000u, 0x4DF03124u},
            {"50371905601e-2", 0x41BE062490028F5Cu, 0x4DF03125u},
            {"503719056.000000000000000000001", 0x41BE062490000000u, 0x4DF03125u},
            {"5.03719056000000000000000000000000000000e8", 0x41BE062490000000u, 0x4DF03124u},
            {"-92331620", 0xC196037990000000u, 0xCCB01BCCu},
            {"9.233163e7", 0x41960379B8000000u, 0x4CB01BCEu},
            {"9233161e1", 0x4196037968000000u, 0x4CB01BCBu},
            {"92331620.1", 0x4196037990666666u, 0x4CB01BCDu},
            {"9.233162000000000000000000001e7", 0x4196037990000000u, 0x4CB01BCDu},
            {"9233162000000000000000000000000000000e-29", 0x4196037990000000u, 0x4CB01BCCu},
            {"3.002458625e6", 0x4146E82D50000000u, 0x4A37416Au},
            {"3002458626e-3", 0x4146E82D5020C49Cu, 0x4A37416Bu},
            {"3002458.624", 0x4146E82D4FDF3B64u, 0x4A37416Au},
            {"-3.00245862501e6", 0xC146E82D500053E3u, 0xCA37416Bu},
            {"3002458625000000000000000000001e-24", 0x4146E82D50000000u, 0x4A37416Bu},
            {"3002458.625000000000000000000000000000000", 0x4146E82D50000000u, 0x4A37416Au},
            {"-1095485584696182596504479582065262592e1", 0xC7A07BA830000000u, 0xFD03DD42u},
            {"10954855846961825965044795820652625930", 0x47A07BA830000000u, 0x7D03DD42u},
            {"1.095485584696182596504479582065262591e37", 0x47A07BA830000000u, 0x7D03DD41u},
            {"109548558469618259650447958206526259201e-1", 0x47A07BA830000000u, 0x7D03DD42u},
            {"-10954855846961825965044795820652625920.00000000000000000001", 0xC7A07BA830000000u, 0xFD03DD42u},
            {"1.095485584696182596504479582065262592000000000000000000000000000000e37", 0x47A07BA830000000u, 0x7D03DD42u},
            {"10954855846961825e21", 0x47A07BA830000000u, 0x7D03DD41u},
            {"10954855846961826000000000000000000000", 0x47A07BA830000000u, 0x7D03DD42u},
            {"10954855846961825960000000000000000000", 0x47A07BA830000000u, 0x7D03DD41u},
            {"1.095485584696182597e37", 0x47A07BA830000000u, 0x7D03DD42u},
            {"1.0954855846961825965e37", 0x47A07BA830000000u, 0x7D03DD41u},
            {"-10954855846961825966e18", 0xC7A07BA830000000u, 0xFD03DD42u},
            {"10954855846961825965e18", 0x47A07BA830000000u, 0x7D03DD41u},
            {"10954855846961825965100000000000000000", 0x47A07BA830000000u, 0x7D03DD42u},
            {"10954855846961825965044795820600000000", 0x47A07BA830000000u, 0x7D03DD41u},
            {"-1.09548558469618259650447958207e37", 0xC7A07BA830000000u, 0xFD03DD42u},
            {"1.6449216019182103706535606608388384863861375606575165875256061553955078126e-21", 0x3B9F125A50000000u, 0x1CF892D3u},
            {"-16449216019182103706535606608388384863861375606575165875256061553955078124e-94", 0xBB9F125A50000000u, 0x9CF892D2u},
            {"-0.0000000000000000000016449216019182103", 0xBB9F125A50000000u, 0x9CF892D2u},
            {"-1.6449216019182104e-21", 0xBB9F125A50000000u, 0x9CF892D3u},
            {"-1.64492160191821037e-21", 0xBB9F125A50000000u, 0x9CF892D2u},
            {"-1644921601918210371e-39", 0xBB9F125A50000000u, 0x9CF892D3u},
            {"-16449216019182103706e-40", 0xBB9F125A50000000u, 0x9CF892D2u},
            {"0.0000000000000000000016449216019182103707", 0x3B9F125A50000000u, 0x1CF892D3u},
            {"0.00000000000000000000164492160191821037065", 0x3B9F125A50000000u, 0x1CF892D2u},
            {"1.64492160191821037066e-21", 0x3B9F125A50000000u, 0x1CF892D3u},
            {"1.64492160191821037065356066083e-21", 0x3B9F125A50000000u, 0x1CF892D2u},
            {"164492160191821037065356066084e-50", 0x3B9F125A50000000u, 0x1CF892D3u},
            {"6.565061509609222412109375e-1", 0x3FE5021930000000u, 0x3F2810CAu},
            {"6565061509609222412109376e-25", 0x3FE5021930000000u, 0x3F2810CAu},
            {"0.6565061509609222412109374", 0x3FE5021930000000u, 0x3F2810C9u},
            {"6.56506150960922241210937501e-1", 0x3FE5021930000000u, 0x3F2810CAu},
            {"6565061509609222412109375000000000000000000001e-46", 0x3FE5021930000000u, 0x3F2810CAu},
            {"-0.6565061509609222412109375000000000000000000000000000000", 0xBFE5021930000000u, 0xBF2810CAu},
            {"6.5650615096092224e-1", 0x3FE5021930000000u, 0x3F2810C9u},
            {"-65650615096092225e-17", 0xBFE5021930000000u, 0xBF2810CAu},
            {"6565061509609222412e-19", 0x3FE5021930000000u, 0x3F2810C9u},
            {"0.6565061509609222413", 0x3FE5021930000000u, 0x3F2810CAu},
            {"0.65650615096092224121", 0x3FE5021930000000u, 0x3F2810C9u},
            {"6.5650615096092224122e-1", 0x3FE5021930000000u, 0x3F2810CAu},
            {"-6.5650615096092224121e-1", 0xBFE5021930000000u, 0xBF2810C9u},
            {"656506150960922241211e-21", 0x3FE5021930000000u, 0x3F2810CAu},
            {"18014627239033005156980393746124491372029297053813934326171875e-77", 0x3CA9F63970000000u, 0x254FB1CCu},
            {"0.00000000000000018014627239033005156980393746124491372029297053813934326171876", 0x3CA9F63970000000u, 0x254FB1CCu},
            {"-1.8014627239033005156980393746124491372029297053813934326171874e-16", 0xBCA9F63970000000u, 0xA54FB1CBu},
            {"1801462723903300515698039374612449137202929705381393432617187501e-79", 0x3CA9F63970000000u, 0x254FB1CCu},
            {"18014627239033005e-32", 0x3CA9F63970000000u, 0x254FB1CBu},
            {"0.00000000000000018014627239033006", 0x3CA9F63970000000u, 0x254FB1CCu},
            {"0.0000000000000001801462723903300515", 0x3CA9F63970000000u, 0x254FB1CBu},
            {"-1.801462723903300516e-16", 0xBCA9F63970000000u, 0xA54FB1CCu},
            {"-1.8014627239033005156e-16", 0xBCA9F63970000000u, 0xA54FB1CBu},
            {"18014627239033005157e-35", 0x3CA9F63970000000u, 0x254FB1CCu},
            {"180146272390330051569e-36", 0x3CA9F63970000000u, 0x254FB1CBu},
            {"-0.00000000000000018014627239033005157", 0xBCA9F63970000000u, 0xA54FB1CCu},
            {"0.000000000000000180146272390330051569803937461", 0x3CA9F63970000000u, 0x254FB1CBu},
            {"1.80146272390330051569803937462e-16", 0x3CA9F63970000000u, 0x254FB1CCu},
            {"0.05534819327294826507568359375", 0x3FAC569930000000u, 0x3D62B4CAu},
            {"-5.534819327294826507568359376e-2", 0xBFAC569930000000u, 0xBD62B4CAu},
            {"5534819327294826507568359374e-29", 0x3FAC569930000000u, 0x3D62B4C9u},
            {"-0.0553481932729482650756835937501", 0xBFAC569930000000u, 0xBD62B4CAu},
            {"5.534819327294826507568359375000000000000000000001e-2", 0x3FAC569930000000u, 0x3D62B4CAu},
            {"5534819327294826507568359375000000000000000000000000000000e-59", 0x3FAC569930000000u, 0x3D62B4CAu},
            {"0.055348193272948265", 0x3FAC569930000000u, 0x3D62B4C9u},
            {"5.5348193272948266e-2", 0x3FAC569930000000u, 0x3D62B4CAu},
            {"5.534819327294826507e-2", 0x3FAC569930000000u, 0x3D62B4C9u},
            {"5534819327294826508e-20", 0x3FAC569930000000u, 0x3D62B4CAu},
            {"55348193272948265075e-21", 0x3FAC569930000000u, 0x3D62B4C9u},
            {"-0.055348193272948265076", 0xBFAC569930000000u, 0xBD62B4CAu},
            {"0.0553481932729482650756", 0x3FAC569930000000u, 0x3D62B4C9u},
            {"-5.53481932729482650757e-2", 0xBFAC569930000000u, 0xBD62B4CAu},
            {"5.179692133247783258005389047985340416e36", 0x478F2C9450000000u, 0x7C7964A2u},
            {"5179692133247783258005389047985340417e0", 0x478F2C9450000000u, 0x7C7964A3u},
            {"5179692133247783258005389047985340415", 0x478F2C9450000000u, 0x7C7964A2u},
            {"-5.17969213324778325800538904798534041601e36", 0xC78F2C9450000000u, 0xFC7964A3u},
            {"-5179692133247783258005389047985340416000000000000000000001e-21", 0xC78F2C9450000000u, 0xFC7964A3u},
            {"-5179692133247783258005389047985340416.000000000000000000000000000000", 0xC78F2C9450000000u, 0xFC7964A2u},
            {"5.1796921332477832e36", 0x478F2C9450000000u, 0x7C7964A2u},
            {"51796921332477833e20", 0x478F2C9450000000u, 0x7C7964A3u},
            {"-5179692133247783258e18", 0xC78F2C9450000000u, 0xFC7964A2u},
            {"5179692133247783259000000000000000000", 0x478F2C9450000000u, 0x7C7964A3u},
            {"5179692133247783258000000000000000000", 0x478F2C9450000000u, 0x7C7964A2u},
            {"5.1796921332477832581e36", 0x478F2C9450000000u, 0x7C7964A3u},
            {"-5.179692133247783258e36", 0xC78F2C9450000000u, 0xFC7964A2u},
            {"-517969213324778325801e16", 0xC78F2C9450000000u, 0xFC7964A3u},
            {"517969213324778325800538904798e7", 0x478F2C9450000000u, 0x7C7964A2u},
            {"5179692133247783258005389047990000000", 0x478F2C9450000000u, 0x7C7964A3u},
            {
                "0.22250738585072011360574097967091319759348195463516456480234261097248222220210769455165295239081350"
                "8791414915891303962110687008643869459464552765720740782062174337998814106326732925355228688137214901"
                "2981122451451889849057222307285255133155755015914397476397983411801999323962548289017107081850690630"
                "6666559949382757725720157630626906633326475653000092458883164330377797918696120494973903778297049050"
                "5108060994073026293712895895000358379996720725430436028407889577179615094551674824347103070260914462"
                "1572289880258182545180325707018860872113128079512233426288368622321503775666622503982534335974568884"
                "4239002654981983854879482922068947216898310996983658468140228542433306603398508864458040010349339704"
                "2756718644338377048603786162277173854562306587467901408672332763671875e-307", 0x0010000000000000u, 0x00000000u
            },
            {
                "2.22507385850720113605740979670913197593481954635164564802342610972482222202107694551652952390813508"
                "7914149158913039621106870086438694594645527657207407820621743379988141063267329253552286881372149012"
                "9811224514518898490572223072852551331557550159143974763979834118019993239625482890171070818506906306"
                "6665599493827577257201576306269066333264756530000924588831643303777979186961204949739037782970490505"
                "1080609940730262937128958950003583799967207254304360284078895771796150945516748243471030702609144621"
                "5722898802581825451803257070188608721131280795122334262883686223215037756666225039825343359745688844"
                "2390026549819838548794829220689472168983109969836584681402285424333066033985088644580400103493397042"
                "756718644338377048603786162277173854562306587467901408672332763671875000000000000000000001e-308", 0x0010000000000000u, 0x00000000u
            },
            {
                "0.11754942807573642917278829910357665133228589927589904276829631184250030649651730385585324256680905"
                "8189392089843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
                "00000000000000000000000000000000000000000000000000000000000000000e-37", 0x380FFFFFE0000000u, 0x00800000u
            },
            {
                "1175494280757364291727882991035766513322858992758990427682963118425003064965173038558532425668090581"
                "8939208984375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
                "00000000000001e-751", 0x380FFFFFE0000000u, 0x00800000u
            },
            {"0", 0x0000000000000000u, 0x00000000u},
            {"-0", 0x8000000000000000u, 0x80000000u},
            {"0.0", 0x0000000000000000u, 0x00000000u},
            {"-0.0", 0x8000000000000000u, 0x80000000u},
            {"0e999999999999999999999", 0x0000000000000000u, 0x00000000u},
            {"-0.000e-99999", 0x8000000000000000u, 0x80000000u},
            {"1e-400", 0x0000000000000000u, 0x00000000u},
            {"-1e-400", 0x8000000000000000u, 0x80000000u},
            {"1e400", 0x7FF0000000000000u, 0x7F800000u},
            {"-1e400", 0xFFF0000000000000u, 0xFF800000u},
            {"1e-50", 0x358DEE7A4AD4B81Fu, 0x00000000u},
            {"-1e-50", 0xB58DEE7A4AD4B81Fu, 0x80000000u},
            {"1e39", 0x48078287F49C4A1Du, 0x7F800000u},
            {"-1e39", 0xC8078287F49C4A1Du, 0xFF800000u},
            {"1e99999999999999999999999999", 0x7FF0000000000000u, 0x7F800000u},
            {"1e-99999999999999999999999999", 0x0000000000000000u, 0x00000000u},
            {"1e0000000000000000000000000000000000000000308", 0x7FE1CCF385EBC8A0u, 0x7F800000u},
            {"123456789012345678901234567890e-30", 0x3FBF9ADD3746F65Fu, 0x3DFCD6EAu},
            {"18446744073709551615", 0x43F0000000000000u, 0x5F800000u},
            {"18446744073709551616", 0x43F0000000000000u, 0x5F800000u},
            {"-9223372036854775808", 0xC3E0000000000000u, 0xDF000000u},
            {"-9223372036854775809", 0xC3E0000000000000u, 0xDF000000u},
        }
    };
    return table;
 }
 } // namespace float_hard_cases
@@ -38,7 +38,7 @@ TEST_CASE("Binary Formats")
        const auto ubjson_2_size = json::to_ubjson(j, true).size();
        const auto ubjson_3_size = json::to_ubjson(j, true, true).size();
-        CHECK(json_size == 2090234);
+        CHECK(json_size == 2090303);
        CHECK(bjdata_1_size == 1112030);
        CHECK(bjdata_2_size == 1224148);
        CHECK(bjdata_3_size == 1224148);
@@ -51,16 +51,16 @@ TEST_CASE("Binary Formats")
        CHECK(ubjson_3_size == 1169069);
        CHECK((100.0 * double(json_size) / double(json_size)) == Approx(100.0));
-        CHECK((100.0 * double(bjdata_1_size) / double(json_size)) == Approx(53.201));
+        CHECK((100.0 * double(bjdata_1_size) / double(json_size)) == Approx(53.199));
-        CHECK((100.0 * double(bjdata_2_size) / double(json_size)) == Approx(58.565));
+        CHECK((100.0 * double(bjdata_2_size) / double(json_size)) == Approx(58.563));
-        CHECK((100.0 * double(bjdata_3_size) / double(json_size)) == Approx(58.565));
+        CHECK((100.0 * double(bjdata_3_size) / double(json_size)) == Approx(58.563));
-        CHECK((100.0 * double(bon8_size) / double(json_size)) == Approx(50.511));
+        CHECK((100.0 * double(bon8_size) / double(json_size)) == Approx(50.509));
-        CHECK((100.0 * double(bson_size) / double(json_size)) == Approx(85.853));
+        CHECK((100.0 * double(bson_size) / double(json_size)) == Approx(85.849));
-        CHECK((100.0 * double(cbor_size) / double(json_size)) == Approx(50.499));
+        CHECK((100.0 * double(cbor_size) / double(json_size)) == Approx(50.497));
-        CHECK((100.0 * double(msgpack_size) / double(json_size)) == Approx(50.528));
+        CHECK((100.0 * double(msgpack_size) / double(json_size)) == Approx(50.526));
-        CHECK((100.0 * double(ubjson_1_size) / double(json_size)) == Approx(53.201));
+        CHECK((100.0 * double(ubjson_1_size) / double(json_size)) == Approx(53.199));
-        CHECK((100.0 * double(ubjson_2_size) / double(json_size)) == Approx(58.565));
+        CHECK((100.0 * double(ubjson_2_size) / double(json_size)) == Approx(58.563));
-        CHECK((100.0 * double(ubjson_3_size) / double(json_size)) == Approx(55.930));
+        CHECK((100.0 * double(ubjson_3_size) / double(json_size)) == Approx(55.928));
    }
    SECTION("twitter.json")
@@ -13,20 +13,16 @@
 using nlohmann::json;
 #include <array> // array
 #include <cfloat> // FLT_EVAL_METHOD
 #include <cstdint> // uint32_t, uint64_t
 #include <cstdio> // snprintf
 #include <cstdlib> // strtod
 #include <cstring> // memcpy
 #include <limits> // numeric_limits
 #include <map> // map
 #include <random> // mt19937
 #include <sstream> // stringstream
 #include <string> // string
 #include <utility> // pair
 #include <vector> // vector
 #include "float_hard_cases.hpp"
 namespace
 {
 // shortcut to scan a string literal
@@ -262,7 +258,7 @@ TEST_CASE("lexer number fast path")
            "123456789012345678901234567890",  // huge -> float
            "0.30000000000000004", "2.2250738585072014e-308", "1e308",
            // high-precision / wide-exponent values that exercise the
-            // Eisel-Lemire path beyond the Clinger subset
+            // std::from_chars (Eisel-Lemire) path beyond the Clinger subset
            "1.7976931348623157e308", "1.2345678901234567e-250",
            "9007199254740993", "5e-324", "1e-320"
        };
@@ -284,18 +280,20 @@ TEST_CASE("lexer number fast path")
        }
    }
-    SECTION("significant digits around Clinger's fast path")
+    SECTION("significant-digit gate for the Clinger fast path")
    {
-        // Clinger's fast path needs a significand of at most 2^53, which
+        // Clinger's fast path needs a significand below 2^53, so it cannot
-        // tokens with 17 or more significant digits exceed. The conversion
+        // succeed once the mantissa has 17 or more significant digits (the
-        // splits the token at the positions the scanners recorded, so leading
+        // significand would be at least 10^16). The lexer skips the attempt
-        // zeros must not count as digits - "0.1234567890123456" has 16
+        // there. That is only allowed to save work: every value must still come
-        // significant digits, not 17 - and both scanners must agree.
+        // out bit-exactly, and both scanners must agree. In particular the gate
        // must not fire for tokens whose leading zeros merely look like extra
        // digits - "0.1234567890123456" has 16 significant digits, not 17.
        const std::vector<std::string> numbers =
        {
            "1234567890123456",                  // 16 significant digits
-            "12345678901234567",                 // 17
+            "12345678901234567",                 // 17 -> attempt skipped
-            "123456789012345678",                // 18
+            "123456789012345678",                // 18 -> attempt skipped
            "0.1234567890123456",                // 16: the leading "0" is not significant
            "0.12345678901234567",               // 17
            "0.00000000000000001",               // 1, in a long token
@@ -666,323 +664,46 @@ TEST_CASE("lexer string fast path")
    }
 }
-TEST_CASE("lexer escape fast path")
+TEST_CASE("parse_float_fast declines what it cannot convert exactly")
 {
-    // json::accept() never throws, so this section stays covered without
+    // The lexer only hands well-formed numbers to parse_float_fast, so the
-    // exceptions; it pins which of the cases below are valid/invalid and
+    // malformed ones below can only be passed to it directly. Declining is
-    // checks the contiguous and streaming paths agree on that classification.
+    // always safe: the caller then falls back to a slower, exact conversion.
-    SECTION("accept() parity")
+    const auto fast = [](const std::string & s, double & out)
    {
-        const std::vector<std::pair<std::string, bool>> cases =
+        return nlohmann::detail::parse_float_fast(s.data(), s.data() + s.size(), out);
        {
            {"\\u0041", true}, {"\\u00e4", true}, {"\\u00E4", true},
            {"\\uD83D\\uDE00", true},
            {"\\u12", false}, {"\\u12G4", false}, {"\\uXYZW", false},
            {"\\uD800", false}, {"\\uD800A", false}, {"\\uD800\\u0041", false},
            {"\\uDC00", false}, {"\\u", false}
    };
    double out = 0;
-        for (const auto& c : cases)
+#if defined(FLT_EVAL_METHOD) && FLT_EVAL_METHOD != 0
-        {
+    // without true double precision, the fast path declines everything
-            for (const std::size_t offset :
+    CHECK_FALSE(fast("1.5", out));
-                    {
+#else
-                        std::size_t{0}, std::size_t{9}
+    CHECK(fast("1.5", out));
-                    })
+    CHECK(out == 1.5);
-            {
+    CHECK(fast("+2.5e1", out));
-                const std::string doc = "[\"" + std::string(offset, 'a') + c.first + "\"]";
+    CHECK(out == 25.0);
-                CAPTURE(doc)
+    CHECK(fast("-25E-1", out));
-                CHECK(json::accept(doc) == c.second);
+    CHECK(out == -2.5);
-                std::stringstream ss(doc);
+    CHECK(fast("1e", out));
-                CHECK(json::accept(ss) == c.second);
+    CHECK(out == 1.0);
            }
        }
    }
 #if !defined(JSON_NOEXCEPTION)
    // the full outcome of parsing @a doc: the parsed value, or the exact
    // error message, so a mismatch in either is caught
    const auto outcome = [](const std::string & doc, bool streaming) -> std::string
    {
        try
        {
            if (streaming)
            {
                std::stringstream ss(doc);
                const json j = json::parse(ss);
                return j.dump();
            }
            const json j = json::parse(doc);
            return j.dump();
        }
        catch (const json::exception& e)
        {
            return {e.what()};
        }
    };
    SECTION("contiguous vs streaming parity")
    {
        const std::vector<std::string> escapes =
        {
            "\\u0041",             // "A"
            "\\u00e4",             // "ä" (lowercase hex)
            "\\u00E4",             // "ä" (uppercase hex)
            "\\uD83D\\uDE00",      // valid surrogate pair (an emoji)
            "\\u12",               // truncated: only 2 hex digits before the closing quote
            "\\u12G4",             // invalid hex digit at the 3rd position
            "\\uXYZW",             // all 4 bytes invalid
            "\\uD800",             // lone high surrogate, string ends right after
            "\\uD800A",            // high surrogate not followed by another \u escape
            "\\uD800\\u0041",      // high surrogate followed by \u, but not a low surrogate
            "\\uDC00",             // lone low surrogate
            "\\u",                 // '\u' with nothing after (closing quote right away)
        };
        // once at the start of the string and once past the first 8-byte SWAR
        // word of the outer string_bulk_run, so the escape is reached both
        // right after the opening quote and mid-run
        for (const auto& escape : escapes)
        {
            for (const std::size_t offset :
                    {
                        std::size_t{0}, std::size_t{9}
                    })
            {
                const std::string doc = "[\"" + std::string(offset, 'a') + escape + "\"]";
                CAPTURE(doc)
                CHECK(outcome(doc, false) == outcome(doc, true));
            }
            // the escape is the last thing before end of input: no closing
            // quote at all
            const std::string truncated_doc = "[\"" + escape;
            CAPTURE(truncated_doc)
            CHECK(outcome(truncated_doc, false) == outcome(truncated_doc, true));
        }
    }
    SECTION("truncated \\u escape at every distance from the end of input")
    {
        // ia.bulk_remaining() must correctly report fewer than 4 bytes for
        // every possible count of trailing hex-looking bytes (0, 1, 2, or 3)
        // before end of input, so the fast path declines and the byte path
        // alone reports the "must be followed by 4 hex digits" error, at the
        // same position, in every case
        for (const std::string& tail :
                {
                    std::string{}, std::string("1"), std::string("12"), std::string("123")
                })
        {
            const std::string doc = "[\"\\u" + tail;
            CAPTURE(doc)
            CHECK(outcome(doc, false) == outcome(doc, true));
            CHECK(outcome(doc, false).find("must be followed by 4 hex digits") != std::string::npos);
        }
    }
    SECTION("invalid hex digit at every position of the 4")
    {
        // the fast path must decline for *any* invalid byte among the 4, not
        // just the first, and the byte path must then stop at exactly that
        // position - same as it always has
        for (std::size_t bad_pos = 0; bad_pos < 4; ++bad_pos)
        {
            std::string digits = "1234";
            digits[bad_pos] = 'g'; // not a hex digit
            const std::string doc = "[\"\\u" + digits + "\"]";
            CAPTURE(doc)
            CHECK(outcome(doc, false) == outcome(doc, true));
            CHECK(outcome(doc, false).find("must be followed by 4 hex digits") != std::string::npos);
        }
    }
    SECTION("random escapes")
    {
        // A seeded PRNG builds the 4 bytes following `\u` from a mix of hex
        // digits and non-hex bytes, at varying distances from the start of
        // the string, to compare the two scanners on many more shapes than
        // are practical to enumerate by hand.
        std::mt19937 gen(7654321); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
        const std::string hex_alphabet = "0123456789AaBbCcDdEeFf";
        std::uniform_int_distribution<std::size_t> pick_hex(0, hex_alphabet.size() - 1);
        std::uniform_int_distribution<int> pick_byte(1, 255); // never NUL
        std::uniform_int_distribution<int> pick_is_hex(0, 4); // 4-in-5 chance of a hex digit
        std::uniform_int_distribution<std::size_t> pick_offset(0, 12);
        std::vector<std::string> mismatches;
        for (int iter = 0; iter < 3000; ++iter)
        {
            std::string digits;
            for (int i = 0; i < 4; ++i)
            {
                if (pick_is_hex(gen) != 0)
                {
                    digits += hex_alphabet[pick_hex(gen)];
                }
                else
                {
                    char c = static_cast<char>(pick_byte(gen));
                    if (c == '"' || c == '\\')
                    {
                        // keep the string well-formed apart from the escape
                        // itself, so any mismatch is attributable to the \u
                        // handling and not to an unrelated quote/escape
                        c = 'z';
                    }
                    digits += c;
                }
            }
            const std::string doc = "[\"" + std::string(pick_offset(gen), 'a') + "\\u" + digits + "\"]";
            if (outcome(doc, false) != outcome(doc, true))
            {
                mismatches.push_back(doc);
            }
        }
        CAPTURE(mismatches)
        CHECK(mismatches.empty());
    }
 #endif
 }
-namespace
+    // not a number
-{
+    CHECK_FALSE(fast("", out));
-// the index of the decimal point (or npos) and of the end of the mantissa of a
+    CHECK_FALSE(fast("-", out));
-// number token, which the lexer records while scanning it
+    CHECK_FALSE(fast(".", out));
-std::pair<std::size_t, std::size_t> float_token_layout(const std::string& s)
+    CHECK_FALSE(fast("1.2.3", out));
-{
+    CHECK_FALSE(fast("1x", out));
-    std::size_t dot = std::string::npos;
+    CHECK_FALSE(fast("1e+", out));
-    std::size_t mantissa_end = s.size();
+    CHECK_FALSE(fast("1e1x", out));
    for (std::size_t i = 0; i < s.size(); ++i)
    {
        if (s[i] == '.')
        {
            dot = i;
        }
        else if (s[i] == 'e' || s[i] == 'E')
        {
            mantissa_end = i;
            break;
        }
    }
    return {dot, mantissa_end};
 }
-template<typename FloatType>
+    // numbers that are not represented exactly on the fast path
-FloatType parse_native(const std::string& s)
+    CHECK_FALSE(fast("12345678901234567890", out));
-{
+    CHECK_FALSE(fast("1e10000", out));
-    const auto layout = float_token_layout(s);
+    CHECK_FALSE(fast("9007199254740993", out));
-    return nlohmann::detail::parse_float_native<FloatType>(s.data(), s.data() + s.size(), layout.first, layout.second);
+    CHECK_FALSE(fast("1e23", out));
-}
+    CHECK_FALSE(fast("1e-23", out));
 std::uint64_t bits_of(double d)
 {
    std::uint64_t b = 0;
    std::memcpy(&b, &d, sizeof(b));
    return b;
 }
 std::uint32_t bits_of(float f)
 {
    std::uint32_t b = 0;
    std::memcpy(&b, &f, sizeof(b));
    return b;
 }
 std::uint64_t native_bits64(const std::string& s)
 {
    return bits_of(parse_native<double>(s));
 }
 std::uint32_t native_bits32(const std::string& s)
 {
    return bits_of(parse_native<float>(s));
 }
 } // namespace
 TEST_CASE("parse_float_native rounds correctly")
 {
    SECTION("double")
    {
        CHECK(native_bits64("1.5") == 0x3FF8000000000000u);
        CHECK(native_bits64("0.1") == 0x3FB999999999999Au);
        CHECK(native_bits64("-0.0") == 0x8000000000000000u);
        CHECK(native_bits64("0e999999999999999999999") == 0u);
        // 2^53 + 1 is exactly between two doubles: ties to even, unless more digits follow
        CHECK(native_bits64("9007199254740993") == 0x4340000000000000u);
        CHECK(native_bits64("9007199254740993.0000000000000000001") == 0x4340000000000001u);
        CHECK(native_bits64("9007199254740992.9999999999999999999") == 0x4340000000000000u);
        // 1 + 2^-53 exactly (a tie), and one unit in the 55th digit around it
        CHECK(native_bits64("1.00000000000000011102230246251565404236316680908203125") == 0x3FF0000000000000u);
        CHECK(native_bits64("1.00000000000000011102230246251565404236316680908203126") == 0x3FF0000000000001u);
        CHECK(native_bits64("1.00000000000000011102230246251565404236316680908203124") == 0x3FF0000000000000u);
        // subnormal and overflow boundaries
        CHECK(native_bits64("2.4703282292062327e-324") == 0u);
        CHECK(native_bits64("2.4703282292062328e-324") == 1u);
        CHECK(native_bits64("2.2250738585072011e-308") == 0x000FFFFFFFFFFFFFu);
        CHECK(native_bits64("2.2250738585072012e-308") == 0x0010000000000000u);
        CHECK(native_bits64("1.7976931348623157e308") == 0x7FEFFFFFFFFFFFFFu);
        CHECK(native_bits64("1.7976931348623159e308") == 0x7FF0000000000000u);
        CHECK(native_bits64("-1e400") == 0xFFF0000000000000u);
        CHECK(native_bits64("-1e-400") == 0x8000000000000000u);
        // exponents and zeros far beyond the range cancel out
        CHECK(native_bits64("0." + std::string(1000, '0') + "1e1001") == 0x3FF0000000000000u);
        CHECK(native_bits64("1" + std::string(1000, '0') + "e-1000") == 0x3FF0000000000000u);
        CHECK(native_bits64("1e-99999999999999999999999") == 0u);
        CHECK(native_bits64("1E+99999999999999999999999") == 0x7FF0000000000000u);
        // more digits than any midpoint has (769): only whether a nonzero digit follows matters
        const std::string tie = "1.00000000000000011102230246251565404236316680908203125";
        CHECK(native_bits64(tie + std::string(800, '0')) == 0x3FF0000000000000u);
        CHECK(native_bits64(tie + std::string(800, '0') + "1") == 0x3FF0000000000001u);
    }
    SECTION("float")
    {
        CHECK(native_bits32("1.5") == 0x3FC00000u);
        CHECK(native_bits32("0.1") == 0x3DCCCCCDu);
        CHECK(native_bits32("-0.0") == 0x80000000u);
        // 2^24 + 1 is exactly between two floats
        CHECK(native_bits32("16777217") == 0x4B800000u);
        CHECK(native_bits32("16777217.000000000000000000001") == 0x4B800001u);
        CHECK(native_bits32("16777218.999999999999999999999") == 0x4B800001u);
        CHECK(native_bits32("16777219") == 0x4B800002u);
        // subnormal and overflow boundaries
        CHECK(native_bits32("3.4028235677973366e38") == 0x7F7FFFFFu);
        CHECK(native_bits32("3.4028235677973367e38") == 0x7F800000u);
        CHECK(native_bits32("7.006492321624085e-46") == 0u);
        CHECK(native_bits32("7.006492321624086e-46") == 1u);
        CHECK(native_bits32("1.1754942e-38") == 0x007FFFFFu);
        CHECK(native_bits32("-1.17549435e-38") == 0x80800000u);
        CHECK(native_bits32("1e39") == 0x7F800000u);
        CHECK(native_bits32("-1e-50") == 0x80000000u);
        // not rounded through double: its double would round to another float
        CHECK(native_bits32("1.00000005960464477539062500000000001") == 0x3F800001u);
        CHECK(native_bits32("9007199254740993") == 0x5A000000u);
    }
    SECTION("the conversion shared with other parsers")
    {
        // convert_float() gives the lexer's results, for every type
        const std::vector<std::string> tokens =
        {
            "0", "-0.0", "1.5", "0.1", "1e-400", "-2.5E+3", "123456789012345678901234567890",
            "9007199254740993.0000000000000000001", "4.9406564584124654e-324"
        };
        using float_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
        using long_double_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, long double>;
        for (const auto& t : tokens)
        {
            CAPTURE(t)
            const auto layout = float_token_layout(t);
            const char* const first = t.data();
            const char* const last = first + t.size();
            const auto d = nlohmann::detail::convert_float<double>(first, last, layout.first, layout.second);
            const auto f = nlohmann::detail::convert_float<float>(first, last, layout.first, layout.second);
            const auto ld = nlohmann::detail::convert_float<long double>(first, last, layout.first, layout.second);
            CHECK(bits_of(d) == bits_of(json::parse(t).get<double>()));
            CHECK(bits_of(f) == bits_of(float_json::parse(t).get<float>()));
            CHECK(ld == long_double_json::parse(t).get<long double>());
        }
    }
 }
 namespace
@@ -1086,6 +807,40 @@ std::size_t big_bit_length(const big_uint& a)
    }
    return n;
 }
 std::uint64_t bits_of(double d)
 {
    std::uint64_t b = 0;
    std::memcpy(&b, &d, sizeof(b));
    return b;
 }
 bool eisel_lemire(const std::string& s, double& out)
 {
    return nlohmann::detail::parse_float_eisel_lemire(s.data(), s.data() + s.size(), out);
 }
 // significant digits of a token, without trailing zeros
 std::size_t significant_digits(const std::string& s)
 {
    std::string digits;
    for (const char c : s)
    {
        if (c == 'e' || c == 'E')
        {
            break;
        }
        if (c >= '0' && c <= '9' && !(digits.empty() && c == '0'))
        {
            digits += c;
        }
    }
    while (!digits.empty() && digits.back() == '0')
    {
        digits.pop_back();
    }
    return digits.size();
 }
 } // namespace
 TEST_CASE("Eisel-Lemire float conversion")
@@ -1517,33 +1272,26 @@ TEST_CASE("Eisel-Lemire float conversion")
        for (const auto& c : known)
        {
            CAPTURE(c.first)
-            CHECK(native_bits64(c.first) == c.second);
+            double out = 0;
-        }
+            if (eisel_lemire(c.first, out))
    }
    SECTION("binary32")
            {
-        using binary32 = nlohmann::detail::ieee_binary_format<24>;
+                CHECK(bits_of(out) == c.second);
-        CHECK(nlohmann::detail::eisel_lemire<binary32>(0, 1) == 0x3F800000u);
+            }
-        CHECK(nlohmann::detail::eisel_lemire<binary32>(-1, 1) == 0x3DCCCCCDu);
+            else
-        CHECK(nlohmann::detail::eisel_lemire<binary32>(-1, 15) == 0x3FC00000u);
+            {
-        CHECK(nlohmann::detail::eisel_lemire<binary32>(0, 16777217) == 0x4B800000u); // tie, to even
+                // only tokens with more than 19 significant digits are left to
-        CHECK(nlohmann::detail::eisel_lemire<binary32>(0, 16777219) == 0x4B800002u); // tie, to even
+                // strtod: those whose value lies too close to a tie
-        CHECK(nlohmann::detail::eisel_lemire<binary32>(-45, 1) == 0x00000001u);
+                CHECK(significant_digits(c.first) > 19);
-        CHECK(nlohmann::detail::eisel_lemire<binary32>(-46, 7) == 0x00000000u);
+            }
-        CHECK(nlohmann::detail::eisel_lemire<binary32>(-46, 8) == 0x00000001u);
+        }
        CHECK(nlohmann::detail::eisel_lemire<binary32>(-65, 9999999999999999999u) == 0x00000000u);
        CHECK(nlohmann::detail::eisel_lemire<binary32>(20, 3402823466385288598u) == 0x7F7FFFFFu);
        CHECK(nlohmann::detail::eisel_lemire<binary32>(20, 3402823669209384635u) == 0x7F800000u);
        CHECK(nlohmann::detail::eisel_lemire<binary32>(39, 1) == 0x7F800000u);
        CHECK(nlohmann::detail::eisel_lemire<binary32>(-5, 0) == 0x00000000u);
    }
    SECTION("round trip")
    {
-        // every double written by to_chars and read back, and its 17-digit
+        // every double written by to_chars and read back, also with trailing
-        // form with trailing digits that make the token longer than 19 digits
+        // digits that make the token longer than 19 digits
        std::uint64_t state = 5295;
        std::size_t declined = 0;
        for (int i = 0; i < 200000; ++i)
        {
            state ^= state << 13u;
@@ -1565,51 +1313,30 @@ TEST_CASE("Eisel-Lemire float conversion")
            const char* end = nlohmann::detail::to_chars(buffer.data(), buffer.data() + buffer.size(), d);
            const std::string token(buffer.data(), static_cast<std::size_t>(end - buffer.data()));
            CAPTURE(token)
-            CHECK(native_bits64(token) == b);
+            double out = 0;
            REQUIRE(eisel_lemire(token, out));
            CHECK(bits_of(out) == b);
-            // insert digits before the exponent of the 17-digit form: that
+            // insert digits before the exponent: the value moves by far less
-            // form lies strictly inside the rounding interval of the double
+            // than the distance to the rounding boundary, so it must not change
-            // (the shortest one may lie on its boundary), and the digits move
+            std::string longer = token;
            // it by far less than the distance to the boundary, so the value
            // must not change
            std::array<char, 64> digits17{};
            static_cast<void>(std::snprintf(digits17.data(), digits17.size(), "%.17g", d)); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
            std::string longer = digits17.data();
            const std::size_t e = longer.find('e');
            const std::size_t dot = longer.find('.');
            const std::string extra = dot == std::string::npos ? ".000000000000000000001" : "000000000000000000001";
            longer.insert(e == std::string::npos ? longer.size() : e, extra);
            CAPTURE(longer)
-            CHECK(native_bits64(longer) == b);
+            if (eisel_lemire(longer, out))
        }
    }
    SECTION("round trip, binary32")
            {
-        std::uint32_t state = 5295;
+                CHECK(bits_of(out) == b);
        for (int i = 0; i < 100000; ++i)
        {
            state ^= state << 13u;
            state ^= state >> 17u;
            state ^= state << 5u;
            std::uint32_t b = state;
            if ((b & 0x7F800000u) == 0x7F800000u)
            {
                continue; // infinity or NaN
            }
-            if (i % 4 == 0)
+            else
            {
-                b &= 0x807FFFFFu; // subnormals
+                // w and w + 1 round differently: only when the value is very
                // close to a rounding boundary
                ++declined;
            }
            float f = 0;
            std::memcpy(&f, &b, sizeof(f));
            std::array<char, 64> buffer{};
            const char* end = nlohmann::detail::to_chars(buffer.data(), buffer.data() + buffer.size(), f);
            const std::string token(buffer.data(), static_cast<std::size_t>(end - buffer.data()));
            CAPTURE(token)
            CHECK(native_bits32(token) == b);
        }
        CHECK(declined < 1000); // 107 of the 200,000
    }
    SECTION("used by the lexer")
@@ -1623,184 +1350,3 @@ TEST_CASE("Eisel-Lemire float conversion")
                             "[json.exception.out_of_range.406] number overflow parsing '1.7976931348623159e308'", json::out_of_range&);
    }
 }
 namespace
 {
 using float_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
 // the bits of the float that parse() gives for a token, via both scanners;
 // the value must be the same for both
 template<typename Json, typename Bits>
 void check_parse(const std::string& token, Bits expected, Bits infinity)
 {
    std::stringstream stream(token);
    if ((expected & ~(Bits{1} << ((8 * sizeof(Bits)) - 1))) == infinity)
    {
        Json _;
        CHECK_THROWS_WITH_AS(_ = Json::parse(token), ("[json.exception.out_of_range.406] number overflow parsing '" + token + "'").c_str(), typename Json::out_of_range&);
        CHECK_THROWS_WITH_AS(_ = Json::parse(stream), ("[json.exception.out_of_range.406] number overflow parsing '" + token + "'").c_str(), typename Json::out_of_range&);
        return;
    }
    const Json contiguous = Json::parse(token);
    const Json streamed = Json::parse(stream);
    if (contiguous.is_number_float()) // not an integer that fits
    {
        CHECK(bits_of(contiguous.template get<typename Json::number_float_t>()) == expected);
        CHECK(bits_of(streamed.template get<typename Json::number_float_t>()) == expected);
    }
    else
    {
        CHECK(streamed.is_number_integer());
    }
 }
 } // namespace
 TEST_CASE("float conversion of hard cases")
 {
    // see float_hard_cases.hpp
    for (const auto& c : float_hard_cases::cases())
    {
        const std::string token = c.token;
        CAPTURE(token)
        CHECK(native_bits64(token) == c.bits64);
        CHECK(native_bits32(token) == c.bits32);
        check_parse<json>(token, c.bits64, std::uint64_t{0x7FF0000000000000u});
        check_parse<float_json>(token, c.bits32, std::uint32_t{0x7F800000u});
    }
 }
 TEST_CASE("float overflow and underflow in the parser")
 {
    SECTION("double")
    {
        check_parse<json>("1.7976931348623157e308", std::uint64_t{0x7FEFFFFFFFFFFFFFu}, std::uint64_t{0x7FF0000000000000u});
        check_parse<json>("1.7976931348623159e308", std::uint64_t{0x7FF0000000000000u}, std::uint64_t{0x7FF0000000000000u});
        check_parse<json>("-1e309", std::uint64_t{0xFFF0000000000000u}, std::uint64_t{0x7FF0000000000000u});
        check_parse<json>("1" + std::string(400, '0'), std::uint64_t{0x7FF0000000000000u}, std::uint64_t{0x7FF0000000000000u});
        check_parse<json>("1e99999999999999999999", std::uint64_t{0x7FF0000000000000u}, std::uint64_t{0x7FF0000000000000u});
        // an underflow gives a zero with the sign of the token
        check_parse<json>("1e-400", std::uint64_t{0}, std::uint64_t{0x7FF0000000000000u});
        check_parse<json>("-1e-400", std::uint64_t{0x8000000000000000u}, std::uint64_t{0x7FF0000000000000u});
        check_parse<json>("-2.4703282292062327e-324", std::uint64_t{0x8000000000000000u}, std::uint64_t{0x7FF0000000000000u});
        check_parse<json>("0." + std::string(400, '0') + "1", std::uint64_t{0}, std::uint64_t{0x7FF0000000000000u});
    }
    SECTION("float")
    {
        check_parse<float_json>("3.4028234e38", std::uint32_t{0x7F7FFFFFu}, std::uint32_t{0x7F800000u});
        check_parse<float_json>("3.4028236e38", std::uint32_t{0x7F800000u}, std::uint32_t{0x7F800000u});
        check_parse<float_json>("-1e39", std::uint32_t{0xFF800000u}, std::uint32_t{0x7F800000u});
        check_parse<float_json>("1e-46", std::uint32_t{0}, std::uint32_t{0x7F800000u});
        check_parse<float_json>("-1e-46", std::uint32_t{0x80000000u}, std::uint32_t{0x7F800000u});
        check_parse<float_json>("-7.006492321624085e-46", std::uint32_t{0x80000000u}, std::uint32_t{0x7F800000u});
        check_parse<float_json>("-7.006492321624086e-46", std::uint32_t{0x80000001u}, std::uint32_t{0x7F800000u});
    }
 }
 TEST_CASE("string scanning kernels")
 {
    // the word-at-a-time kernels must stop exactly where a byte-by-byte scan
    // stops, for any content, length, and alignment
    const auto reference_special = [](const unsigned char* data, std::size_t n)
    {
        std::size_t i = 0;
        while (i < n && !nlohmann::detail::is_string_special(data[i]))
        {
            ++i;
        }
        return i;
    };
    const auto reference_copyable = [](const unsigned char* data, std::size_t n)
    {
        std::size_t i = 0;
        while (i < n && nlohmann::detail::is_ascii_copyable(data[i]))
        {
            ++i;
        }
        return i;
    };
    const auto reference_bulk_run = [](const unsigned char* data, std::size_t n)
    {
        std::size_t i = 0;
        while (i < n)
        {
            if (data[i] < 0x80u)
            {
                if (nlohmann::detail::is_string_special(data[i]))
                {
                    break;
                }
                ++i;
                continue;
            }
            const std::size_t seq = nlohmann::detail::validate_one_utf8(data + i, n - i);
            if (seq == 0)
            {
                break;
            }
            i += seq;
        }
        return i;
    };
    // pieces: ordinary ASCII, stops, DEL, well-formed sequences of every
    // length, and ill-formed or truncated ones
    const std::vector<std::string> pieces =
    {
        "a", "Z", " ", "~", "0123456789", "\"", "\\", std::string(1, '\0'), "\n", "\x1F", "\x7F",
        "\xC3\xA4", "\xE2\x82\xAC", "\xE6\x97\xA5\xE6\x9C\xAC", "\xF0\x9F\x98\x80", "\xED\x9F\xBF",
        "\x80", "\xC0\x80", "\xC3", "\xE2\x82", "\xED\xA0\x80", "\xF4\x90\x80\x80", "\xFF",
    };
    std::uint64_t state = 5295;
    const auto next = [&state]()
    {
        state ^= state << 13u;
        state ^= state >> 7u;
        state ^= state << 17u;
        return state;
    };
    // the upper half as a 32-bit value: converts to std::size_t implicitly on
    // every platform (a cast of std::uint64_t is useless where both are the
    // same type, and required where std::size_t is 32 bits wide)
    const auto next_small = [&next]()
    {
        return static_cast<std::uint32_t>(next() >> 32u);
    };
    for (int round = 0; round < 100000; ++round)
    {
        // mostly ordinary text, so that runs span several words
        std::string text(next_small() % 8u, '.');
        const std::size_t count = next_small() % 12u;
        for (std::size_t k = 0; k < count; ++k)
        {
            const std::size_t p = (next() % 4 == 0) ? next_small() % pieces.size() : 0;
            text += pieces[p];
            text += std::string(next_small() % 10u, 'x');
        }
        const auto* data = reinterpret_cast<const unsigned char*>(text.data()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
        for (std::size_t offset = 0; offset < 3 && offset <= text.size(); ++offset)
        {
            const std::size_t n = text.size() - offset;
            CAPTURE(text)
            CAPTURE(offset)
            CHECK(nlohmann::detail::find_string_special(data + offset, n) == reference_special(data + offset, n));
            CHECK(nlohmann::detail::find_ascii_copyable_run(data + offset, n) == reference_copyable(data + offset, n));
            CHECK(nlohmann::detail::scalar_string_bulk_run(data + offset, n) == reference_bulk_run(data + offset, n));
        }
    }
    // the trailing-zero count, whichever implementation the compiler gets
    for (int k = 0; k < 64; ++k)
    {
        const std::uint64_t bit = std::uint64_t{1} << k;
        CHECK(nlohmann::detail::count_trailing_zeros(bit) == k);
        CHECK(nlohmann::detail::count_trailing_zeros(bit | (bit << 1u) | 0x8000000000000000u) == k);
    }
    // eight bytes as a little-endian word, at any alignment
    const std::array<unsigned char, 16> bytes = {{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF}};
    CHECK(nlohmann::detail::read_eight_bytes(bytes.data()) == 0x0807060504030201u);
    CHECK(nlohmann::detail::read_eight_bytes(bytes.data() + 1) == 0x0908070605040302u);
    CHECK(nlohmann::detail::read_eight_bytes(bytes.data() + 8) == 0xFF0F0E0D0C0B0A09u);
    CHECK(nlohmann::detail::read_eight_bytes(reinterpret_cast<const char*>(bytes.data()) + 3) == 0x0B0A090807060504u);
 }
@@ -260,11 +260,10 @@ struct LocaleSwitchingSax final: public nlohmann::json_sax<json>
 TEST_CASE("locale changes between lexer construction and number conversion (#5198)")
 {
-    // float and double are converted without the locale. A long double that
+    // The numbers are chosen so that the conversion also takes the strtod
-    // is not binary64 can take the strtold fallback, which honors the locale
+    // fallback, which honors the locale that is current at conversion time:
-    // that is current at conversion time. The numbers are chosen so that it
+    // too many significant digits for Clinger's fast path, an underflow that
-    // does: too many significant digits for Clinger's fast path, an underflow
+    // std::from_chars rejects, and a plain value.
    // that std::from_chars rejects, and a plain value.
    const std::vector<std::string> numbers = {"3.14159265358979323846", "1.5e-400", "12.34", "-0.000123456789012345678"};
    std::string text = "[";
    for (const auto& n : numbers)
@@ -328,8 +327,7 @@ TEST_CASE("locale changes between lexer construction and number conversion (#519
            }
        }
-        // a long double goes through std::strtold unless it is binary64 or
+        // a long double goes through std::strtold unless std::from_chars supports it
        // std::from_chars supports it
        {
            bool switched = false;
            const auto cb = [&](int /*depth*/, long_double_json::parse_event_t event, long_double_json& /*parsed*/) noexcept
@@ -355,15 +353,8 @@ TEST_CASE("locale with a multi-byte decimal point")
 {
    // Some locales use a decimal point that is not a single character, e.g.
    // U+066B ARABIC DECIMAL SEPARATOR (two bytes in UTF-8). It cannot be
-    // substituted in place for '.', so the strtold fallback (only for long
+    // substituted in place for '.', so the strtod fallback stops early. The
-    // double formats other than binary64) converts a copy of the token with
+    // conversion must still terminate rather than retry forever.
    // the whole decimal point instead (#5660). The values must be those of the
    // "C" locale.
    using long_double_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, long double>;
    const char* const long_double_numbers = "[3.14159265358979323846, 1.5e-400, -0.000123456789012345678]";
    REQUIRE(std::setlocale(LC_NUMERIC, "C") != nullptr);
    const long_double_json expected_long_double = long_double_json::parse(long_double_numbers);
    const std::array<const char*, 6> names = {{"ar_EG.UTF-8", "ar_SA.UTF-8", "fa_IR.UTF-8", "ps_AF.UTF-8", "ar_EG", "fa_IR"}};
    bool tested = false;
    for (const char* name : names)
@@ -381,20 +372,12 @@ TEST_CASE("locale with a multi-byte decimal point")
        tested = true;
        // too many significant digits for Clinger's fast path, and an underflow
-        // that std::from_chars rejects: double does not depend on the locale
+        // that std::from_chars rejects: both reach the strtod fallback
        json j;
        CHECK_NOTHROW(j = json::parse("[3.14159265358979323846, 1.5e-400, -0.000123456789012345678]"));
        CHECK(j.is_array());
        CHECK(j[0] == 3.14159265358979323846);
        CHECK(j[1] == 0.0);
        CHECK(j[2] == -0.000123456789012345678);
        CHECK(json::accept("3.14159265358979323846"));
        // a long double that reaches the strtold fallback is not truncated
        long_double_json ld;
        CHECK_NOTHROW(ld = long_double_json::parse(long_double_numbers));
        CHECK(ld == expected_long_double);
        // a value the locale-independent paths convert is not affected
        CHECK(json::parse("12.5") == 12.5);
    }
@@ -20,8 +20,11 @@
 using nlohmann::json;
 #include <array>
 #include <cstdint>
 #include <sstream>
 #include <iomanip>
 #include <string>
 #include <vector>
 #include "test_utils.hpp"
@@ -923,66 +926,68 @@ TEST_CASE("serialization boundary values for the string buffer")
    // mid-string once fewer than 13 bytes remain (`string_buffer.size() - bytes
    // < 13`), 13 being one more than the most a single code point can ever
    // write at once (a surrogate pair: two back-to-back "\uXXXX" escapes, 12
-    // bytes). Every write into string_buffer that this check protects happens
+    // bytes). Characters below 0x60 (control characters, '"' and '\\') are
-    // in steps of 2 (a simple "\\x" escape) or 6 (one "\uXXXX" unit), so
+    // escaped straight into the write buffer and never reach string_buffer, so
-    // `bytes` only ever takes even values at the point the check runs - the
+    // under ensure_ascii it fills in steps of 6 (one "\uXXXX" unit for a
-    // tightest values actually reachable are therefore 498 (512 - 498 == 14,
+    // character below U+10000) or 12 (a surrogate pair). With 2-byte characters
-    // one simple escape away from the threshold) and 500 (512 - 500 == 12,
+    // such as U+00E4, `bytes` takes multiples of 6 at the point the check runs;
-    // where the flush fires immediately and resets bytes to 0).
+    // the tightest values reachable are therefore 498 (512 - 498 == 14, after
    // 83 characters) and 504 (512 - 504 == 8, after 84 characters, where the
    // flush fires immediately and resets bytes to 0).
-    SECTION("a run of 2-byte escapes lands bytes on, and one step past, the flush threshold")
+    SECTION("a run of 6-byte escapes lands bytes on, and one step past, the flush threshold")
    {
        for (const int count :
                {
-                    249, 250, 251
+                    83, 84, 85
                })
        {
            CAPTURE(count)
-            const json j = std::string(static_cast<std::size_t>(count), '\n');
+            std::string umlauts;
            std::string expected = "\"";
            for (int i = 0; i < count; ++i)
            {
-                expected += "\\n";
+                umlauts += "\xC3\xA4";
                expected += "\\u00e4";
            }
            expected += '"';
-            CHECK(j.dump() == expected);
+            CHECK(json(umlauts).dump(-1, ' ', true) == expected);
        }
    }
-    SECTION("an ASCII prefix leaves the tightest reachable margin before a 12-byte surrogate pair")
+    SECTION("a prefix leaves the tightest reachable margin before a 12-byte surrogate pair")
    {
        // U+1F600 (the "\xF0\x9F\x98\x80" UTF-8 bytes) is dumped under
        // ensure_ascii as the 12-byte surrogate pair "\ud83d\ude00"; that
        // write happens in a single step with no intermediate flush check, so
        // it is the write most exposed by an off-by-one in the "< 13" guard.
-        // A prefix of 249 newlines leaves exactly 14 bytes of headroom
+        // A prefix of 83 U+00E4 characters leaves exactly 14 bytes of headroom
        // (512 - 498), the smallest margin the guard ever actually allows
-        // into a new code point; 250 newlines instead trigger the guard's own
+        // into a new code point; 84 characters instead trigger the guard's own
        // flush first, so the emoji starts from a freshly emptied (512-byte)
-        // buffer, and 251 repeats that with one more escape already past the
+        // buffer, and 85 repeats that with one more escape already past the
        // reset. Together they cover the margin the guard allows landing on,
        // one step before, and one step after - all must still produce the
        // identical, correct escapes.
        for (const int prefix_count :
                {
-                    249, 250, 251
+                    83, 84, 85
                })
        {
            CAPTURE(prefix_count)
-            const std::string prefix(static_cast<std::size_t>(prefix_count), '\n');
+            std::string prefix;
            const std::string emoji = "\xF0\x9F\x98\x80";
            const json j = prefix + emoji;
            std::string expected_prefix;
            for (int i = 0; i < prefix_count; ++i)
            {
-                expected_prefix += "\\n";
+                prefix += "\xC3\xA4";
                expected_prefix += "\\u00e4";
            }
            const std::string emoji = "\xF0\x9F\x98\x80";
            const json j = prefix + emoji;
-            // newline escaping does not depend on ensure_ascii: only the
+            // without ensure_ascii, the whole string is copied unchanged
            // emoji differs (raw UTF-8 bytes vs. a \u-escaped surrogate pair)
            std::string expected_raw = "\"";
-            expected_raw += expected_prefix;
+            expected_raw += prefix;
            expected_raw += emoji;
            expected_raw += '"';
            std::string expected_ascii = "\"";
@@ -1027,3 +1032,524 @@ TEST_CASE("serialization boundary values for the string buffer")
        }
    }
 }
 namespace
 {
 // appends the escaped form of the ASCII character c to out; written
 // independently of the table in serializer::ascii_escapes()
 void append_escaped_ascii(std::string& out, const char c, const bool ensure_ascii)
 {
    const auto byte = static_cast<unsigned char>(c);
    switch (byte)
    {
        case '\b':
            out += "\\b";
            break;
        case '\t':
            out += "\\t";
            break;
        case '\n':
            out += "\\n";
            break;
        case '\f':
            out += "\\f";
            break;
        case '\r':
            out += "\\r";
            break;
        case '"':
            out += "\\\"";
            break;
        case '\\':
            out += "\\\\";
            break;
        default:
            if (byte < 0x20 || (ensure_ascii && byte == 0x7F))
            {
                // byte < 0x80, so the first two hex digits are 0
                const char* const hex = "0123456789abcdef";
                out += "\\u00";
                out += hex[byte >> 4U];
                out += hex[byte & 0x0FU];
            }
            else
            {
                out += c;
            }
            break;
    }
 }
 // reference escaper for ASCII strings
 std::string reference_escape_ascii(const std::string& s, const bool ensure_ascii)
 {
    std::string result = "\"";
    for (const char c : s)
    {
        append_escaped_ascii(result, c, ensure_ascii);
    }
    result += '"';
    return result;
 }
 } // namespace
 TEST_CASE("characters below 0x60 are escaped from a table straight into the write buffer")
 {
    SECTION("every ASCII character at every position")
    {
        // lengths up to 17 cover the 8-byte strides of the bulk scanner on
        // both sides of the character, so the scanner stops at it from every
        // offset
        for (std::size_t length = 1; length <= 17; ++length)
        {
            for (std::size_t pos = 0; pos < length; ++pos)
            {
                for (unsigned int c = 0; c < 0x80; ++c)
                {
                    std::string s(length, 'a');
                    s[pos] = static_cast<char>(c);
                    CAPTURE(length)
                    CAPTURE(pos)
                    CAPTURE(c)
                    const json j = s;
                    CHECK(j.dump(-1, ' ', false) == reference_escape_ascii(s, false));
                    CHECK(j.dump(-1, ' ', true) == reference_escape_ascii(s, true));
                }
            }
        }
    }
    SECTION("runs of escaped characters")
    {
        std::string s;
        for (unsigned int c = 0; c < 0x20; ++c)
        {
            s += static_cast<char>(c);
        }
        s += R"("\"\)";
        CHECK(json(s).dump() == reference_escape_ascii(s, false));
        CHECK(json(s).dump(-1, ' ', true) == reference_escape_ascii(s, true));
    }
    SECTION("escapes straddle the end of the write buffer")
    {
        // the 8-byte store of a table entry needs room for all 8 bytes, even
        // when the escape itself is shorter; a prefix of k plain characters
        // shifts the 6-byte escapes across every offset of the 1024-byte
        // write buffer
        for (std::size_t k = 0; k < 8; ++k)
        {
            CAPTURE(k)
            const std::string s = std::string(k, 'a') + std::string(400, '\x01');
            CHECK(json(s).dump() == reference_escape_ascii(s, false));
            CHECK(json::array({s, s}).dump() == "[" + reference_escape_ascii(s, false) + "," + reference_escape_ascii(s, false) + "]");
        }
    }
    SECTION("pending \\u escapes of non-ASCII characters are written first")
    {
        // under ensure_ascii, U+00E4 is \u-escaped into the string buffer;
        // a following escape from the table must not overtake it
        const json j = "\xC3\xA4\n\xC3\xA4\"\xF0\x9F\x98\x80\\";
        CHECK(j.dump(-1, ' ', true) == "\"\\u00e4\\n\\u00e4\\\"\\ud83d\\ude00\\\\\"");
        CHECK(j.dump(-1, ' ', false) == "\"\xC3\xA4\\n\xC3\xA4\\\"\xF0\x9F\x98\x80\\\\\"");
    }
    SECTION("escapes after invalid UTF-8 for every error handler")
    {
        const json j = "a\xFF\n\xC3\"";
        CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] invalid UTF-8 byte at index 1: 0xFF", json::type_error&);
        CHECK(j.dump(-1, ' ', false, json::error_handler_t::ignore) == "\"a\\n\\\"\"");
        CHECK(j.dump(-1, ' ', true, json::error_handler_t::ignore) == "\"a\\n\\\"\"");
        CHECK(j.dump(-1, ' ', false, json::error_handler_t::replace) == "\"a\xEF\xBF\xBD\\n\xEF\xBF\xBD\\\"\"");
        CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"a\\ufffd\\n\\ufffd\\\"\"");
        CHECK(j.dump(-1, ' ', false, json::error_handler_t::keep) == "\"a\xFF\\n\xC3\\\"\"");
        CHECK(j.dump(-1, ' ', true, json::error_handler_t::keep) == "\"a\xFF\\n\xC3\\\"\"");
    }
 }
 namespace
 {
 // expected result of dumping a string: the output, or (with
 // error_handler_t::strict) the message of the type_error.316 exception
 struct expected_dump
 {
    bool throws = false;
    std::string text{}; // NOLINT(readability-redundant-member-init)
 };
 std::string upper_hex_byte(const unsigned char byte)
 {
    const char* const hex = "0123456789ABCDEF";
    return std::string(1, hex[byte >> 4U]) + hex[byte & 0x0FU];
 }
 void append_u_escape(std::string& out, const std::uint32_t code_unit)
 {
    const char* const hex = "0123456789abcdef";
    out += "\\u";
    for (int shift = 12; shift >= 0; shift -= 4)
    {
        out += hex[(code_unit >> static_cast<unsigned int>(shift)) & 0x0FU];
    }
 }
 void append_replacement_character(std::string& out, const bool ensure_ascii)
 {
    out += ensure_ascii ? "\\ufffd" : "\xEF\xBF\xBD";
 }
 // reference serializer for arbitrary byte strings, written from the documented
 // behavior of dump() and independently of serializer::dump_escaped(): UTF-8 is
 // decoded strictly (well-formed sequences as in Table 3-7 of the Unicode
 // Standard), and each ill-formed sequence is handled as the error handler says
 expected_dump reference_dump_string(const std::string& s, const bool ensure_ascii, const json::error_handler_t error_handler)
 {
    expected_dump result;
    std::string& out = result.text;
    out = "\"";
    // handle the ill-formed bytes s[begin, end), of which s[index] is the byte
    // that could not be decoded; returns false if an exception is expected
    const auto ill_formed = [&](const std::size_t begin, const std::size_t end, const std::size_t index)
    {
        switch (error_handler)
        {
            case json::error_handler_t::strict:
                result.throws = true;
                out = "[json.exception.type_error.316] invalid UTF-8 byte at index " + std::to_string(index) + ": 0x" + upper_hex_byte(static_cast<unsigned char>(s[index]));
                return false;
            case json::error_handler_t::ignore:
                break;
            case json::error_handler_t::replace:
                append_replacement_character(out, ensure_ascii);
                break;
            case json::error_handler_t::keep:
            default:
                // kept as is, even with ensure_ascii
                out.append(s, begin, end - begin);
                break;
        }
        return true;
    };
    std::size_t i = 0;
    while (i < s.size())
    {
        const auto lead = static_cast<unsigned char>(s[i]);
        if (lead < 0x80)
        {
            append_escaped_ascii(out, s[i], ensure_ascii);
            ++i;
            continue;
        }
        // number of bytes of the sequence and the range of its second byte
        std::size_t length = 0;
        std::uint32_t code_point = 0;
        unsigned char lower = 0x80;
        unsigned char upper = 0xBF;
        if (lead >= 0xC2 && lead <= 0xDF)
        {
            length = 2;
            code_point = lead & 0x1FU;
        }
        else if (lead >= 0xE0 && lead <= 0xEF)
        {
            length = 3;
            code_point = lead & 0x0FU;
            lower = (lead == 0xE0) ? 0xA0 : 0x80; // no overlong encodings
            upper = (lead == 0xED) ? 0x9F : 0xBF; // no surrogates
        }
        else if (lead >= 0xF0 && lead <= 0xF4)
        {
            length = 4;
            code_point = lead & 0x07U;
            lower = (lead == 0xF0) ? 0x90 : 0x80; // no overlong encodings
            upper = (lead == 0xF4) ? 0x8F : 0xBF; // nothing above U+10FFFF
        }
        else
        {
            // a byte that cannot start a sequence is consumed
            if (!ill_formed(i, i + 1, i))
            {
                return result;
            }
            ++i;
            continue;
        }
        std::size_t j = i + 1;
        for (; j < i + length; ++j)
        {
            if (j == s.size())
            {
                // the string ends in the middle of the sequence
                switch (error_handler)
                {
                    case json::error_handler_t::strict:
                        result.throws = true;
                        out = "[json.exception.type_error.316] incomplete UTF-8 string; last byte: 0x" + upper_hex_byte(static_cast<unsigned char>(s.back()));
                        return result;
                    case json::error_handler_t::ignore:
                        break;
                    case json::error_handler_t::replace:
                        append_replacement_character(out, ensure_ascii);
                        break;
                    case json::error_handler_t::keep:
                    default:
                        out.append(s, i, s.size() - i);
                        break;
                }
                out += '"';
                return result;
            }
            const auto byte = static_cast<unsigned char>(s[j]);
            if (byte < lower || byte > upper)
            {
                break;
            }
            code_point = (code_point << 6U) | (byte & 0x3FU);
            lower = 0x80;
            upper = 0xBF;
        }
        if (j < i + length)
        {
            // the sequence was abandoned at s[j]; that byte is read again as
            // the start of a new character
            if (!ill_formed(i, j, j))
            {
                return result;
            }
            i = j;
            continue;
        }
        if (!ensure_ascii)
        {
            out.append(s, i, length);
        }
        else if (code_point <= 0xFFFF)
        {
            append_u_escape(out, code_point);
        }
        else
        {
            append_u_escape(out, 0xD800U + ((code_point - 0x10000U) >> 10U));
            append_u_escape(out, 0xDC00U + ((code_point - 0x10000U) & 0x3FFU));
        }
        i = j;
    }
    out += '"';
    return result;
 }
 std::string hex_dump(const std::string& s)
 {
    std::string result;
    for (const char c : s)
    {
        result += upper_hex_byte(static_cast<unsigned char>(c));
        result += ' ';
    }
    return result;
 }
 // compares dump() of s with the reference for every error handler, with
 // ensure_ascii on and off; CHECKs only on a mismatch to keep the sweep fast;
 // error_handler_t::strict can be skipped where the position of the string
 // buffer does not matter, as throwing is slow on some platforms
 void check_dump_against_reference(const std::string& s, const bool with_strict = true)
 {
    const json j = s;
    const std::array<json::error_handler_t, 4> error_handlers =
    {
        {
            json::error_handler_t::strict, json::error_handler_t::ignore,
            json::error_handler_t::replace, json::error_handler_t::keep
        }
    };
    for (const auto error_handler : error_handlers)
    {
        if (!with_strict && error_handler == json::error_handler_t::strict)
        {
            continue;
        }
        for (const bool ensure_ascii :
                {
                    false, true
                })
        {
            const expected_dump expected = reference_dump_string(s, ensure_ascii, error_handler);
            expected_dump actual;
            int id = 0;
            try
            {
                actual.text = j.dump(-1, ' ', ensure_ascii, error_handler);
            }
            catch (const json::exception& e)
            {
                actual.throws = true;
                actual.text = e.what();
                id = e.id;
            }
            if (actual.throws != expected.throws || actual.text != expected.text || (actual.throws && id != 316))
            {
                const std::string input = hex_dump(s);
                CAPTURE(input)
                CAPTURE(ensure_ascii)
                CAPTURE(static_cast<int>(error_handler))
                CHECK(actual.throws == expected.throws);
                CHECK(actual.text == expected.text);
                CHECK((!actual.throws || id == 316));
            }
        }
    }
 }
 } // namespace
 TEST_CASE("invalid UTF-8 at every position is handled like the reference")
 {
    // ill-formed byte sequences; those that end in a truncated sequence are
    // also cut short by the filler that follows, or by the end of the string
    const std::vector<std::string> patterns =
    {
        // stray continuation bytes
        "\x80", "\xBF",
        // bytes that cannot start a sequence
        "\xC0", "\xC1", "\xF5", "\xF6", "\xF7", "\xF8", "\xF9", "\xFA", "\xFB", "\xFC", "\xFD", "\xFE", "\xFF",
        // overlong encodings
        "\xC0\xAF", "\xE0\x80\x80", "\xF0\x80\x80\x80",
        // UTF-16 surrogates
        "\xED\xA0\x80", "\xED\xBF\xBF",
        // a code point above U+10FFFF
        "\xF4\x90\x80\x80",
        // sequences cut short by ASCII, a control character, a quote, a
        // backslash, DEL, or the lead byte of a well-formed character
        "\xC3" "a", "\xE2\x82" "\n", "\xE2\x82\"", "\xF0\x9F\x98\\", "\xC3\x7F", "\xC3\xC3\xA4", "\xE2\xF0\x9F\x98\x80",
        // truncated sequences
        "\xC3", "\xE2\x82", "\xF0\x9F\x98"
    };
    // well-formed characters of 1, 2, 3, and 4 bytes
    const std::vector<std::string> fillers = {"a", "\xC3\xA4", "\xE2\x82\xAC", "\xF0\x9F\x98\x80"};
    const auto make_string = [](const std::string & filler, const std::size_t before, const std::string & pattern, const std::size_t after)
    {
        std::string s;
        for (std::size_t k = 0; k < before; ++k)
        {
            s += filler;
        }
        s += pattern;
        for (std::size_t k = 0; k < after; ++k)
        {
            s += filler;
        }
        return s;
    };
    SECTION("the reference")
    {
        // the reference itself, against hand-written results
        const std::string s = "a\xFF\n\xC3\"\xE0\x80\xF0\x9F\x98\x80\xE2\x82";
        CHECK(reference_dump_string(s, false, json::error_handler_t::strict).text == "[json.exception.type_error.316] invalid UTF-8 byte at index 1: 0xFF");
        CHECK(reference_dump_string(s.substr(2), false, json::error_handler_t::strict).text == "[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0x22");
        CHECK(reference_dump_string("\xF0\x9F\x98\x80\xE2\x82", true, json::error_handler_t::strict).text == "[json.exception.type_error.316] incomplete UTF-8 string; last byte: 0x82");
        CHECK(reference_dump_string(s, false, json::error_handler_t::ignore).text == "\"a\\n\\\"\xF0\x9F\x98\x80\"");
        CHECK(reference_dump_string(s, true, json::error_handler_t::ignore).text == "\"a\\n\\\"\\ud83d\\ude00\"");
        CHECK(reference_dump_string(s, false, json::error_handler_t::replace).text == "\"a\xEF\xBF\xBD\\n\xEF\xBF\xBD\\\"\xEF\xBF\xBD\xEF\xBF\xBD\xF0\x9F\x98\x80\xEF\xBF\xBD\"");
        CHECK(reference_dump_string(s, true, json::error_handler_t::replace).text == "\"a\\ufffd\\n\\ufffd\\\"\\ufffd\\ufffd\\ud83d\\ude00\\ufffd\"");
        CHECK(reference_dump_string(s, false, json::error_handler_t::keep).text == "\"" + std::string("a\xFF\\n\xC3\\\"\xE0\x80\xF0\x9F\x98\x80\xE2\x82") + "\"");
        CHECK(reference_dump_string(s, true, json::error_handler_t::keep).text == "\"" + std::string("a\xFF\\n\xC3\\\"\xE0\x80\\ud83d\\ude00\xE2\x82") + "\"");
        check_dump_against_reference(s);
    }
    SECTION("short strings")
    {
        // strings of up to 17 bytes put the pattern at every offset of an
        // 8-byte stride of the bulk scanners, with whole strides on both
        // sides; lengths around 24, 32, and 40 bytes cross the 16- and 32-byte
        // strides; error_handler_t::strict is checked for up to 17 bytes of
        // ASCII and 8 bytes of other characters only, as throwing is slow on
        // some platforms
        for (const auto& filler : fillers)
        {
            for (std::size_t length = 0; length * filler.size() <= 40; ++length)
            {
                const std::size_t bytes = length * filler.size();
                if (filler.size() == 1 && bytes > 17 && (bytes + 1) % 8 > 2)
                {
                    continue;
                }
                for (std::size_t pos = 0; pos <= length; ++pos)
                {
                    for (const auto& pattern : patterns)
                    {
                        check_dump_against_reference(make_string(filler, pos, pattern, length - pos), bytes <= (filler.size() == 1 ? 17 : 8));
                    }
                }
            }
        }
    }
    SECTION("strings crossing the end of the string buffer")
    {
        // characters that are not copied in bulk go through a 512-byte string
        // buffer that is written out once fewer than 13 bytes are left; with
        // ensure_ascii, each 2-byte character takes 6 bytes of it and each
        // 4-byte character 12, so the pattern meets the end of the buffer after
        // about 84 or 42 characters (3-byte characters behave like 2-byte
        // ones); plain ASCII, copied in bulk, is checked around 512 bytes;
        // positions further away are sampled; error_handler_t::strict throws
        // at the first ill-formed byte, regardless of the string buffer, and is
        // covered above
        for (const auto& filler : fillers)
        {
            if (filler.size() == 3)
            {
                continue;
            }
            const std::size_t escaped_size = filler.size() == 1 ? 1 : filler.size() * 3;
            const std::size_t middle = 506 / escaped_size;
            const std::size_t window = filler.size() == 1 ? 8 : 16;
            for (std::size_t pos = 0; pos <= middle + window; pos += (pos + window >= middle) ? 1 : 29)
            {
                for (const std::size_t after :
                        {
                            std::size_t{0}, std::size_t{12}
                        })
                {
                    for (const auto& pattern : patterns)
                    {
                        check_dump_against_reference(make_string(filler, pos, pattern, after), false);
                    }
                }
            }
        }
    }
    SECTION("repeated invalid sequences at every offset of the string buffer")
    {
        // ill-formed sequences that are kept or replaced fill the string
        // buffer without a bulk copy in between; a prefix of 0 to 12 bytes
        // 0xFF (kept as 1 byte, replaced by 3 or 6) shifts them across every
        // offset of the end of the buffer
        for (const auto& pattern : patterns)
        {
            for (std::size_t shift = 0; shift <= 12; ++shift)
            {
                std::string s(shift, '\xFF');
                while (s.size() < 600)
                {
                    s += pattern;
                }
                check_dump_against_reference(s, shift == 0);
                check_dump_against_reference(s + "\xF0\x9F\x98\x80", false);
            }
        }
    }
 }
@@ -15,24 +15,6 @@
 #include <nlohmann/json.hpp>
 using nlohmann::detail::dtoa_impl::reinterpret_bits;
 #include <algorithm>
 #include <array>
 #include <cmath>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 #include <iomanip>
 #include <limits>
 #include <locale>
 #include <random>
 #include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
 #if defined(JSON_HAS_CPP_17)
    #include <charconv>
 #endif
 namespace
 {
 float make_float(uint32_t sign_bit, uint32_t biased_exponent, uint32_t significand)
@@ -468,7 +450,7 @@ TEST_CASE("formatting")
        check_double(  1.2345e+18,   "1.2345e+18"             ); //  1.2345e+18                1.2345e+18                1.2345e18
        check_double(  1.2345e+19,   "1.2345e+19"             ); //  1.2345e+19                1.2345e+19                1.2345e19
        check_double(  1.2345e+20,   "1.2345e+20"             ); //  1.2345e+20                1.2345e+20                1.2345e20
-        check_double(  1.2345e+21,   "1.2345e+21"             ); //  1.2345e+21                1.2344999999999999e+21    1.2345e21
+        check_double(  1.2345e+21,   "1.2344999999999999e+21" ); //  1.2345e+21                1.2344999999999999e+21    1.2345e21
        check_double(  1.2345e+22,   "1.2345e+22"             ); //  1.2345e+22                1.2345e+22                1.2345e22
    }
@@ -532,327 +514,3 @@ TEST_CASE("formatting")
        check_integer(1000000000000000000LL, "1000000000000000000");
    }
 }
 namespace
 {
 // a small unsigned big integer (32-bit limbs, least significant first), to
 // recompute the powers of ten of the shortest double conversion
 using big = std::vector<std::uint32_t>;
 void big_mul_small(big& x, std::uint32_t m)
 {
    std::uint64_t carry = 0;
    for (auto& limb : x)
    {
        const std::uint64_t v = (static_cast<std::uint64_t>(limb) * m) + carry;
        limb = static_cast<std::uint32_t>(v);
        carry = v >> 32u;
    }
    if (carry != 0)
    {
        x.push_back(static_cast<std::uint32_t>(carry));
    }
 }
 void big_div_small(big& x, std::uint32_t d)
 {
    std::uint64_t rest = 0;
    for (std::size_t i = x.size(); i-- > 0;)
    {
        const std::uint64_t v = (rest << 32u) | x[i];
        x[i] = static_cast<std::uint32_t>(v / d);
        rest = v % d;
    }
    while (!x.empty() && x.back() == 0)
    {
        x.pop_back();
    }
 }
 std::size_t big_bit_length(const big& x)
 {
    std::size_t n = 32 * x.size();
    for (std::uint32_t top = x.back(); (top & 0x80000000u) == 0; top <<= 1u)
    {
        --n;
    }
    return n;
 }
 bool big_bit(const big& x, std::size_t i)
 {
    return ((x[i / 32] >> (i % 32)) & 1u) != 0;
 }
 /// the 128 most significant bits of x (floor), shifted left if x has fewer bits
 std::pair<std::uint64_t, std::uint64_t> big_top128(const big& x)
 {
    const std::size_t n = big_bit_length(x);
    std::uint64_t high = 0;
    std::uint64_t low = 0;
    for (std::size_t k = 0; k < 128; ++k)
    {
        const bool bit = k < n && big_bit(x, n - 1 - k);
        if (k < 64)
        {
            high = (high << 1u) | (bit ? 1u : 0u);
        }
        else
        {
            low = (low << 1u) | (bit ? 1u : 0u);
        }
    }
    return {high, low};
 }
 /// the digits (without trailing zeros) and the decimal exponent of a
 /// representation "[-]d[.ddd][e[+-]x]"
 std::pair<std::string, int> digits_and_exponent(const std::string& s)
 {
    std::string digits;
    int point = -1;
    int exponent = 0;
    for (std::size_t i = 0; i < s.size(); ++i)
    {
        const char c = s[i];
        if (c >= '0' && c <= '9')
        {
            digits += c;
        }
        else if (c == '.')
        {
            point = static_cast<int>(digits.size());
        }
        else if (c == 'e' || c == 'E')
        {
            exponent = std::stoi(s.substr(i + 1));
            break;
        }
    }
    int e = exponent + (point < 0 ? static_cast<int>(digits.size()) : point) - static_cast<int>(digits.size());
    const std::size_t first = digits.find_first_not_of('0');
    digits = first == std::string::npos ? "0" : digits.substr(first);
    while (digits.size() > 1 && digits.back() == '0')
    {
        digits.pop_back();
        ++e;
    }
    return {digits, e};
 }
 /// the correctly rounded double of a decimal text
 /// (not std::strtod: the C runtimes of some platforms, e.g. MinGW's, round
 /// some 16 and 17 digit inputs wrongly)
 double parse_double(const std::string& text)
 {
    const nlohmann::json j = nlohmann::json::parse(text, nullptr, false);
    // (a discarded value: out of range, as strtod's HUGE_VAL)
    return j.is_discarded() ? std::numeric_limits<double>::infinity() : j.get<double>();
 }
 /// whether the decimal digits * 10^e reads back as v
 bool reads_back(const std::string& digits, int e, double v)
 {
    const std::string text = digits + "e" + std::to_string(e);
    // (compared bit for bit: v is positive and finite, and -Wfloat-equal)
    return reinterpret_bits<std::uint64_t>(parse_double(text)) == reinterpret_bits<std::uint64_t>(v);
 }
 /// Check the representation of a positive finite double: it reads back as
 /// the same value, and no representation with fewer digits does.
 void check_shortest(double v)
 {
    std::array<char, 33> buf{};
    char* end = nlohmann::detail::to_chars(buf.data(), buf.data() + 32, v);
    const std::string text(buf.data(), end);
    CAPTURE(text)
    CHECK(parse_double(text) == v);
    // the layout is that of format_buffer() for the digits of Zmij
    const auto sd = nlohmann::detail::zmij::to_shortest(reinterpret_bits<std::uint64_t>(v));
    const std::uint64_t significand = sd.has_digit ? (sd.integral * 10) + sd.digit : sd.integral;
    int exponent = sd.has_digit ? sd.exponent : sd.exponent + 1;
    std::string significand_digits = std::to_string(significand);
    while (significand_digits.size() > 1 && significand_digits.back() == '0')
    {
        significand_digits.pop_back();
        ++exponent;
    }
    std::array<char, 64> reference{};
    std::copy(significand_digits.begin(), significand_digits.end(), reference.begin());
    const char* const reference_end = nlohmann::detail::dtoa_impl::format_buffer(reference.data(), static_cast<int>(significand_digits.size()), exponent, -4, 15);
    CHECK(text == std::string(reference.data(), static_cast<std::size_t>(reference_end - reference.data())));
    // and write_positive() is what to_chars() calls
    std::array<char, 64> positive{};
    const char* const positive_end = nlohmann::detail::dtoa_impl::write_positive(positive.data(), positive.data() + positive.size(), v);
    CHECK(text == std::string(positive.data(), static_cast<std::size_t>(positive_end - positive.data())));
    const auto de = digits_and_exponent(text);
    const std::string& digits = de.first;
    if (digits.size() > 1)
    {
        // the decimals of one digit fewer next to the value
        // (a stream rather than snprintf("%.*e"), whose output GCC cannot bound)
        std::ostringstream shorter;
        shorter.imbue(std::locale::classic());
        shorter << std::scientific << std::setprecision(static_cast<int>(digits.size()) - 2) << v;
        const auto near = digits_and_exponent(shorter.str());
        // as an integer with digits.size() - 1 digits
        std::string m = near.first;
        int e = near.second;
        while (m.size() < digits.size() - 1)
        {
            m += '0';
            --e;
        }
        const std::uint64_t mid = std::stoull(m);
        for (const std::uint64_t candidate :
                {
                    mid - 1, mid, mid + 1
                })
        {
            CAPTURE(candidate)
            CHECK(!reads_back(std::to_string(candidate), e, v));
        }
    }
    // (icpc with libstdc++ 11 defines __cpp_lib_to_chars, but has no floating-point std::to_chars)
 #if defined(JSON_HAS_CPP_17) && defined(__cpp_lib_to_chars) && !defined(__INTEL_COMPILER)
    // the closest of the shortest representations, as std::to_chars finds it
    std::array<char, 64> std_text{};
    const auto r = std::to_chars(std_text.data(), std_text.data() + std_text.size(), v, std::chars_format::scientific);
    CHECK(digits_and_exponent(std::string(std_text.data(), r.ptr)) == de);
 #endif
 }
 } // namespace
 TEST_CASE("shortest digits of doubles")
 {
    SECTION("powers of ten")
    {
        // the 128-bit significands of 10^k, rounded down, recomputed
        for (int k = -342; k <= 341; ++k)
        {
            CAPTURE(k)
            big x{1};
            if (k >= 0)
            {
                for (int i = 0; i < k; ++i)
                {
                    big_mul_small(x, 10);
                }
            }
            else
            {
                // floor(2^b / 10^-k) for a b that leaves more than 128 bits
                const int b = 128 + 64 + (4 * -k);
                x.assign(static_cast<std::size_t>(b / 32) + 1, 0);
                x.back() = 1u << (b % 32);
                for (int i = 0; i < -k; ++i)
                {
                    big_div_small(x, 10);
                }
            }
            const auto expected = big_top128(x);
            const auto actual = nlohmann::detail::zmij::pow10(k);
            CHECK(actual.high == expected.first);
            CHECK(actual.low == expected.second);
        }
    }
    SECTION("boundary values")
    {
        for (const double v :
                {
                    std::numeric_limits<double>::min(), std::numeric_limits<double>::max(), std::numeric_limits<double>::denorm_min(),
                    std::nextafter(std::numeric_limits<double>::min(), 0.0), 1.0, 2.0, 0.1, 0.3, 1e21, 1e22, 1e23, 5e-324, 9007199254740993.0,
                    1.2345e+21, 2.2250738585072014e-308, 1.7976931348623157e308, 4.9406564584124654e-324, 123456789012345680.0
                })
        {
            check_shortest(v);
        }
        // all powers of two (their rounding interval is narrower below)
        for (int e = -1074; e <= 1023; ++e)
        {
            check_shortest(std::ldexp(1.0, e));
        }
        // powers of ten and their neighbors
        for (int e = -323; e <= 308; ++e)
        {
            const double p = std::strtod(("1e" + std::to_string(e)).c_str(), nullptr);
            check_shortest(p);
            check_shortest(std::nextafter(p, 0.0));
            check_shortest(std::nextafter(p, std::numeric_limits<double>::infinity()));
        }
    }
    SECTION("random doubles")
    {
        std::mt19937_64 rng(5295); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed): reproducible
        for (int i = 0; i < 100000; ++i)
        {
            const std::uint64_t bits = rng() & 0x7FFFFFFFFFFFFFFFu;
            const auto v = reinterpret_bits<double>(bits);
            if (std::isfinite(v) && bits != 0)
            {
                check_shortest(v);
            }
        }
    }
 }
 TEST_CASE("choice of the conversion")
 {
    using nlohmann::detail::dtoa_impl::is_binary64;
    SECTION("by the format of the type")
    {
        // Zmij needs binary64 numbers; everything else uses Grisu2
        static_assert(!is_binary64<float>::value, "float is not binary64");
        static_assert(is_binary64<double>::value == (std::numeric_limits<double>::is_iec559 && std::numeric_limits<double>::digits == 53),
                      "double is binary64 where it is IEEE 754 with 53 digits");
        static_assert(!is_binary64<int>::value, "integers are not binary64");
        static_assert(is_binary64<long double>::value == (std::numeric_limits<long double>::is_iec559 && std::numeric_limits<long double>::digits == 53 && sizeof(long double) == 8),
                      "long double is binary64 where it has the format of a double");
        CHECK(!is_binary64<float>::value);
        CHECK(is_binary64<double>::value);
    }
    SECTION("float: Grisu2, double: Zmij")
    {
        // 5.3165205877497296e+16 is one of the doubles for which Grisu2 does not find the shortest digits
        constexpr double value = 5.3165205877497296e+16;
        std::array<char, 64> buf{};
        const char* const last = buf.data() + buf.size();
        char* end = nlohmann::detail::dtoa_impl::write_positive(buf.data(), last, value);
        CHECK(std::string(buf.data(), end) == "5.31652058774973e+16");
        end = nlohmann::detail::dtoa_impl::write_positive_grisu2(buf.data(), last, value);
        CHECK(std::string(buf.data(), end) == "5.3165205877497296e+16");
        constexpr float f = 1.1754944e-38f;
        end = nlohmann::detail::dtoa_impl::write_positive(buf.data(), last, f);
        const std::string dispatched(buf.data(), end);
        end = nlohmann::detail::dtoa_impl::write_positive_grisu2(buf.data(), last, f);
        CHECK(dispatched == std::string(buf.data(), end));
    }
    SECTION("long double with the format of a double: Zmij")
    {
        // (on platforms where long double is wider, Grisu2 does not apply either: the snprintf fallback does)
        // (constant on a given platform)
        DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
        DOCTEST_MSVC_SUPPRESS_WARNING(4127)
        if (std::numeric_limits<long double>::digits == 53 && std::numeric_limits<long double>::is_iec559)
        {
            using long_double_json = nlohmann::json::with_float_t<long double>;
            for (const double d :
                    {
                        5.3165205877497296e+16, 1.0, 0.1, 123456.789, 2.2250738585072014e-308, 1.7976931348623157e+308, -5.3165205877497296e+16
                    })
            {
                CAPTURE(d)
                CHECK(long_double_json(static_cast<long double>(d)).dump() == nlohmann::json(d).dump());
            }
            CHECK(long_double_json(5.3165205877497296e+16L).dump() == "5.31652058774973e+16");
        }
        DOCTEST_MSVC_SUPPRESS_WARNING_POP
    }
 }