Merge branch 'develop' into claude/issue-3885-3dcafd

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Avoid //include in Meson-generated CMake target for prefix /
2026-10-01 12:10:32 +00:00 · 2026-10-01 13:07:17 +02:00 · 2026-10-01 13:07:17 +02:00 · 2026-10-01 10:53:10 +02:00 · 2026-09-30 20:31:07 +02:00 · 2026-09-27 20:58:21 +02:00
21 changed files with 1281 additions and 2402 deletions
@@ -0,0 +1,53 @@
 name: "Cancel runs of closed pull requests"
 # The concurrency groups of the other workflows cancel superseded runs when a
 # pull request gets new commits, but nothing stops the runs of its last commit
 # once the pull request is merged or closed. They then keep the runners busy
 # for hours while the queue of the open pull requests waits.
 #
 # pull_request_target is needed to get a token that can cancel runs for pull
 # requests from forks. This is safe because the workflow never checks out or
 # runs code from the pull request; it only calls the API.
 on:
  pull_request_target:
    types: [closed]
 concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }}
  cancel-in-progress: true
 permissions:
  contents: read
 jobs:
  cancel:
    permissions:
      actions: write
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
      - name: Cancel unfinished runs of the pull request's head commit
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          GH_REPO: ${{ github.repository }}
          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
          SELF: ${{ github.run_id }}
        # only runs triggered by the pull request: when a branch is pushed to
        # develop directly, its push runs share the head commit
        run: |
          gh api --paginate "repos/$GH_REPO/actions/runs?head_sha=$HEAD_SHA&per_page=100" \
            --jq ".workflow_runs[]
                  | select(.status != \"completed\" and .id != $SELF)
                  | select(.event == \"pull_request\" or .event == \"pull_request_target\")
                  | \"\(.id) \(.name)\"" |
          while read -r id name; do
            echo "Cancelling run $id ($name)"
            # a run may finish between listing and cancelling; that is not an error
            gh run cancel "$id" || true
          done
@@ -31,6 +31,45 @@ jobs:
      - name: Build
        run: cmake --build build --target ci_test_gcc
  ci_meson_install:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
      - name: Install Meson
        run: pip install meson
      - name: Install with Meson
        run: |
          meson setup build-meson --prefix=${{ github.workspace }}/install
          meson install -C build-meson
      - name: Use the installed package with find_package
        run: |
          cmake -S tests/cmake_import/project -B build-import -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install
          cmake --build build-import
      - name: Install with Meson and non-default options
        run: |
          meson setup build-meson-options --prefix=${{ github.workspace }}/install-options -DMultipleHeaders=true -DDiagnostics=true -DGlobalUDLs=false
          meson install -C build-meson-options
      - name: Check that the options reach the installed files
        run: |
          test -d install-options/include/nlohmann/detail
          cflags=$(PKG_CONFIG_PATH=${{ github.workspace }}/install-options/share/pkgconfig pkg-config --cflags nlohmann_json)
          echo "$cflags"
          echo "$cflags" | grep -q -- '-DJSON_DIAGNOSTICS=1'
          echo "$cflags" | grep -q -- '-DJSON_USE_GLOBAL_UDLS=0'
          grep -q 'JSON_USE_GLOBAL_UDLS=0;JSON_DIAGNOSTICS=1' install-options/share/cmake/nlohmann_json/nlohmann_jsonTargets.cmake
          cmake -S tests/cmake_import/project -B build-import-options -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install-options
          cmake --build build-import-options
      - name: Install with Meson and the include directory outside the prefix
        run: |
          meson setup build-meson-split --prefix=${{ github.workspace }}/install-split --includedir=${{ github.workspace }}/install-split-dev/include
          meson install -C build-meson-split
          cmake -S tests/cmake_import/project -B build-import-split -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install-split
          cmake --build build-import-split
  ci_infer:
    runs-on: ubuntu-latest
    steps:
@@ -174,7 +174,30 @@ if (MSVC)
    )
 endif()
-# Install a pkg-config file, so other tools can find this.
+# Install a pkg-config file, so other tools can find this. It carries the same
 # compile definitions as the target above.
 set(NLOHMANN_JSON_PKGCONFIG_CFLAGS "")
 if (NOT JSON_GlobalUDLs)
    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_GLOBAL_UDLS=0")
 endif()
 if (NOT JSON_ImplicitConversions)
    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_IMPLICIT_CONVERSIONS=0")
 endif()
 if (JSON_DisableEnumSerialization)
    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DISABLE_ENUM_SERIALIZATION=1")
 endif()
 if (JSON_Diagnostics)
    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DIAGNOSTICS=1")
 endif()
 if (JSON_Diagnostic_Positions)
    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DIAGNOSTIC_POSITIONS=1")
 endif()
 if (JSON_LegacyDiscardedValueComparison)
    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1")
 endif()
 if (JSON_StrictNulHandling)
    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_STRICT_NUL_HANDLING=1")
 endif()
 configure_file(
    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkg-config.pc.in"
    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"
@@ -249,9 +249,29 @@ make BUILD.bazel
 The "Check amalgamation" workflow fails if the file is out of date.
-### `meson.build`
+### `meson.build` and `meson_options.txt`
-The build definition for the [Meson](https://mesonbuild.com) build system.
+Meson build definitions suitable for use as a subproject ("wrap" in Meson terminology).
 Projects wishing to use the wrap can execute:
 ```sh
 meson wrap install nlohmann_json
 ```
 Which allows Meson to build from source when a system provided dependency isn't available.
 To build directly:
 ```sh
 meson setup builddir
 ninja -C builddir
 ```
 `meson_options.txt` defines the options, which mirror the CMake options that change the library's target (for example,
 `-DDiagnostics=true`). Meson requires this file next to `meson.build`, so it is also part of `include.zip`.
 When installing, `meson.build` installs the headers, a pkg-config file, and the CMake package config files, so that
 `find_package(nlohmann_json)` works. As Meson cannot generate `nlohmann_jsonTargets.cmake` itself, it is created from
 the template `cmake/nlohmann_jsonTargets.cmake.in`, which is only used by Meson.
 ### `Package.swift`
@@ -181,7 +181,7 @@ json.tar.xz:
 # We use `-X` to make the resulting ZIP file reproducible, see
 # <https://content.pivotal.io/blog/barriers-to-deterministic-reproducible-zip-files>.
 include.zip: BUILD.bazel
-	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) BUILD.bazel MODULE.bazel meson.build LICENSE.MIT
+	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) BUILD.bazel MODULE.bazel meson.build meson_options.txt LICENSE.MIT
 # Create the files for a release and add signatures and hashes.
 release: include.zip json.tar.xz
@@ -1394,7 +1394,7 @@ THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR I
 - 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 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">
@@ -0,0 +1,42 @@
 # Imported target for installations made with Meson (see meson.build).
 #
 # CMake installations generate this file with install(EXPORT ...). Meson cannot
 # do that, but as the library is header-only, the target only needs an include
 # directory, the C++ standard, and the compile definitions of the options that
 # differ from their defaults. Paths are computed relative to this file so that
 # the installation can be relocated (e.g., into a sysroot), unless includedir or
 # datadir is outside the prefix.
 if(TARGET @PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@)
    return()
 endif()
 get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_DIR}/@NLOHMANN_JSON_CONFIG_TO_PREFIX@" ABSOLUTE)
 # As in CMake's generated file: avoid "//include" for an installation to "/".
 if(_IMPORT_PREFIX STREQUAL "/")
    set(_IMPORT_PREFIX "")
 endif()
 add_library(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ INTERFACE IMPORTED)
 set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
    INTERFACE_INCLUDE_DIRECTORIES "@NLOHMANN_JSON_INCLUDE_DIR@"
 )
 if(CMAKE_VERSION VERSION_LESS 3.8)
    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
        INTERFACE_COMPILE_FEATURES cxx_range_for
    )
 else()
    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
        INTERFACE_COMPILE_FEATURES cxx_std_11
    )
 endif()
 set(_NLOHMANN_JSON_COMPILE_DEFINITIONS "@NLOHMANN_JSON_COMPILE_DEFINITIONS@")
 if(_NLOHMANN_JSON_COMPILE_DEFINITIONS)
    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
        INTERFACE_COMPILE_DEFINITIONS "${_NLOHMANN_JSON_COMPILE_DEFINITIONS}"
    )
 endif()
 unset(_NLOHMANN_JSON_COMPILE_DEFINITIONS)
 unset(_IMPORT_PREFIX)
@@ -4,4 +4,4 @@ includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
 Name: @PROJECT_NAME@
 Description: JSON for Modern C++
 Version: @PROJECT_VERSION@
-Cflags: -I${includedir}
+Cflags: -I${includedir}@NLOHMANN_JSON_PKGCONFIG_CFLAGS@
@@ -23,10 +23,9 @@ type to use.
 ## Template parameters
 `NumberFloatType`
-:   the type to store floating-point numbers. The parser converts `#!cpp float`, `#!cpp double`, and a
+:   the type to store floating-point numbers. Parsing and serialization are implemented in terms of
-    `#!cpp long double` that is IEEE 754 binary64 itself and other `#!cpp long double` formats with
+    `#!cpp std::strtof`/`#!cpp std::strtod`/`#!cpp std::strtold` and `#!cpp std::snprintf`, so the type must be
-    `#!cpp std::from_chars` or `#!cpp std::strtold`, and serialization falls back to `#!cpp std::snprintf`, so the
+    `#!cpp float`, `#!cpp double`, or `#!cpp long double`. The
    type must be `#!cpp float`, `#!cpp double`, or `#!cpp long double`. 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).
@@ -71,13 +71,10 @@ otherwise, it uses unsigned integer storage.
    - 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
+    - As of version 3.9.1, the conversion is realized by
-      numbers are correctly rounded (to nearest, ties to even). Only a `#!c long double` that is not IEEE 754 binary64
+      [`std::strtoull`](https://en.cppreference.com/w/cpp/string/byte/strtoul),
-      (e.g., the 80-bit x87 format) is converted with `#!cpp std::from_chars` where available, or else with
+      [`std::strtoll`](https://en.cppreference.com/w/cpp/string/byte/strtol), and
-      [`std::strtold`](https://en.cppreference.com/w/cpp/string/byte/strtof). For that call, the library temporarily
+      [`std::strtod`](https://en.cppreference.com/w/cpp/string/byte/strtof), respectively.
      replaces the `.` with the decimal point of the current locale (which may be longer than one byte, e.g., in
      `fa_IR.UTF-8`), so the result does not depend on the locale either. Changing the locale in another thread during
      parsing is undefined behavior of the C library, though.
 !!! example "Examples"
@@ -88,10 +85,10 @@ otherwise, it uses unsigned integer storage.
 ### 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;`.
@@ -26,9 +26,8 @@ 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 silently misparses numbers,
-      stored as a `#!cpp long double` that is not IEEE 754 binary64 (e.g., the 80-bit x87 format), because the lexer
+      because the lexer hands the buffer to `#!cpp std::strtoull`/`#!cpp std::strtoll`/`#!cpp std::strtod`.
      hands the buffer to `#!cpp std::strtold`.
    - 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
@@ -536,10 +535,8 @@ 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::strtof`, `#!cpp std::strtod`, or
-  `#!cpp long double` that is IEEE 754 binary64 itself; other `#!cpp long double` formats are converted with
+  `#!cpp std::strtold`; the library provides overloads for exactly these three types.
  `#!cpp std::from_chars` where available, or with `#!cpp std::strtold`. The library provides overloads for exactly
  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`).
@@ -20,4 +20,4 @@ The class contains a slightly modified version of the Grisu2 algorithm from Flor
 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
@@ -121,10 +121,23 @@ meson wrap install nlohmann_json
 Please see the Meson project for any issues regarding the packaging.
 The provided `meson.build` can also be used as an alternative to CMake for installing `nlohmann_json` system-wide in
-which case a pkg-config file is installed. To use it, have your build system require the `nlohmann_json`
+which case a pkg-config file and the CMake package config files are installed. To use it, have your build system require
-pkg-config dependency. In Meson, it is preferred to use the
+the `nlohmann_json` pkg-config dependency, or use [`find_package(nlohmann_json)`](cmake.md#external) in CMake. In Meson,
-[`dependency()`](https://mesonbuild.com/Reference-manual.html#dependency) object with a subproject fallback, rather than
+it is preferred to use the [`dependency()`](https://mesonbuild.com/Reference-manual.html#dependency) object with a
-using the subproject directly.
+subproject fallback, rather than using the subproject directly.
 The options that change the library's configuration are available in Meson as well, named like the
 [CMake options](cmake.md#cmake-options) without the `JSON_` prefix: `MultipleHeaders`, `GlobalUDLs`,
 `ImplicitConversions`, `DisableEnumSerialization`, `Diagnostics`, `Diagnostic_Positions`,
 `LegacyDiscardedValueComparison`, and `StrictNulHandling`. They have the same defaults as in CMake, except that
 `MultipleHeaders` is `false`. Set them with `-D` when setting up the build, or with the subproject name as prefix when
 the library is used as a subproject:
 ```shell
 meson setup build -Dnlohmann_json:Diagnostics=true
 ```
 The resulting compile definitions are part of the Meson dependency, the pkg-config file, and the CMake target.
 ??? example "Example: Wrap"
@@ -1039,11 +1039,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.
    {
@@ -1056,7 +1054,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;
@@ -1386,8 +1384,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)
    {
@@ -1441,11 +1439,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;
@@ -2,24 +2,111 @@ project('nlohmann_json',
    'cpp',
    version : '3.12.0',
    license : 'MIT',
    meson_version : '>= 0.64',
    default_options: ['cpp_std=c++11'],
 )
 if get_option('MultipleHeaders')
    incdir = 'include'
 else
    incdir = 'single_include'
 endif
 # The same compile definitions as the CMake target (see target_compile_definitions
 # in CMakeLists.txt): only an option that differs from its default adds one.
 json_defines = []
 if not get_option('GlobalUDLs')
    json_defines += 'JSON_USE_GLOBAL_UDLS=0'
 endif
 if not get_option('ImplicitConversions')
    json_defines += 'JSON_USE_IMPLICIT_CONVERSIONS=0'
 endif
 if get_option('DisableEnumSerialization')
    json_defines += 'JSON_DISABLE_ENUM_SERIALIZATION=1'
 endif
 if get_option('Diagnostics')
    json_defines += 'JSON_DIAGNOSTICS=1'
 endif
 if get_option('Diagnostic_Positions')
    json_defines += 'JSON_DIAGNOSTIC_POSITIONS=1'
 endif
 if get_option('LegacyDiscardedValueComparison')
    json_defines += 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1'
 endif
 if get_option('StrictNulHandling')
    json_defines += 'JSON_STRICT_NUL_HANDLING=1'
 endif
 cpp_args = []
 foreach define : json_defines
    cpp_args += '-D' + define
 endforeach
 nlohmann_json_dep = declare_dependency(
-    include_directories: include_directories('single_include')
+    compile_args: cpp_args,
    include_directories: include_directories(incdir)
 )
 meson.override_dependency('nlohmann_json', nlohmann_json_dep)
 # The multi-header version under the name earlier versions of this file used
 nlohmann_json_multiple_headers = declare_dependency(
    compile_args: cpp_args,
    include_directories: include_directories('include')
 )
 if not meson.is_subproject()
-install_headers('single_include/nlohmann/json.hpp', subdir: 'nlohmann')
+    install_subdir(
-install_headers('single_include/nlohmann/json_fwd.hpp', subdir: 'nlohmann')
+        incdir / 'nlohmann',
-install_headers('single_include/nlohmann/json_literals.hpp', subdir: 'nlohmann')
+        install_dir: get_option('includedir'),
        install_tag: 'devel',
    )
-pkgc = import('pkgconfig')
+    pkgc = import('pkgconfig')
-pkgc.generate(name: 'nlohmann_json',
+    pkgc.generate(name: 'nlohmann_json',
        version: meson.project_version(),
-    description: 'JSON for Modern C++'
+        description: 'JSON for Modern C++',
-)
+        extra_cflags: cpp_args,
        install_dir: get_option('datadir') / 'pkgconfig',
    )
    # CMake package config files, so that find_package(nlohmann_json) works. The
    # include directory is given relative to the config files, so that the
    # installation can be relocated. This is not possible if includedir or datadir
    # is an absolute path outside the prefix (e.g., with the separate outputs of
    # Nix); then the absolute include directory is used, as CMake does.
    fs = import('fs')
    cmake_install_dir = get_option('datadir') / 'cmake' / meson.project_name()
    cmake_to_prefix = []
    if fs.is_absolute(get_option('includedir')) or fs.is_absolute(cmake_install_dir)
        cmake_include_dir = (get_option('prefix') / get_option('includedir')).replace('\\', '/')
    else
        foreach component : cmake_install_dir.split('/')
            cmake_to_prefix += '..'
        endforeach
        cmake_include_dir = '${_IMPORT_PREFIX}/' + get_option('includedir')
    endif
    cmake_conf = configuration_data()
    cmake_conf.set('PROJECT_NAME', meson.project_name())
    cmake_conf.set('PROJECT_VERSION', meson.project_version())
    cmake_conf.set('PROJECT_VERSION_MAJOR', meson.project_version().split('.')[0])
    cmake_conf.set('NLOHMANN_JSON_TARGET_NAME', meson.project_name())
    cmake_conf.set('NLOHMANN_JSON_TARGETS_EXPORT_NAME', meson.project_name() + 'Targets')
    cmake_conf.set('NLOHMANN_JSON_INCLUDE_DIR', cmake_include_dir)
    cmake_conf.set('NLOHMANN_JSON_CONFIG_TO_PREFIX', '/'.join(cmake_to_prefix))
    cmake_conf.set('NLOHMANN_JSON_COMPILE_DEFINITIONS', ';'.join(json_defines))
    foreach cmake_file : [
        ['cmake/config.cmake.in', 'nlohmann_jsonConfig.cmake'],
        ['cmake/nlohmann_jsonConfigVersion.cmake.in', 'nlohmann_jsonConfigVersion.cmake'],
        ['cmake/nlohmann_jsonTargets.cmake.in', 'nlohmann_jsonTargets.cmake'],
    ]
        configure_file(
            input: cmake_file[0],
            output: cmake_file[1],
            configuration: cmake_conf,
            format: 'cmake@',
            install_dir: cmake_install_dir,
        )
    endforeach
 endif
@@ -0,0 +1,48 @@
 option(
    'MultipleHeaders',
    type: 'boolean',
    value: false,
    description: 'Use non-amalgamated version of the library',
 )
 option(
    'GlobalUDLs',
    type: 'boolean',
    value: true,
    description: 'Place user-defined string literals in the global namespace',
 )
 option(
    'ImplicitConversions',
    type: 'boolean',
    value: true,
    description: 'Enable implicit conversions',
 )
 option(
    'DisableEnumSerialization',
    type: 'boolean',
    value: false,
    description: 'Disable default integer enum serialization',
 )
 option(
    'Diagnostics',
    type: 'boolean',
    value: false,
    description: 'Use extended diagnostic messages',
 )
 option(
    'Diagnostic_Positions',
    type: 'boolean',
    value: false,
    description: 'Enable diagnostic positions',
 )
 option(
    'LegacyDiscardedValueComparison',
    type: 'boolean',
    value: false,
    description: 'Enable legacy discarded value comparison',
 )
 option(
    'StrictNulHandling',
    type: 'boolean',
    value: false,
    description: 'Enable strict NUL-byte handling',
 )
@@ -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
@@ -13,18 +13,15 @@
 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 <map> // map
 #include <sstream> // stringstream
 #include <string> // string
 #include <utility> // pair
 #include <vector> // vector
 #include "float_hard_cases.hpp"
 namespace
 {
 // shortcut to scan a string literal
@@ -260,7 +257,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"
        };
@@ -282,18 +279,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
@@ -664,145 +663,46 @@ TEST_CASE("lexer string fast path")
    }
 }
-namespace
+TEST_CASE("parse_float_fast declines what it cannot convert exactly")
 {
-// the index of the decimal point (or npos) and of the end of the mantissa of a
+    // The lexer only hands well-formed numbers to parse_float_fast, so the
-// number token, which the lexer records while scanning it
+    // malformed ones below can only be passed to it directly. Declining is
-std::pair<std::size_t, std::size_t> float_token_layout(const std::string& s)
+    // always safe: the caller then falls back to a slower, exact conversion.
-{
+    const auto fast = [](const std::string & s, double & out)
    std::size_t dot = std::string::npos;
    std::size_t mantissa_end = s.size();
    for (std::size_t i = 0; i < s.size(); ++i)
    {
-        if (s[i] == '.')
+        return nlohmann::detail::parse_float_fast(s.data(), s.data() + s.size(), out);
        {
            dot = i;
        }
        else if (s[i] == 'e' || s[i] == 'E')
        {
            mantissa_end = i;
            break;
        }
    }
    return {dot, mantissa_end};
 }
 template<typename FloatType>
 FloatType parse_native(const std::string& s)
 {
    const auto layout = float_token_layout(s);
    return nlohmann::detail::parse_float_native<FloatType>(s.data(), s.data() + s.size(), layout.first, layout.second);
 }
 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>;
+    double out = 0;
-        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)
+#if defined(FLT_EVAL_METHOD) && FLT_EVAL_METHOD != 0
-        {
+    // without true double precision, the fast path declines everything
-            CAPTURE(t);
+    CHECK_FALSE(fast("1.5", out));
-            const auto layout = float_token_layout(t);
+#else
-            const char* const first = t.data();
+    CHECK(fast("1.5", out));
-            const char* const last = first + t.size();
+    CHECK(out == 1.5);
-            const auto d = nlohmann::detail::convert_float<double>(first, last, layout.first, layout.second);
+    CHECK(fast("+2.5e1", out));
-            const auto f = nlohmann::detail::convert_float<float>(first, last, layout.first, layout.second);
+    CHECK(out == 25.0);
-            const auto ld = nlohmann::detail::convert_float<long double>(first, last, layout.first, layout.second);
+    CHECK(fast("-25E-1", out));
-            CHECK(bits_of(d) == bits_of(json::parse(t).get<double>()));
+    CHECK(out == -2.5);
-            CHECK(bits_of(f) == bits_of(float_json::parse(t).get<float>()));
+    CHECK(fast("1e", out));
-            CHECK(ld == long_double_json::parse(t).get<long double>());
+    CHECK(out == 1.0);
-        }
+#endif
-    }
+
    // not a number
    CHECK_FALSE(fast("", out));
    CHECK_FALSE(fast("-", out));
    CHECK_FALSE(fast(".", out));
    CHECK_FALSE(fast("1.2.3", out));
    CHECK_FALSE(fast("1x", out));
    CHECK_FALSE(fast("1e+", out));
    CHECK_FALSE(fast("1e1x", out));
    // numbers that are not represented exactly on the fast path
    CHECK_FALSE(fast("12345678901234567890", out));
    CHECK_FALSE(fast("1e10000", out));
    CHECK_FALSE(fast("9007199254740993", out));
    CHECK_FALSE(fast("1e23", out));
    CHECK_FALSE(fast("1e-23", out));
 }
 namespace
@@ -906,6 +806,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")
@@ -1303,33 +1237,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;
@@ -1351,51 +1278,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")
@@ -1409,76 +1315,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});
    }
 }
@@ -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);
    }
Author	SHA1	Message	Date
Niels Lohmann	9df8de47a5	Merge branch 'develop' into claude/issue-3885-3dcafd Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-01 13:07:17 +02:00
Niels Lohmann	57371b0977	Avoid //include in Meson-generated CMake target for prefix / As CMake's generated targets file does, reset _IMPORT_PREFIX to an empty string when it resolves to "/". Reported by @heitbaum in #5587. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-01 13:07:17 +02:00
Niels Lohmann	11e75a5428	Cancel CI runs of merged and closed pull requests (#5748 )	2026-10-01 10:53:10 +02:00
Niels Lohmann	2c65caa5bf	Merge branch 'develop' into claude/issue-3885-3dcafd Conflicts: - Makefile: include.zip lists both develop's $(AMALGAMATED_LITERALS_FILE) and this PR's meson_options.txt - meson.build: kept this PR's install_subdir(incdir / 'nlohmann'), which already installs develop's new json_literals.hpp in both header modes, in place of develop's per-file install_headers() lines Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 20:31:07 +02:00
Niels Lohmann	38528b4a38	Merge branch 'develop' into claude/issue-3885-3dcafd Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 20:58:21 +02:00
Niels Lohmann	9cbe62efb0	Fix the Meson CMake target for includedir or datadir outside the prefix nlohmann_jsonTargets.cmake always prepended the prefix computed from the file's location to includedir. With an absolute includedir outside the prefix (as Nix passes for packages with a separate dev output), this gave "<prefix>//abs/include"; with an absolute datadir outside the prefix, the number of ".." was derived from the absolute path and the prefix resolved to "/". In both cases find_package(nlohmann_json) failed with "Imported target includes non-existent path". Use the absolute include directory in these cases, as CMake's install(EXPORT) does, and check it in CI. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 18:23:27 +02:00
Niels Lohmann	471c7678cf	Merge branch 'develop' into claude/issue-3885-3dcafd Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 17:50:55 +02:00
Niels Lohmann	4fabfb27f7	Merge branch 'develop' into claude/issue-3885-3dcafd Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 16:07:30 +02:00
Niels Lohmann	71b4eaf743	Document the Meson options and check them in CI Describe the options of meson.build in FILES.md and in the Meson section of the package manager documentation, which so far said that a Meson installation always uses the default configuration. The ci_meson_install job now also installs with non-default options and checks that the headers of the multi-header version are installed, that the definitions reach the pkg-config file and the CMake target, and that find_package still works. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 14:51:27 +02:00
Niels Lohmann	2790175d79	Add the JSON_* definitions to the CMake pkg-config file The installed pkg-config file only had the include path, so a pkg-config user of a library installed with, for example, -DJSON_Diagnostics=ON compiled without JSON_DIAGNOSTICS=1, unlike users of the CMake target. Append the same definitions the target has. For the default options, the file is unchanged. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 14:50:39 +02:00
Niels Lohmann	cc9fafa0e1	Complete the Meson options and match CMake's compile definitions Finish the Meson changes from #4452: - Offer all eight options that change the CMake target, named like the CMake options without the JSON_ prefix. MultipleHeaders defaults to false so that existing Meson users keep the single header. - Add a compile definition only for an option that differs from its default, exactly as target_compile_definitions does. Before, the GlobalUDLs and ImplicitConversions definitions were inverted and were also added in the default configuration. - Keep the nlohmann_json_multiple_headers dependency that earlier versions of meson.build provided. - Put the definitions into the pkg-config file and the Meson-generated nlohmann_jsonTargets.cmake, and install the pkg-config file into <datadir>/pkgconfig like CMake does. - Ship meson_options.txt in include.zip, since meson.build now reads options and the zip is documented as a Meson subproject. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 14:50:10 +02:00
Dylan Baker	8d6d1264a7	Add meson information to FILES.md Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:47:12 +02:00
Dylan Baker	d75f9ab161	meson: add support for the ImplictConversions option Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:47:04 +02:00
Dylan Baker	c3774be4e2	meson: add support for the GlobalUDLs option Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:47:03 +02:00
Dylan Baker	91365ca3b2	meson: handle single header and multiheader the same way CMake does This uses a meson option (set in `meson_options.txt`) to control whether multi-header or single-header setup is wanted. Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:47:02 +02:00
Dylan Baker	605cc6c81d	meson: set the C++ standard to C++11 Matching the CMake as closely as possible, as Meson doesn't have C++11 feature checks like CMAke does. Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:47:01 +02:00
Dylan Baker	f012b85d06	meson: use `install_subdir` for headers This makes a single call to install the entire directory, and doesn't need an update if any new headers are added. It also will simplify bringing the Meson and CMake builds into allignment on how they handle the multi-header vs single-header setups. Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:46:56 +02:00
Dylan Baker	243b6e20e3	meson: use `override_dependency()` to set dependencies This simplifies the use of json as a subproject. Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:46:55 +02:00
Dylan Baker	0a0d5623be	meson: set a minimum Meson version Without a version set meson will give no developer warnings, including deprecations. 0.64 was selected as it's quite old, it's the newest version supported by muon (a pure C Meson implementation), and there's nothing complicated going on here. Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:46:55 +02:00
Dylan Baker	22c9ce3f21	meson: Indent code inside an if block for better readability Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:46:49 +02:00
Niels Lohmann	0d2240ad1e	Install CMake package config files with Meson A Meson installation only provided the headers and a pkg-config file, so consumers using find_package(nlohmann_json) could not find the library. Meson now also installs nlohmann_jsonConfig.cmake and nlohmann_jsonConfigVersion.cmake from the existing templates, plus a static nlohmann_jsonTargets.cmake that defines the header-only imported target with a relocatable include path. A new CI job installs with Meson and builds tests/cmake_import/project against the result. Closes #3885 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 14:25:10 +02:00
`@@ -20,4 +20,4 @@ The class contains a slightly modified version of the Grisu2 algorithm from Flor`

	`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 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 © 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 © 2021 The fast_float authors`