diff --git a/.github/workflows/badges.yml b/.github/workflows/badges.yml
index adc7f2e17..ca1c4c904 100644
--- a/.github/workflows/badges.yml
+++ b/.github/workflows/badges.yml
@@ -22,7 +22,7 @@ jobs:
         libopenblas-dev liblapacke-dev lcov
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: master
 
diff --git a/.github/workflows/build_and_test.yml b/.github/workflows/build_and_test.yml
index 5c6cb0704..441b86d83 100644
--- a/.github/workflows/build_and_test.yml
+++ b/.github/workflows/build_and_test.yml
@@ -10,8 +10,11 @@ on:
   push:
 
 env:
-  WINDOWS_BASEKIT_URL: https://registrationcenter-download.intel.com/akdlm/IRC_NAS/f5881e61-dcdc-40f1-9bd9-717081ac623c/intel-oneapi-base-toolkit-2025.2.1.46_offline.exe
   LINUX_BASEKIT_URL: https://registrationcenter-download.intel.com/akdlm/IRC_NAS/3b7a16b3-a7b0-460f-be16-de0d64fa6b1e/intel-oneapi-base-toolkit-2025.2.1.44_offline.sh
+  WINDOWS_TOOLKIT_URL: https://registrationcenter-download.intel.com/akdlm/IRC_NAS/bae85ab1-cfcd-4251-8d42-a0c27949ea33/intel-oneapi-toolkit-2026.0.0.193_offline.exe
+  WINDOWS_MKL_COMPONENTS: intel.oneapi.win.cpp-dpcpp-common:intel.oneapi.win.mkl.devel:intel.oneapi.win.tbb.devel:intel.oneapi.win.dpl
+  WINDOWS_ONEAPI_CACHE_NUMBER: 1
+  ONEAPI_VS_VER: vs2026
 
 
 jobs:
@@ -40,7 +43,7 @@ jobs:
 
       - name: Cache installed packages
         id: cache-apt
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: ~/apt-install-cache
           key: apt-installed-${{ runner.os }}-${{ env.APT_HASH }}
@@ -67,7 +70,7 @@ jobs:
         shell: bash
         run: echo ${{ env.BRANCH_NAME }}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ env.BRANCH_NAME }}
 
@@ -100,7 +103,7 @@ jobs:
 
       - name: Cache installed packages
         id: cache-apt
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: ~/apt-install-cache
           key: apt-installed-${{ runner.os }}-${{ env.APT_HASH }}
@@ -125,7 +128,7 @@ jobs:
 
       - name: Cache Intel OneAPI
         id: cache-oneapi
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: /opt/intel
           key: intel-oneapi-linux-${{ env.ONEAPI_HASH }}
@@ -142,7 +145,7 @@ jobs:
         shell: bash
         run: echo ${{ env.BRANCH_NAME }}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ env.BRANCH_NAME }}
 
@@ -159,7 +162,7 @@ jobs:
           mkdir -p ./zip/dynadjust-linux-mkl
           mv ./bin/* ./zip/dynadjust-linux-mkl
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: dynadjust-linux-mkl
           path: ./zip/
@@ -187,7 +190,7 @@ jobs:
 
       - name: Cache installed packages
         id: cache-apt
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: ~/apt-install-cache
           key: apt-installed-${{ runner.os }}-${{ env.APT_HASH }}
@@ -214,13 +217,13 @@ jobs:
         shell: bash
         run: echo ${{ env.BRANCH_NAME }}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ env.BRANCH_NAME }}
 
       - name: Cache static xerces
         id: cache-xerces
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: |
             /usr/local/lib/libxerces-c*.a
@@ -254,7 +257,7 @@ jobs:
           mkdir -p ./zip/dynadjust-linux-static
           mv ./bin/* ./zip/dynadjust-linux-static
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: dynadjust-linux-openblas-static
           path: ./zip/
@@ -277,7 +280,7 @@ jobs:
 
       - name: Cache Homebrew packages
         id: cache-brew
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: |
             /opt/homebrew/Cellar/boost
@@ -304,7 +307,7 @@ jobs:
         shell: bash
         run: echo ${{ env.BRANCH_NAME }}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ env.BRANCH_NAME }}
 
@@ -332,7 +335,7 @@ jobs:
 
       - name: Cache Homebrew packages
         id: cache-brew
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: |
             /opt/homebrew/Cellar/boost
@@ -359,7 +362,7 @@ jobs:
         shell: bash
         run: echo ${{ env.BRANCH_NAME }}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ env.BRANCH_NAME }}
 
@@ -369,7 +372,7 @@ jobs:
           make -j2 VERBOSE=1
           ls -la bin/
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: dynadjust-macos-static
           path: ./bin/
@@ -378,13 +381,12 @@ jobs:
 
   build_windows_dyn_mkl:
     name: Windows build (mkl)
-    runs-on: windows-2025
+    runs-on: windows-2025-vs2026
     env:
       BRANCH_NAME: ${{ github.head_ref || github.ref_name }}
       VCPKG_PACKAGES: boost-geometry boost-process boost-iostreams boost-spirit boost-program-options boost-interprocess xerces-c vcpkg-tool-ninja
       VCPKG_INSTALLATION_ROOT: "C:/vcpkg"
       VCPKG_BINARY_SOURCES: "clear"
-      ONEAPI_VERSION: "2025.2"
 
     steps:
 
@@ -392,11 +394,10 @@ jobs:
       shell: bash
       run: |
         echo VCPKG_HASH=$(echo "${VCPKG_PACKAGES}" | sed "s/ /_/g" | md5sum | cut -f 1 -d" ") >> $GITHUB_ENV
-        echo ONEAPI_HASH=$(echo "${WINDOWS_BASEKIT_URL}" | md5sum | cut -f 1 -d" ") >> $GITHUB_ENV
 
     - name: Cache vcpkg
       id: cache-vcpkg
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: ${{ env.VCPKG_INSTALLATION_ROOT }}/installed
         key: vcpkg-${{ runner.os }}-mkl-${{ env.VCPKG_HASH }}
@@ -406,12 +407,15 @@ jobs:
 
     - name: Cache Intel OneAPI
       id: cache-oneapi
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
-        path: C:\Program Files (x86)\Intel\oneAPI
-        key: intel-oneapi-windows-${{ env.ONEAPI_HASH }}
-        restore-keys: |
-          intel-oneapi-windows-
+        path: |
+          C:\Program Files (x86)\Intel\oneAPI\setvars.bat
+          C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat
+          C:\Program Files (x86)\Intel\oneAPI\compiler
+          C:\Program Files (x86)\Intel\oneAPI\mkl
+          C:\Program Files (x86)\Intel\oneAPI\tbb
+        key: intel-oneapi-windows-${{ env.WINDOWS_ONEAPI_CACHE_NUMBER }}-${{ env.WINDOWS_TOOLKIT_URL }}-${{ env.WINDOWS_MKL_COMPONENTS }}
 
     - name: Install vcpkg prerequisites
       if: steps.cache-vcpkg.outputs.cache-hit != 'true'
@@ -432,35 +436,24 @@ jobs:
       if: steps.cache-oneapi.outputs.cache-hit != 'true'
       shell: powershell
       run: |
-        Write-Host "Installing Intel OneAPI..."
-        $url = $env:WINDOWS_BASEKIT_URL
-        $components = "intel.oneapi.win.mkl.devel"
         $tempExe = Join-Path $env:TEMP "webimage.exe"
-
-        Write-Host "Downloading installer from $url..."
-        curl.exe -L $url -o $tempExe
-
-        Write-Host "Extracting installer..."
-        $installerArgs = "-s -x -f webimage_extracted --log extract.log"
-        $proc = Start-Process -FilePath $tempExe -ArgumentList $installerArgs -NoNewWindow -Wait -PassThru
+        curl.exe --output $tempExe --url $env:WINDOWS_TOOLKIT_URL --retry 5 --retry-delay 5
+        $extract = Start-Process -FilePath $tempExe -ArgumentList "-s -x -f webimage_extracted --log extract.log" -NoNewWindow -Wait -PassThru
         Remove-Item $tempExe -Force
+        if ($extract.ExitCode -ne 0) { exit $extract.ExitCode }
 
         $bootstrapperPath = Join-Path -Path (Join-Path $PWD "webimage_extracted") "bootstrapper.exe"
-
-        Write-Host "Listing available components..."
-        $procBootstrap = Start-Process -FilePath $bootstrapperPath -ArgumentList "--list-components" -NoNewWindow -Wait -PassThru -RedirectStandardOutput components
-        get-content components
-
-        Write-Host "Running bootstrapper..."
+        $components = $env:WINDOWS_MKL_COMPONENTS
         $bootstrapArgs = "-s --action install --components=$components --eula=accept -p=NEED_VS2017_INTEGRATION=0 -p=NEED_VS2019_INTEGRATION=0 -p=NEED_VS2022_INTEGRATION=0 --log-dir=."
-        $procBootstrap = Start-Process -FilePath $bootstrapperPath -ArgumentList $bootstrapArgs -NoNewWindow -Wait -PassThru
+        $bootstrap = Start-Process -FilePath $bootstrapperPath -ArgumentList $bootstrapArgs -NoNewWindow -Wait -PassThru
         Remove-Item -Recurse -Force "webimage_extracted"
+        exit $bootstrap.ExitCode
 
     - name: Check branch name
       shell: bash
       run: echo ${{ env.BRANCH_NAME }}
 
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         ref: ${{ env.BRANCH_NAME }}
         path: "./src"
@@ -472,37 +465,35 @@ jobs:
         curl.exe -L -O https://www.codesynthesis.com/download/xsd/4.2/libxsd-4.2.0.tar.gz
         tar zxvf libxsd-4.2.0.tar.gz
 
-    - name: Extract OneAPI version
-      shell: powershell
-      run: |
-        # Extract version from URL (e.g., 2025.2.1 -> 2025.2)
-        $url = "${{ env.WINDOWS_BASEKIT_URL }}"
-        if ($url -match 'toolkit-(\d+\.\d+)\.\d+') {
-          $version = $matches[1]
-          echo "ONEAPI_VERSION=$version" >> $env:GITHUB_ENV
-          Write-Host "Extracted OneAPI version: $version"
-        } else {
-          Write-Host "Failed to extract version, using default 2025.2"
-          echo "ONEAPI_VERSION=2025.2" >> $env:GITHUB_ENV
-        }
+    - name: Add MSBuild to PATH
+      uses: microsoft/setup-msbuild@v3
+      with:
+        vs-version: '[18.0,19.0)'
 
     - name: Build with CMake
       working-directory: "./src"
       shell: cmd
       run: |
         vcpkg.exe integrate install
-        call "C:\Program Files (x86)\Intel\oneAPI\compiler\%ONEAPI_VERSION%\env\vars.bat"
-        call "C:\Program Files (x86)\Intel\oneAPI\mkl\%ONEAPI_VERSION%\env\vars.bat"
-        set XSDROOT=%cd%\libxsd-4.2.0
-        set VPKG_INCLUDE=${{ env.VCPKG_INSTALLATION_ROOT }}\installed\x64-windows\include
-        set INCLUDE=%XSDROOT%;%VPKG_INCLUDE%;%INCLUDE%
-        set UseEnv=true
+        set "VS2026INSTALLDIR=C:\Program Files\Microsoft Visual Studio\18\Enterprise"
+        call "C:\Program Files\Microsoft Visual Studio\18\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+        if errorlevel 1 exit /b %errorlevel%
+        if exist "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat" (
+          call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat" %ONEAPI_VS_VER%
+          if errorlevel 1 call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+        ) else (
+          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+        )
+        if errorlevel 1 exit /b %errorlevel%
+        if not defined MKLROOT set "MKLROOT=C:\Program Files (x86)\Intel\oneAPI\mkl\latest"
         cmake -DUSE_MKL=ON ^
+              "-DMKL_DIR:PATH=%MKLROOT%\lib\cmake\mkl" ^
+              -DMKL_THREADING=sequential ^
               -DVCPKG_MANIFEST_MODE=OFF ^
               -DCMAKE_TOOLCHAIN_FILE"=${{ env.VCPKG_INSTALLATION_ROOT }}/scripts/buildsystems/vcpkg.cmake" ^
               -DBUILD_TESTING=OFF ^
               -DUSE_UNITY_BUILD=ON ^
-              -G "Visual Studio 17 2022" -A x64 dynadjust
+              -G "Visual Studio 18 2026" -A x64 dynadjust
         cmake --build %cd% --config Release --parallel 2
 
     - name: Collate artifacts
@@ -516,7 +507,7 @@ jobs:
         cp -f ./src/bin/*.exe ./release/DynAdjust-Windows/ 2>/dev/null || true
         ls -la ./release/DynAdjust-Windows/
 
-    - uses: actions/upload-artifact@v4
+    - uses: actions/upload-artifact@v7
       with:
         name: dynadjust-windows-mkl
         path: ./release/
@@ -525,7 +516,7 @@ jobs:
 
   build_windows_dyn_openblas:
     name: Windows build (openblas)
-    runs-on: windows-2025
+    runs-on: windows-2025-vs2026
     env:
       BRANCH_NAME: ${{ github.head_ref || github.ref_name }}
       VCPKG_PACKAGES: boost-geometry boost-process boost-iostreams boost-spirit boost-program-options boost-interprocess xerces-c vcpkg-tool-ninja openblas lapack-reference
@@ -541,7 +532,7 @@ jobs:
 
     - name: Cache vcpkg
       id: cache-vcpkg
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: ${{ env.VCPKG_INSTALLATION_ROOT }}/installed
         key: vcpkg-${{ runner.os }}-openblas-${{ env.VCPKG_HASH }}
@@ -568,7 +559,7 @@ jobs:
       shell: bash
       run: echo ${{ env.BRANCH_NAME }}
 
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         ref: ${{ env.BRANCH_NAME }}
         path: "./src"
@@ -581,21 +572,22 @@ jobs:
         tar zxvf libxsd-4.2.0.tar.gz
 
     - name: Add MSBuild to PATH
-      uses: microsoft/setup-msbuild@v2
+      uses: microsoft/setup-msbuild@v3
+      with:
+        vs-version: '[18.0,19.0)'
 
     - name: Build with CMake
       working-directory: "./src"
       shell: cmd
       run: |
         vcpkg.exe integrate install
-        setx WindowsTargetPlatformVersion 10.0.22621.0
         set XSDROOT=%cd%\libxsd-4.2.0
         cmake -DUSE_MKL=OFF ^
               -DVCPKG_MANIFEST_MODE=OFF ^
               -DBUILD_TESTING=OFF ^
               -DUSE_UNITY_BUILD=ON ^
               -DCMAKE_TOOLCHAIN_FILE"=${{ env.VCPKG_INSTALLATION_ROOT }}/scripts/buildsystems/vcpkg.cmake" ^
-              -G "Visual Studio 17 2022" -A x64 dynadjust
+              -G "Visual Studio 18 2026" -A x64 dynadjust
         cmake --build %cd% --config Release --parallel 2
 
     - name: Collate artifacts
@@ -609,7 +601,7 @@ jobs:
         cp -f ./src/bin/*.exe ./release/DynAdjust-Windows/ 2>/dev/null || true
         ls -la ./release/DynAdjust-Windows/
 
-    - uses: actions/upload-artifact@v4
+    - uses: actions/upload-artifact@v7
       with:
         name: dynadjust-windows-openblas
         path: ./release/
@@ -646,7 +638,7 @@ jobs:
         shell: bash
         run: echo ${{ env.BRANCH_NAME }}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ env.BRANCH_NAME }}
 
@@ -662,7 +654,7 @@ jobs:
 
       - name: Upload test log on failure
         if: failure()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: ctest-linux-openblas-log
           path: Testing/Temporary/LastTest.log
@@ -728,7 +720,7 @@ jobs:
 
       - name: Cache Intel OneAPI
         id: cache-oneapi
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: /opt/intel
           key: intel-oneapi-linux-${{ env.ONEAPI_HASH }}
@@ -745,7 +737,7 @@ jobs:
         shell: bash
         run: echo ${{ env.BRANCH_NAME }}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ env.BRANCH_NAME }}
 
@@ -767,7 +759,7 @@ jobs:
 
       - name: Upload test log on failure
         if: failure()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: ctest-linux-mkl-log
           path: Testing/Temporary/LastTest.log
@@ -863,13 +855,12 @@ jobs:
 
   ctest_windows_dyn_mkl:
     name: Build and run ctests on Windows (mkl)
-    runs-on: windows-2025
+    runs-on: windows-2025-vs2026
     env:
       BRANCH_NAME: ${{ github.head_ref || github.ref_name }}
       VCPKG_PACKAGES: boost-geometry boost-process boost-iostreams boost-spirit boost-program-options boost-interprocess boost-filesystem boost-timer boost-date-time boost-chrono xerces-c vcpkg-tool-ninja
       VCPKG_INSTALLATION_ROOT: "C:/vcpkg"
       VCPKG_BINARY_SOURCES: "clear"
-      ONEAPI_VERSION: "2025.2"
 
     steps:
 
@@ -883,11 +874,10 @@ jobs:
       shell: bash
       run: |
         echo VCPKG_HASH=$(echo "${VCPKG_PACKAGES}" | sed "s/ /_/g" | md5sum | cut -f 1 -d" ") >> $GITHUB_ENV
-        echo ONEAPI_HASH=$(echo "${WINDOWS_BASEKIT_URL}" | md5sum | cut -f 1 -d" ") >> $GITHUB_ENV
 
     - name: Cache vcpkg
       id: cache-vcpkg
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: ${{ env.VCPKG_INSTALLATION_ROOT }}/installed
         key: vcpkg-${{ runner.os }}-mkl-${{ env.VCPKG_HASH }}
@@ -897,12 +887,15 @@ jobs:
 
     - name: Cache Intel OneAPI
       id: cache-oneapi
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
-        path: C:\Program Files (x86)\Intel\oneAPI
-        key: intel-oneapi-windows-${{ env.ONEAPI_HASH }}
-        restore-keys: |
-          intel-oneapi-windows-
+        path: |
+          C:\Program Files (x86)\Intel\oneAPI\setvars.bat
+          C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat
+          C:\Program Files (x86)\Intel\oneAPI\compiler
+          C:\Program Files (x86)\Intel\oneAPI\mkl
+          C:\Program Files (x86)\Intel\oneAPI\tbb
+        key: intel-oneapi-windows-${{ env.WINDOWS_ONEAPI_CACHE_NUMBER }}-${{ env.WINDOWS_TOOLKIT_URL }}-${{ env.WINDOWS_MKL_COMPONENTS }}
 
     - name: Install vcpkg prerequisites
       if: steps.cache-vcpkg.outputs.cache-hit != 'true'
@@ -923,35 +916,24 @@ jobs:
       if: steps.cache-oneapi.outputs.cache-hit != 'true'
       shell: powershell
       run: |
-        Write-Host "Installing Intel OneAPI..."
-        $url = $env:WINDOWS_BASEKIT_URL
-        $components = "intel.oneapi.win.mkl.devel"
         $tempExe = Join-Path $env:TEMP "webimage.exe"
-
-        Write-Host "Downloading installer from $url..."
-        curl.exe -L $url -o $tempExe
-
-        Write-Host "Extracting installer..."
-        $installerArgs = "-s -x -f webimage_extracted --log extract.log"
-        $proc = Start-Process -FilePath $tempExe -ArgumentList $installerArgs -NoNewWindow -Wait -PassThru
+        curl.exe --output $tempExe --url $env:WINDOWS_TOOLKIT_URL --retry 5 --retry-delay 5
+        $extract = Start-Process -FilePath $tempExe -ArgumentList "-s -x -f webimage_extracted --log extract.log" -NoNewWindow -Wait -PassThru
         Remove-Item $tempExe -Force
+        if ($extract.ExitCode -ne 0) { exit $extract.ExitCode }
 
         $bootstrapperPath = Join-Path -Path (Join-Path $PWD "webimage_extracted") "bootstrapper.exe"
-
-        Write-Host "Listing available components..."
-        $procBootstrap = Start-Process -FilePath $bootstrapperPath -ArgumentList "--list-components" -NoNewWindow -Wait -PassThru -RedirectStandardOutput components
-        get-content components
-
-        Write-Host "Running bootstrapper..."
+        $components = $env:WINDOWS_MKL_COMPONENTS
         $bootstrapArgs = "-s --action install --components=$components --eula=accept -p=NEED_VS2017_INTEGRATION=0 -p=NEED_VS2019_INTEGRATION=0 -p=NEED_VS2022_INTEGRATION=0 --log-dir=."
-        $procBootstrap = Start-Process -FilePath $bootstrapperPath -ArgumentList $bootstrapArgs -NoNewWindow -Wait -PassThru
+        $bootstrap = Start-Process -FilePath $bootstrapperPath -ArgumentList $bootstrapArgs -NoNewWindow -Wait -PassThru
         Remove-Item -Recurse -Force "webimage_extracted"
+        exit $bootstrap.ExitCode
 
     - name: Check branch name
       shell: bash
       run: echo ${{ env.BRANCH_NAME }}
 
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         ref: ${{ env.BRANCH_NAME }}
         path: "./src"
@@ -963,48 +945,62 @@ jobs:
         curl.exe -L -O https://www.codesynthesis.com/download/xsd/4.2/libxsd-4.2.0.tar.gz
         tar zxvf libxsd-4.2.0.tar.gz
 
-    - name: Extract OneAPI version
-      shell: powershell
-      run: |
-        # Extract version from URL (e.g., 2025.2.1 -> 2025.2)
-        $url = "${{ env.WINDOWS_BASEKIT_URL }}"
-        if ($url -match 'toolkit-(\d+\.\d+)\.\d+') {
-          $version = $matches[1]
-          echo "ONEAPI_VERSION=$version" >> $env:GITHUB_ENV
-          Write-Host "Extracted OneAPI version: $version"
-        } else {
-          Write-Host "Failed to extract version, using default 2025.2"
-          echo "ONEAPI_VERSION=2025.2" >> $env:GITHUB_ENV
-        }
+    - name: Add MSBuild to PATH
+      uses: microsoft/setup-msbuild@v3
+      with:
+        vs-version: '[18.0,19.0)'
 
     - name: Build with CMake
       working-directory: "./src"
       shell: cmd
       run: |
         vcpkg.exe integrate install
-        call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat" intel64 vs2022
-        set XSDROOT=%cd%\libxsd-4.2.0
-        set VPKG_INCLUDE=${{ env.VCPKG_INSTALLATION_ROOT }}\installed\x64-windows\include
-        set INCLUDE=%XSDROOT%;%VPKG_INCLUDE%;%INCLUDE%
-        set UseEnv=true
+        set "VS2026INSTALLDIR=C:\Program Files\Microsoft Visual Studio\18\Enterprise"
+        call "C:\Program Files\Microsoft Visual Studio\18\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+        if errorlevel 1 exit /b %errorlevel%
+        if exist "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat" (
+          call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat" %ONEAPI_VS_VER%
+          if errorlevel 1 call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+        ) else (
+          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+        )
+        if errorlevel 1 exit /b %errorlevel%
+        if not defined MKLROOT set "MKLROOT=C:\Program Files (x86)\Intel\oneAPI\mkl\latest"
         cmake -DUSE_MKL=ON ^
+              "-DMKL_DIR:PATH=%MKLROOT%\lib\cmake\mkl" ^
+              -DMKL_THREADING=sequential ^
               -DBUILD_TESTING=ON ^
               -DVCPKG_MANIFEST_MODE=OFF ^
               -DCMAKE_TOOLCHAIN_FILE"=${{ env.VCPKG_INSTALLATION_ROOT }}/scripts/buildsystems/vcpkg.cmake" ^
-              -G "Visual Studio 17 2022" -A x64 dynadjust
+              -G "Visual Studio 18 2026" -A x64 dynadjust
         cmake --build %cd% --config Release --parallel 2
+        cmake --build %cd% --config Release --target unit_tests --parallel 2
         dir bin\
 
     - name: Run tests
       working-directory: "./src"
       shell: cmd
       run: |
-        call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-        ctest --timeout 20 --output-on-failure -C Release 2>&1 | powershell -Command "$input | Tee-Object -FilePath ctest_output.log"
+        set "VS2026INSTALLDIR=C:\Program Files\Microsoft Visual Studio\18\Enterprise"
+        call "C:\Program Files\Microsoft Visual Studio\18\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+        if errorlevel 1 exit /b %errorlevel%
+        if exist "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat" (
+          call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat" %ONEAPI_VS_VER%
+          if errorlevel 1 call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+        ) else (
+          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+        )
+        if errorlevel 1 exit /b %errorlevel%
+        set "MKL_NUM_THREADS=1"
+        set "OMP_NUM_THREADS=1"
+        set "MKL_DYNAMIC=FALSE"
+        set "MKL_DOMAIN_NUM_THREADS=MKL_DOMAIN_ALL=1"
+        set "MKL_THREADING_LAYER=SEQUENTIAL"
+        ctest --timeout 120 --output-on-failure --stop-on-failure -C Release -E "^unit-MatrixTest$" 2>&1 | powershell -Command "$input | Tee-Object -FilePath ctest_output.log"
 
     - name: Upload test log on failure
       if: failure()
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v7
       with:
         name: ctest-windows-mkl-log
         path: src/Testing/Temporary/LastTest.log
@@ -1084,7 +1080,7 @@ jobs:
 
       - name: Cache Intel OneAPI
         id: cache-oneapi
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: /opt/intel
           key: intel-oneapi-linux-${{ env.ONEAPI_HASH }}
@@ -1101,12 +1097,12 @@ jobs:
         shell: bash
         run: echo ${{ env.BRANCH_NAME }}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ env.BRANCH_NAME }}
 
       - name: Download MKL binaries artifact
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v7
         with:
           name: dynadjust-linux-mkl
           path: ./artifacts
@@ -1145,8 +1141,9 @@ jobs:
           # Source Intel OneAPI environment
           source /opt/intel/oneapi/setvars.sh
 
-          # Modify PATH to use our binaries
+          # Modify PATH and LD_LIBRARY_PATH to use our binaries
           export PATH="../bin:$PATH"
+          export LD_LIBRARY_PATH="../bin:${LD_LIBRARY_PATH:-}"
 
           # Run the test script and capture output
           set +e  # Don't exit on error
@@ -1169,8 +1166,9 @@ jobs:
           # Source Intel OneAPI environment
           source /opt/intel/oneapi/setvars.sh
 
-          # Modify PATH to use our binaries
+          # Modify PATH and LD_LIBRARY_PATH to use our binaries
           export PATH="../bin:$PATH"
+          export LD_LIBRARY_PATH="../bin:${LD_LIBRARY_PATH:-}"
 
           # Run the test script and capture output
           set +e  # Don't exit on error
@@ -1207,12 +1205,12 @@ jobs:
         shell: bash
         run: echo ${{ env.BRANCH_NAME }}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ env.BRANCH_NAME }}
 
       - name: Download static binaries artifact
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v7
         with:
           name: dynadjust-linux-openblas-static
           path: ./artifacts
@@ -1307,12 +1305,12 @@ jobs:
         shell: bash
         run: echo ${{ env.BRANCH_NAME }}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ env.BRANCH_NAME }}
 
       - name: Download static binaries artifact
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v7
         with:
           name: dynadjust-macos-static
           path: ./artifacts
@@ -1386,14 +1384,13 @@ jobs:
 
   test_windows_mkl_binaries:
     name: Test Windows MKL binaries
-    runs-on: windows-2025
+    runs-on: windows-2025-vs2026
     needs: [build_windows_dyn_mkl]
     env:
       BRANCH_NAME: ${{ github.head_ref || github.ref_name }}
       VCPKG_PACKAGES: boost-geometry boost-process boost-iostreams boost-spirit boost-program-options boost-interprocess xerces-c vcpkg-tool-ninja
       VCPKG_INSTALLATION_ROOT: "C:/vcpkg"
       VCPKG_BINARY_SOURCES: "clear"
-      ONEAPI_VERSION: "2025.2"
 
     steps:
       - name: Show CPU information
@@ -1406,11 +1403,10 @@ jobs:
         shell: bash
         run: |
           echo VCPKG_HASH=$(echo "${VCPKG_PACKAGES}" | sed "s/ /_/g" | md5sum | cut -f 1 -d" ") >> $GITHUB_ENV
-          echo ONEAPI_HASH=$(echo "${WINDOWS_BASEKIT_URL}" | md5sum | cut -f 1 -d" ") >> $GITHUB_ENV
 
       - name: Cache vcpkg
         id: cache-vcpkg
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: ${{ env.VCPKG_INSTALLATION_ROOT }}/installed
           key: vcpkg-${{ runner.os }}-mkl-${{ env.VCPKG_HASH }}
@@ -1420,12 +1416,15 @@ jobs:
 
       - name: Cache Intel OneAPI
         id: cache-oneapi
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
-          path: C:\Program Files (x86)\Intel\oneAPI
-          key: intel-oneapi-windows-${{ env.ONEAPI_HASH }}
-          restore-keys: |
-            intel-oneapi-windows-
+          path: |
+            C:\Program Files (x86)\Intel\oneAPI\setvars.bat
+            C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat
+            C:\Program Files (x86)\Intel\oneAPI\compiler
+            C:\Program Files (x86)\Intel\oneAPI\mkl
+            C:\Program Files (x86)\Intel\oneAPI\tbb
+          key: intel-oneapi-windows-${{ env.WINDOWS_ONEAPI_CACHE_NUMBER }}-${{ env.WINDOWS_TOOLKIT_URL }}-${{ env.WINDOWS_MKL_COMPONENTS }}
 
       - name: Install vcpkg prerequisites
         if: steps.cache-vcpkg.outputs.cache-hit != 'true'
@@ -1442,50 +1441,29 @@ jobs:
         if: steps.cache-oneapi.outputs.cache-hit != 'true'
         shell: powershell
         run: |
-          Write-Host "Installing Intel OneAPI..."
-          $url = $env:WINDOWS_BASEKIT_URL
-          $components = "intel.oneapi.win.mkl.devel"
           $tempExe = Join-Path $env:TEMP "webimage.exe"
-
-          Write-Host "Downloading installer from $url..."
-          curl.exe -L $url -o $tempExe
-
-          Write-Host "Extracting installer..."
-          $installerArgs = "-s -x -f webimage_extracted --log extract.log"
-          $proc = Start-Process -FilePath $tempExe -ArgumentList $installerArgs -NoNewWindow -Wait -PassThru
+          curl.exe --output $tempExe --url $env:WINDOWS_TOOLKIT_URL --retry 5 --retry-delay 5
+          $extract = Start-Process -FilePath $tempExe -ArgumentList "-s -x -f webimage_extracted --log extract.log" -NoNewWindow -Wait -PassThru
           Remove-Item $tempExe -Force
+          if ($extract.ExitCode -ne 0) { exit $extract.ExitCode }
 
           $bootstrapperPath = Join-Path -Path (Join-Path $PWD "webimage_extracted") "bootstrapper.exe"
-
-          Write-Host "Running bootstrapper..."
+          $components = $env:WINDOWS_MKL_COMPONENTS
           $bootstrapArgs = "-s --action install --components=$components --eula=accept -p=NEED_VS2017_INTEGRATION=0 -p=NEED_VS2019_INTEGRATION=0 -p=NEED_VS2022_INTEGRATION=0 --log-dir=."
-          $procBootstrap = Start-Process -FilePath $bootstrapperPath -ArgumentList $bootstrapArgs -NoNewWindow -Wait -PassThru
+          $bootstrap = Start-Process -FilePath $bootstrapperPath -ArgumentList $bootstrapArgs -NoNewWindow -Wait -PassThru
           Remove-Item -Recurse -Force "webimage_extracted"
-
-      - name: Extract OneAPI version
-        shell: powershell
-        run: |
-          # Extract version from URL (e.g., 2025.2.1 -> 2025.2)
-          $url = "${{ env.WINDOWS_BASEKIT_URL }}"
-          if ($url -match 'toolkit-(\d+\.\d+)\.\d+') {
-            $version = $matches[1]
-            echo "ONEAPI_VERSION=$version" >> $env:GITHUB_ENV
-            Write-Host "Extracted OneAPI version: $version"
-          } else {
-            Write-Host "Failed to extract version, using default 2025.2"
-            echo "ONEAPI_VERSION=2025.2" >> $env:GITHUB_ENV
-          }
+          exit $bootstrap.ExitCode
 
       - name: Check branch name
         shell: bash
         run: echo ${{ env.BRANCH_NAME }}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ env.BRANCH_NAME }}
 
       - name: Download binaries artifact
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v7
         with:
           name: dynadjust-windows-mkl
           path: ./artifacts
@@ -1516,8 +1494,19 @@ jobs:
         working-directory: ./sampleData
         shell: cmd
         run: |
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-          set PATH=..\bin;%PATH%
+          set "VS2026INSTALLDIR=C:\Program Files\Microsoft Visual Studio\18\Enterprise"
+          call "C:\Program Files\Microsoft Visual Studio\18\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+          if errorlevel 1 exit /b %errorlevel%
+          if exist "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat" (
+            call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat" %ONEAPI_VS_VER%
+            if errorlevel 1 call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+          ) else (
+            call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+          )
+          if errorlevel 1 exit /b %errorlevel%
+          if not defined ONEAPI_ROOT set "ONEAPI_ROOT=C:\Program Files (x86)\Intel\oneAPI"
+          if not defined MKLROOT set "MKLROOT=%ONEAPI_ROOT%\mkl\latest"
+          set PATH=..\bin;%VCPKG_INSTALLATION_ROOT%\installed\x64-windows\bin;%MKLROOT%\bin;%ONEAPI_ROOT%\compiler\latest\bin;%PATH%
 
           :: Run the commands directly using the correct names
           ..\bin\import.exe -n gnss gnss-network.stn gnss-network.msr
@@ -1543,8 +1532,19 @@ jobs:
         working-directory: ./sampleData
         shell: cmd
         run: |
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-          set PATH=..\bin;%PATH%
+          set "VS2026INSTALLDIR=C:\Program Files\Microsoft Visual Studio\18\Enterprise"
+          call "C:\Program Files\Microsoft Visual Studio\18\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+          if errorlevel 1 exit /b %errorlevel%
+          if exist "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat" (
+            call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat" %ONEAPI_VS_VER%
+            if errorlevel 1 call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+          ) else (
+            call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+          )
+          if errorlevel 1 exit /b %errorlevel%
+          if not defined ONEAPI_ROOT set "ONEAPI_ROOT=C:\Program Files (x86)\Intel\oneAPI"
+          if not defined MKLROOT set "MKLROOT=%ONEAPI_ROOT%\mkl\latest"
+          set PATH=..\bin;%VCPKG_INSTALLATION_ROOT%\installed\x64-windows\bin;%MKLROOT%\bin;%ONEAPI_ROOT%\compiler\latest\bin;%PATH%
 
           :: Run the commands directly using the correct names
           ..\bin\import.exe -n urban urban-network.stn urban-network.msr
@@ -1569,7 +1569,7 @@ jobs:
 
   test_windows_openblas_binaries:
     name: Test Windows OpenBLAS binaries
-    runs-on: windows-2025
+    runs-on: windows-2025-vs2026
     needs: [build_windows_dyn_openblas]
     env:
       BRANCH_NAME: ${{ github.head_ref || github.ref_name }}
@@ -1591,7 +1591,7 @@ jobs:
 
       - name: Cache vcpkg
         id: cache-vcpkg
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: ${{ env.VCPKG_INSTALLATION_ROOT }}/installed
           key: vcpkg-${{ runner.os }}-openblas-${{ env.VCPKG_HASH }}
@@ -1614,12 +1614,12 @@ jobs:
         shell: bash
         run: echo ${{ env.BRANCH_NAME }}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ env.BRANCH_NAME }}
 
       - name: Download binaries artifact
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v7
         with:
           name: dynadjust-windows-openblas
           path: ./artifacts
diff --git a/.github/workflows/check_code_format.yml b/.github/workflows/check_code_format.yml
index 12bb2c4e6..b14d6841f 100644
--- a/.github/workflows/check_code_format.yml
+++ b/.github/workflows/check_code_format.yml
@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6
 
       - name: Install clang-format
         uses: aminya/setup-cpp@v1
diff --git a/.github/workflows/clang_tidy.yml b/.github/workflows/clang_tidy.yml
index 178bc4650..6152ae78b 100644
--- a/.github/workflows/clang_tidy.yml
+++ b/.github/workflows/clang_tidy.yml
@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
     - name: Run clang-tidy
       uses: HorstBaerbel/action-clang-tidy@1.2
       with:
diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index 11c0b81d7..1eff27d04 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -22,7 +22,7 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y ${{ env.PKGS }}
 
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           ref: ${{ env.BRANCH_NAME }}
 
@@ -75,7 +75,7 @@ jobs:
 
       - name: Upload test log on failure
         if: failure()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: ctest-coverage-log
           path: Testing/Temporary/LastTest.log
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
index d857120e1..e526e245d 100644
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -14,7 +14,7 @@ jobs:
     steps:
       -
         name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v6
       -
         name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v1
diff --git a/dynadjust/CMakeLists.txt b/dynadjust/CMakeLists.txt
index b5982f5ec..d910731ef 100644
--- a/dynadjust/CMakeLists.txt
+++ b/dynadjust/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.15)
-project(dynadjust VERSION 1.3.0)
+project(dynadjust VERSION 1.4.1)
 
 option(USE_MKL "Use Intel MKL (Linux and Windows)" OFF)
 option(BUILD_TESTING "Enable testing" OFF)
@@ -59,17 +59,23 @@ if(BUILD_TESTING)
     set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 endif()
 
-# Set output directories for all platforms to use ../bin/
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/../bin)
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/../bin)
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/../bin)
+# Set output directories for all platforms to use ../bin/ (unless overridden)
+if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/../bin)
+endif()
+if(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/../bin)
+endif()
+if(NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY)
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/../bin)
+endif()
 
 # For multi-config generators (Visual Studio, Xcode)
 foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
     string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG_UPPER)
-    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG_UPPER} ${CMAKE_SOURCE_DIR}/../bin)
-    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG_UPPER} ${CMAKE_SOURCE_DIR}/../bin)
-    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG_UPPER} ${CMAKE_SOURCE_DIR}/../bin)
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG_UPPER} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG_UPPER} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG_UPPER} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
 endforeach()
 
 if (BUILD_STATIC)
@@ -189,7 +195,7 @@ else()
 endif()
 message(STATUS "Found XercesC (${XercesC_INCLUDE_DIRS} ${XercesC_LIBRARIES})")
 
-# Static builds need ICU for Xerces transcoding (glibc iconv can't dlopen gconv modules in static binaries)
+# Static builds need ICU for Xerces transcoding (glibc iconv can't dlopen gconv modules in static binaries).
 if(BUILD_STATIC AND UNIX AND NOT APPLE)
     find_package(ICU COMPONENTS uc data)
     if(ICU_FOUND)
@@ -300,10 +306,13 @@ message(STATUS "Found Boost version: ${Boost_VERSION}")
 # Set up libraries
 # ----------------------------------------------------------------------------
 
+find_package(Threads REQUIRED)
+
 set(DNA_LIBRARIES
     ${Boost_LIBRARIES}
     ${XercesC_LIBRARIES}
     ${XERCES_ICU_LIBRARIES}
+    Threads::Threads
 )
 
 # ----------------------------------------------------------------------------
@@ -608,6 +617,23 @@ if(BUILD_STATIC)
             endif()
         endforeach()
 
+        # For MKL builds, add static MKL libraries (MKL::MKL is an imported
+        # target that the generic .a finder above cannot resolve)
+        if(USE_MKL AND MKL_FOUND AND DEFINED ENV{MKLROOT})
+            set(MKL_LIB_DIR "$ENV{MKLROOT}/lib")
+            if(ILP64)
+                set(MKL_INTERFACE_LIB "${MKL_LIB_DIR}/libmkl_intel_ilp64.a")
+            else()
+                set(MKL_INTERFACE_LIB "${MKL_LIB_DIR}/libmkl_intel_lp64.a")
+            endif()
+            list(APPEND STATIC_LIBS_LIST
+                "-Wl,--start-group"
+                "${MKL_INTERFACE_LIB}"
+                "${MKL_LIB_DIR}/libmkl_sequential.a"
+                "${MKL_LIB_DIR}/libmkl_core.a"
+                "-Wl,--end-group")
+        endif()
+
         message("")
         message(STATUS "STATIC_LIBS_LIST=${STATIC_LIBS_LIST}")
         
@@ -759,6 +785,31 @@ if (BUILD_TESTING)
         ${CMAKE_SOURCE_DIR}/include/measurement_types/dnastation.cpp
     )
 
+    set(JSONL_PARSER_TEST_SOURCES
+        ${CMAKE_SOURCE_DIR}/dynadjust/dnaimport/dnaparser_jsonl.cpp
+        ${CMAKE_SOURCE_DIR}/dynadjust/dnaimport/dnaparser_validators.cpp
+        ${CMAKE_SOURCE_DIR}/include/functions/dnastringfuncs.cpp
+        ${CMAKE_SOURCE_DIR}/include/functions/template_instantiations.cpp
+        ${CMAKE_SOURCE_DIR}/include/math/dnamatrix_contiguous.cpp
+        ${CMAKE_SOURCE_DIR}/include/ide/trace.cpp
+        ${CMAKE_SOURCE_DIR}/include/parameters/dnadatum.cpp
+        ${CMAKE_SOURCE_DIR}/include/parameters/dnaellipsoid.cpp
+        ${CMAKE_SOURCE_DIR}/include/parameters/dnaprojection.cpp
+        ${CMAKE_SOURCE_DIR}/include/measurement_types/dnaangle.cpp
+        ${CMAKE_SOURCE_DIR}/include/measurement_types/dnacoordinate.cpp
+        ${CMAKE_SOURCE_DIR}/include/measurement_types/dnadirection.cpp
+        ${CMAKE_SOURCE_DIR}/include/measurement_types/dnadirectionset.cpp
+        ${CMAKE_SOURCE_DIR}/include/measurement_types/dnadistance.cpp
+        ${CMAKE_SOURCE_DIR}/include/measurement_types/dnagpsbaseline.cpp
+        ${CMAKE_SOURCE_DIR}/include/measurement_types/dnagpspoint.cpp
+        ${CMAKE_SOURCE_DIR}/include/measurement_types/dnaheight.cpp
+        ${CMAKE_SOURCE_DIR}/include/measurement_types/dnaheightdifference.cpp
+        ${CMAKE_SOURCE_DIR}/include/measurement_types/dnameasurement.cpp
+        ${CMAKE_SOURCE_DIR}/include/measurement_types/dnastation.cpp
+        ${CMAKE_SOURCE_DIR}/include/measurement_types/dnamsrtally.cpp
+        ${CMAKE_SOURCE_DIR}/include/measurement_types/dnastntally.cpp
+    )
+
     # Test: test_matrix
     add_executable(test_matrix
         ${UNIT_TEST_DIR}/test_matrix.cpp
@@ -867,6 +918,15 @@ if (BUILD_TESTING)
     target_link_libraries(test_gnss_nstat_sort PRIVATE ${DNA_LIBRARIES})
     target_compile_definitions(test_gnss_nstat_sort PRIVATE __BINARY_NAME__="test_gnss_nstat_sort" __BINARY_DESC__="Unit tests for GNSS n-stat sort in alternate units")
 
+    # Test: test_dnaparser_jsonl
+    add_executable(test_dnaparser_jsonl
+        ${UNIT_TEST_DIR}/test_dnaparser_jsonl.cpp
+        ${JSONL_PARSER_TEST_SOURCES}
+    )
+    target_include_directories(test_dnaparser_jsonl PRIVATE ${UNIT_TEST_DIR} ${CMAKE_SOURCE_DIR}/include)
+    target_link_libraries(test_dnaparser_jsonl PRIVATE ${DNA_LIBRARIES})
+    target_compile_definitions(test_dnaparser_jsonl PRIVATE __BINARY_NAME__="test_dnaparser_jsonl" __BINARY_DESC__="Regression tests for JSONL parser")
+
     # Test: test_bst_file_loader (new)
     add_executable(test_bst_file_loader
         ${UNIT_TEST_DIR}/test_bst_file_loader.cpp
@@ -916,6 +976,30 @@ if (BUILD_TESTING)
     target_link_libraries(test_snx_file_writer PRIVATE ${DNA_LIBRARIES})
     target_compile_definitions(test_snx_file_writer PRIVATE __BINARY_NAME__="test_snx_file_writer" __BINARY_DESC__="Unit tests for SNX file writer")
 
+    # Test: test_format_elapsed_time
+    add_executable(test_format_elapsed_time
+        ${UNIT_TEST_DIR}/test_format_elapsed_time.cpp
+    )
+    target_include_directories(test_format_elapsed_time PRIVATE ${UNIT_TEST_DIR} ${CMAKE_SOURCE_DIR}/include)
+    target_compile_definitions(test_format_elapsed_time PRIVATE __BINARY_NAME__="test_format_elapsed_time" __BINARY_DESC__="Unit tests for FormatElapsedTime helper")
+
+    set(UNIT_TEST_TARGETS
+        test_matrix test_msr_to_stn_sort test_bst_file test_asl_file
+        test_aml_file_loader test_bms_file test_network_data_loader
+        test_measurement_processor test_dnaadjust_printer test_gnss_nstat_sort
+        test_dnaparser_jsonl test_bst_file_loader test_asl_file_loader test_bms_file_loader
+        test_snx_file_writer test_format_elapsed_time
+    )
+    if(WIN32)
+        foreach(UNIT_TEST_TARGET IN LISTS UNIT_TEST_TARGETS)
+            # Unit tests compile selected DynAdjust sources directly, so they
+            # must not import DNATYPE_API classes from the shared libraries.
+            target_compile_definitions(${UNIT_TEST_TARGET} PRIVATE BUILD_STATIC)
+        endforeach()
+    endif()
+    add_custom_target(unit_tests)
+    add_dependencies(unit_tests ${UNIT_TEST_TARGETS})
+
     # Register unit tests with CTest
     add_test(NAME unit-MatrixTest COMMAND $<TARGET_FILE:test_matrix>)
     add_test(NAME unit-MsrToStnSortTest COMMAND $<TARGET_FILE:test_msr_to_stn_sort>)
@@ -927,10 +1011,12 @@ if (BUILD_TESTING)
     add_test(NAME unit-MeasurementProcessorTest COMMAND $<TARGET_FILE:test_measurement_processor>)
     add_test(NAME unit-DynAdjustPrinterTest COMMAND $<TARGET_FILE:test_dnaadjust_printer>)
     add_test(NAME unit-GNSSNstatSortTest COMMAND $<TARGET_FILE:test_gnss_nstat_sort>)
+    add_test(NAME unit-DnaParserJsonlTest COMMAND $<TARGET_FILE:test_dnaparser_jsonl>)
     add_test(NAME unit-BstFileLoaderTest COMMAND $<TARGET_FILE:test_bst_file_loader>)
     add_test(NAME unit-AslFileLoaderTest COMMAND $<TARGET_FILE:test_asl_file_loader>)
     add_test(NAME unit-BmsFileLoaderTest COMMAND $<TARGET_FILE:test_bms_file_loader>)
     add_test(NAME unit-SnxFileWriterTest COMMAND $<TARGET_FILE:test_snx_file_writer>)
+    add_test(NAME unit-FormatElapsedTimeTest COMMAND $<TARGET_FILE:test_format_elapsed_time>)
 
     # ........................................................................
     # Functional tests
@@ -947,7 +1033,10 @@ if (BUILD_TESTING)
     add_test(NAME test-gnss-network
         COMMAND $<TARGET_FILE:${DNADIFF_TARGET}> gnss.simult.adj gnss.simult.adj.expected --skip-headers 52 -t 0.001)
 
-    add_test (NAME import-gnss-network-similar COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n gnss_similar gnss-network.stn gnss-network.msr -r itrf2008 --override-input-ref-frame --search-similar-gnss-msr --quiet) 
+    # 1a. gnss network JSONL import
+    add_test (NAME import-gnss-network-jsonl COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n gnss_jsonl gnss-networkstn.jsonl gnss-networkmsr.jsonl -r GDA2020 --flag-unused-stations)
+
+    add_test (NAME import-gnss-network-similar COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n gnss_similar gnss-network.stn gnss-network.msr -r itrf2008 --override-input-ref-frame --search-similar-gnss-msr --quiet)
     add_test (NAME import-gnss-network-exclude COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n gnss_excl gnss-network.stn gnss-network.msr --exclude-stns-assoc-msrs "BEEC,261000380,356000780,349800490" --split) 
     add_test (NAME import-gnss-network-scaled COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n gnss_scaled gnss-network.stn gnss-network.msr --baseline-scalar-file gnss-network.scalars -r GDA94) 
     add_test (NAME import-gnss-network-block1 COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n gnss_b1 gnss-network.stn gnss-network.msr --export-dna --export-xml --single-xml-file --export-asl --export-aml --export-map --output-msr-to-stn --test-integrity -r GDA94 --flag-unused-stations) 
@@ -974,7 +1063,10 @@ if (BUILD_TESTING)
     add_test (NAME import-urban-network COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n urban urban-network.stn urban-network.msr --flag-unused-stations)
     add_test (NAME geoid-urban-network COMMAND $<TARGET_FILE:${DNAGEOID_TARGET}> urban -g urban-network-geoid.gsb --export-dna-geo)
     add_test (NAME segment-urban-network COMMAND $<TARGET_FILE:${DNASEGMENT_TARGET}> urban --min 50 --max 150 --test-integrity)
-    add_test (NAME adjust-urban-network-verbose COMMAND $<TARGET_FILE:${DNAADJUST_TARGET}> urban --verbose 3)
+    add_test (NAME import-urban-network-verbose COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n urban_verbose urban-network.stn urban-network.msr --flag-unused-stations)
+    add_test (NAME geoid-urban-network-verbose COMMAND $<TARGET_FILE:${DNAGEOID_TARGET}> urban_verbose -g urban-network-geoid.gsb --export-dna-geo)
+    add_test (NAME segment-urban-network-verbose COMMAND $<TARGET_FILE:${DNASEGMENT_TARGET}> urban_verbose --min 50 --max 150 --test-integrity)
+    add_test (NAME adjust-urban-network-verbose COMMAND $<TARGET_FILE:${DNAADJUST_TARGET}> urban_verbose --verbose 3)
     add_test (NAME adjust-urban-network COMMAND $<TARGET_FILE:${DNAADJUST_TARGET}> urban --output-adj-msr --phased --stn-corrections --export-sinex-file --export-xml-stn-file --export-dna-stn-file --output-pos-uncertainty --export-dna-msr --export-xml-msr)
     add_test (NAME plot-urban-network-01 COMMAND $<TARGET_FILE:${DNAPLOT_TARGET}> urban --phased --label-sta --correction-arrows --label-corr --compute-corrections --scale-arrows 10.5 --error-ellipse --positional-uncertainty --scale-ellipse-c 10.5)
     add_test (NAME plot-urban-network-02 COMMAND $<TARGET_FILE:${DNAPLOT_TARGET}> urban --phased --label-sta --label-constraints --correction-arrows --label-corr --compute-corrections --scale-arrows 10.5 --error-ellipse --positional-uncertainty --scale-ellipse-c 10.5 --block-number 2 --alternate-name)
@@ -1098,7 +1190,7 @@ if (BUILD_TESTING)
     add_test (NAME test-urban-phased-network COMMAND $<TARGET_FILE:${DNADIFF_TARGET}> urban.phased.adj urban.phased.adj.expected --skip-to-marker "M Station 1" -t 0.001)
     add_test (NAME test-urban-thread-network COMMAND $<TARGET_FILE:${DNADIFF_TARGET}> urban_mt.phased-mt.adj urban_mt.phased-mt.adj.expected --skip-to-marker "M Station 1" -t 0.01 -v)
 
-    # 8. Source tag preservation in --export-xml (issue #317)
+    # Source tag preservation in --export-xml (issue #317)
     # Import XML data with <Source> tags and verify they are preserved in export
     add_test (NAME import-source-test COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n srctest source-test-stn.xml source-test-msr.xml --export-xml -r GDA2020)
     add_test (NAME check-source-import COMMAND bash check_source_tags.sh srctestmsr.xml CAMPAIGN_2023A CAMPAIGN_2023B EMPTY)
@@ -1106,6 +1198,28 @@ if (BUILD_TESTING)
     add_test (NAME reftran-source-test COMMAND $<TARGET_FILE:${DNAREFTRAN_TARGET}> srctest -r itrf2014 -e 01.01.2020 --export-xml)
     add_test (NAME check-source-reftran COMMAND bash check_source_tags.sh srctest.ITRF2014.01.01.2020msr.xml CAMPAIGN_2023A CAMPAIGN_2023B EMPTY)
 
+    # 8a. XML import with and without xsi:noNamespaceSchemaLocation (issue #346)
+    # Verify dnaimport handles XML files regardless of whether the schema location
+    # attribute is present. Strip the attribute and import each sample data pair.
+
+    # gnss-network: with schema location (original files)
+    add_test (NAME import-xml-gnss-with-xsd COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n xsd_gnss gnss-networkstn.xml gnss-networkmsr.xml -r GDA2020)
+    # gnss-network: without schema location
+    add_test (NAME import-xml-gnss-strip COMMAND bash strip_schema_location.sh gnss-networkstn.xml gnss-networkstn-noxsd.xml)
+    add_test (NAME import-xml-gnss-strip-msr COMMAND bash strip_schema_location.sh gnss-networkmsr.xml gnss-networkmsr-noxsd.xml)
+    add_test (NAME import-xml-gnss-without-xsd COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n xsd_gnss gnss-networkstn-noxsd.xml gnss-networkmsr-noxsd.xml -r GDA2020)
+    set_tests_properties(import-xml-gnss-strip import-xml-gnss-strip-msr PROPERTIES FIXTURES_SETUP gnss_strip)
+    set_tests_properties(import-xml-gnss-without-xsd PROPERTIES FIXTURES_REQUIRED gnss_strip)
+
+    # urban-network: with schema location
+    add_test (NAME import-xml-urban-with-xsd COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n xsd_urban urban-networkstn.xml urban-networkmsr.xml -r GDA2020)
+    # urban-network: without schema location
+    add_test (NAME import-xml-urban-strip COMMAND bash strip_schema_location.sh urban-networkstn.xml urban-networkstn-noxsd.xml)
+    add_test (NAME import-xml-urban-strip-msr COMMAND bash strip_schema_location.sh urban-networkmsr.xml urban-networkmsr-noxsd.xml)
+    add_test (NAME import-xml-urban-without-xsd COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n xsd_urban urban-networkstn-noxsd.xml urban-networkmsr-noxsd.xml -r GDA2020)
+    set_tests_properties(import-xml-urban-strip import-xml-urban-strip-msr PROPERTIES FIXTURES_SETUP urban_strip)
+    set_tests_properties(import-xml-urban-without-xsd PROPERTIES FIXTURES_REQUIRED urban_strip)
+
     # 9. gnss reference frame transformations
     add_test (NAME ref-gnss01-network COMMAND $<TARGET_FILE:${DNAREFTRAN_TARGET}> gnss -r itrf2014 -e 01.01.2020)
     add_test (NAME ref-gnss02-network COMMAND $<TARGET_FILE:${DNAREFTRAN_TARGET}> gnss -r itrf1988 -e 03.12.1995)
@@ -1744,16 +1858,8 @@ if (BUILD_TESTING)
     add_test (NAME import-no-frame COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n sample -r itrf1975 dsg.stn dsg.msr)
     # no stations and measurements (generated above)
     add_test (NAME import-no-data COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n null ./null.stn ./null.msr)
-    # no DynaML.xsd - remove file in platform-independent manner (using CMake command) by setting up a test dependency
-    add_test (NAME import-no-xsd-file-remove COMMAND ${CMAKE_COMMAND} -E remove DynaML.xsd)
-    add_test (NAME import-no-xsd-file COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n gnss gnss-networkstn.xml gnss-networkmsr.xml)
-    set_tests_properties(import-no-xsd-file PROPERTIES DEPENDS import-no-xsd-file-remove TIMEOUT 5)
-    # Restore DynaML.xsd after testing its absence
-    add_test (NAME import-no-xsd-file-restore COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/../sampleData/DynaML.xsd DynaML.xsd)
-    set_tests_properties(import-no-xsd-file-restore PROPERTIES DEPENDS import-no-xsd-file)
     # no geoid file
     add_test (NAME import-no-geoid COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n geoid --geo-file ./nofile.geo)
-    set_tests_properties(import-no-geoid PROPERTIES DEPENDS import-no-xsd-file-restore)
     # no project file
     add_test (NAME import-no-project COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -p ./nofile.dnaproj)
     # measurement stns not in station file
@@ -1765,7 +1871,7 @@ if (BUILD_TESTING)
     add_test (NAME import-misc-network-size COMMAND $<TARGET_FILE:${DNAIMPORT_TARGET}> -n contig --import-contiguous-stn-msr 5000 --export-dna)
 
     set_tests_properties(import-no-option import-invalid-option import-invalid-file import-nearby import-no-files import-no-frame
-        import-no-data import-no-xsd-file import-no-geoid import-no-project import-no-stns import-no-help
+        import-no-data import-no-geoid import-no-project import-no-stns import-no-help
         import-misc-block-size import-misc-network-size import-misc-07
         PROPERTIES WILL_FAIL TRUE)
 
@@ -1942,6 +2048,9 @@ if (BUILD_TESTING)
     set_tests_properties(
         import-urban-network geoid-urban-network segment-urban-network adjust-urban-network
         PROPERTIES RUN_SERIAL TRUE)
+    set_tests_properties(
+        import-urban-network-verbose geoid-urban-network-verbose segment-urban-network-verbose adjust-urban-network-verbose
+        PROPERTIES RUN_SERIAL TRUE)
     set_tests_properties(
         import-urban-network-thread reftran-urban-network-thread geoid-urban-network-thread segment-urban-network-thread adjust-urban-network-thread-01
         PROPERTIES RUN_SERIAL TRUE)
@@ -1986,7 +2095,7 @@ if (BUILD_TESTING)
         unit-AmlFileLoaderTest unit-BmsFileTest unit-NetworkDataLoaderTest
         unit-MeasurementProcessorTest unit-DynAdjustPrinterTest unit-GNSSNstatSortTest
         unit-BstFileLoaderTest unit-AslFileLoaderTest unit-BmsFileLoaderTest
-        unit-SnxFileWriterTest
+        unit-SnxFileWriterTest unit-FormatElapsedTimeTest
     )
     set_tests_properties(${UNIT_TESTS} PROPERTIES
         RUN_SERIAL FALSE
@@ -2007,4 +2116,3 @@ endif ()
 
 message ("")
 message ("")
-
diff --git a/dynadjust/cmake/StaticBuildOptimizations.cmake b/dynadjust/cmake/StaticBuildOptimizations.cmake
index 2f3d45716..7bac0b495 100644
--- a/dynadjust/cmake/StaticBuildOptimizations.cmake
+++ b/dynadjust/cmake/StaticBuildOptimizations.cmake
@@ -6,20 +6,59 @@ function(optimize_static_target TARGET_NAME)
     if(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
         set_property(TARGET ${TARGET_NAME} PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
     endif()
-    
+
     # Platform-specific optimizations
     if(UNIX AND NOT APPLE)
-        # Linux-specific optimizations
         target_link_options(${TARGET_NAME} PRIVATE
-            -static
-            -Wl,--gc-sections      # Remove unused sections
-            -Wl,--as-needed         # Only link libraries that are actually used
-            -Wl,-O2                 # Optimize at link time
-            -Wl,--strip-all         # Strip all symbols
+            -static-libgcc
+            -static-libstdc++
+            -Wl,--as-needed
+            -Wl,-O2
+            -Wl,--strip-all
+            # glibc 2.34+ merged libpthread into libc; libpthread.a is an
+            # empty stub. libstdc++.a references ALL pthread functions via
+            # weak aliases (__gthrw_), and glibc defines them as WEAK (W)
+            # in libc.a. LLD will not pull a weak-defined archive member to
+            # satisfy a weak-undefined reference, leaving every pthread
+            # symbol at address 0 and crashing at runtime.
+            # Fix: add a strong undefined reference (-u) for each symbol.
+            # This forces LLD to pull in each object from libc.a, making
+            # the weak-defined symbol available for the weak refs to bind to.
+            -Wl,-u,pthread_once
+            -Wl,-u,pthread_getspecific
+            -Wl,-u,pthread_setspecific
+            -Wl,-u,pthread_create
+            -Wl,-u,pthread_join
+            -Wl,-u,pthread_equal
+            -Wl,-u,pthread_self
+            -Wl,-u,pthread_detach
+            -Wl,-u,pthread_cancel
+            -Wl,-u,pthread_mutex_lock
+            -Wl,-u,pthread_mutex_trylock
+            -Wl,-u,pthread_mutex_unlock
+            -Wl,-u,pthread_mutex_init
+            -Wl,-u,pthread_mutex_destroy
+            -Wl,-u,pthread_cond_init
+            -Wl,-u,pthread_cond_broadcast
+            -Wl,-u,pthread_cond_signal
+            -Wl,-u,pthread_cond_wait
+            -Wl,-u,pthread_cond_timedwait
+            -Wl,-u,pthread_cond_destroy
+            -Wl,-u,pthread_key_create
+            -Wl,-u,pthread_key_delete
+            -Wl,-u,pthread_mutexattr_init
+            -Wl,-u,pthread_mutexattr_settype
+            -Wl,-u,pthread_mutexattr_destroy
+            -Wl,-u,pthread_attr_init
+            -Wl,-u,pthread_attr_destroy
+            -Wl,-u,pthread_attr_setdetachstate
+            -Wl,-u,pthread_exit
+            -Wl,-u,__pthread_key_create
         )
+        target_link_libraries(${TARGET_NAME} PRIVATE pthread m dl)
         target_compile_options(${TARGET_NAME} PRIVATE
-            -ffunction-sections     # Put each function in its own section
-            -fdata-sections         # Put each data item in its own section
+            -ffunction-sections
+            -fdata-sections
         )
     elseif(APPLE)
         # macOS-specific optimizations
diff --git a/dynadjust/dynadjust.rc b/dynadjust/dynadjust.rc
index a0eaebbac..2bbab4905 100644
--- a/dynadjust/dynadjust.rc
+++ b/dynadjust/dynadjust.rc
@@ -25,8 +25,8 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,3,0,0
- PRODUCTVERSION 1,3,0,0
+ FILEVERSION 1,4,1,0
+ PRODUCTVERSION 1,4,1,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -42,12 +42,12 @@ BEGIN
         BLOCK "040904b0"
         BEGIN
             VALUE "FileDescription", "DynAdjust is a rigorous, high performance least squares adjustment application."
-            VALUE "FileVersion", "1.3.0.0"
+            VALUE "FileVersion", "1.4.1.0"
             VALUE "InternalName", "DynAdjust"
             VALUE "LegalCopyright", "Copyright 2025 Geoscience Australia"
             VALUE "OriginalFilename", "DynAdjust"
             VALUE "ProductName", "DynAdjust"
-            VALUE "ProductVersion", "1.3.0.0"
+            VALUE "ProductVersion", "1.4.1.0"
         END
     END
     BLOCK "VarFileInfo"
diff --git a/dynadjust/dynadjust/dnaadjust/CMakeLists.txt b/dynadjust/dynadjust/dnaadjust/CMakeLists.txt
index c817c55a4..321b9fefb 100644
--- a/dynadjust/dynadjust/dnaadjust/CMakeLists.txt
+++ b/dynadjust/dynadjust/dnaadjust/CMakeLists.txt
@@ -33,8 +33,17 @@ add_library (${PROJECT_NAME} SHARED
              dnaadjust-stage.cpp
              dnaadjust.cpp
              dnaadjust_printer.cpp
+             dnaadjust_json_printer.cpp
              ${CMAKE_SOURCE_DIR}/dynadjust.rc)
 
+# The JSON printer pulls in the nlohmann/json single header which is
+# expensive to compile; exclude it from the unity/jumbo build so it is
+# compiled in isolation.
+set_source_files_properties(
+    dnaadjust_json_printer.cpp
+    PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON
+)
+
 target_precompile_headers (${PROJECT_NAME} PUBLIC precompile.h)
 
 target_link_libraries (${PROJECT_NAME} ${DNA_LIBRARIES})
diff --git a/dynadjust/dynadjust/dnaadjust/dnaadjust-multi.cpp b/dynadjust/dynadjust/dnaadjust/dnaadjust-multi.cpp
index d0df76cb7..a188ed5d6 100644
--- a/dynadjust/dynadjust/dnaadjust/dnaadjust-multi.cpp
+++ b/dynadjust/dynadjust/dnaadjust/dnaadjust-multi.cpp
@@ -94,11 +94,9 @@ void dna_adjust::AdjustPhasedMultiThread()
 	initialiseIteration();
 
 	std::string corr_msg;
-	std::ostringstream ss;
 	UINT32 i;
 	bool iterate(true);
 
-	std::chrono::milliseconds iteration_time(std::chrono::milliseconds(0));
 	cpu_timer it_time, tot_time;
 
 #if defined(__ICC) || defined(__INTEL_COMPILER)		// Intel compiler
@@ -169,7 +167,6 @@ void dna_adjust::AdjustPhasedMultiThread()
 		for_each(mt_adjust_threads.begin(), mt_adjust_threads.end(), std::mem_fn(&std::thread::join));
 #endif
 		// This point is reached when the threads have finished
-		iteration_time = std::chrono::duration_cast<std::chrono::milliseconds>(it_time.elapsed().wall);
 
 		//delete mt_adjust_threads;
 #if defined(__ICC) || defined(__INTEL_COMPILER)		// Intel compiler
@@ -195,18 +192,12 @@ void dna_adjust::AdjustPhasedMultiThread()
 		if (IsCancelled())
 			break;
 
-		ss.str("");
-		if (iteration_time >= std::chrono::seconds(1)) {
-			auto seconds = std::chrono::duration_cast<std::chrono::seconds>(iteration_time);
-			ss << seconds.count() << "s";
-		} else {
-			ss << iteration_time.count() << "ms";
-		}
+		std::string iteration_time_str = FormatElapsedTime(it_time.elapsed().wall.count() / 1.0e9);
 
 		///////////////////////////////////
 		// protected write to adj file (not needed here since write to
 		// adj file at this stage is via single thread
-		adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Elapsed time" << ss.str() << std::endl;
+		adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Elapsed time" << iteration_time_str << std::endl;
 		OutputLargestCorrection(corr_msg);
 		///////////////////////////////////
 
@@ -214,6 +205,7 @@ void dna_adjust::AdjustPhasedMultiThread()
 			debug_file << concurrentAdjustments.print_adjusted_blocks();
 
 		iterationCorrections_.add_message(corr_msg);
+		iterationTimes_.add_message(iteration_time_str);
 		iterationQueue_.push_and_notify(CurrentIteration());				// currentIteration begins at 1, so not zero-indexed
 
 		// continue iterating?
@@ -303,7 +295,7 @@ void dna_adjust::SolveMT(bool COMPUTE_INVERSE, const UINT32& block)
 	{
 		// Compute inverse of normals (aposteriori variance matrix)
 		// (AT * V-1 * A)-1
-		FormInverseVarianceMatrix(&(v_normalsR_.at(block)), false);
+		FormInverseVarianceMatrix(&(v_normalsR_.at(block)), false, true);
 	}
 
 	// compute weighted "measured minus computed"
@@ -312,7 +304,10 @@ void dna_adjust::SolveMT(bool COMPUTE_INVERSE, const UINT32& block)
 
 	// Solve corrections from normal equations
 	v_correctionsR_.at(block).redim(v_designR_.at(block).columns(), 1);
-	v_correctionsR_.at(block).multiply(v_normalsR_.at(block), "N", At_Vinv_m, "N");
+	if (v_normalsR_.at(block).is_symmetric())
+		v_correctionsR_.at(block).multiply_sym(v_normalsR_.at(block), At_Vinv_m);
+	else
+		v_correctionsR_.at(block).multiply(v_normalsR_.at(block), "N", At_Vinv_m, "N");
 
 	// debug output?
 	if (projectSettings_.g.verbose > 3)
@@ -842,4 +837,3 @@ void dna_adjust::PrepareAdjustmentMultiThread()
 
 }	// namespace networkadjust
 }	// namespace dynadjust
-
diff --git a/dynadjust/dynadjust/dnaadjust/dnaadjust-stage.cpp b/dynadjust/dynadjust/dnaadjust/dnaadjust-stage.cpp
index e0e1175d9..4be2c0422 100644
--- a/dynadjust/dynadjust/dnaadjust/dnaadjust-stage.cpp
+++ b/dynadjust/dynadjust/dnaadjust/dnaadjust-stage.cpp
@@ -159,6 +159,8 @@ void dna_adjust::DeserialiseBlockFromMappedFile(const UINT32& block, const int f
 		return;
 	}
 
+	const auto profile_start = profileTimings_ ? std::chrono::steady_clock::now() : std::chrono::steady_clock::time_point{};
+
 	va_list vlist;
 	va_start(vlist, file_count);
 	
@@ -173,7 +175,7 @@ void dna_adjust::DeserialiseBlockFromMappedFile(const UINT32& block, const int f
 			break;
 		case sf_normals_r:
 			addr = normalsR_map_.GetBlockRegionAddr(block);
-			v_normalsR_.at(block).ReadMappedFileRegion(addr);
+			v_normalsR_.at(block).AttachMappedFileRegion(addr);
 			break;
 		case sf_atvinv:
 			v_AtVinv_.at(block).allocate();
@@ -183,47 +185,47 @@ void dna_adjust::DeserialiseBlockFromMappedFile(const UINT32& block, const int f
 			break;
 		case sf_meas_minus_comp:
 			addr = measMinusComp_map_.GetBlockRegionAddr(block);
-			v_measMinusComp_.at(block).ReadMappedFileRegion(addr);
+			v_measMinusComp_.at(block).AttachMappedFileRegion(addr);
 			break;
 		case sf_estimated_stns:
 			addr = estimatedStations_map_.GetBlockRegionAddr(block);
-			v_estimatedStations_.at(block).ReadMappedFileRegion(addr);
+			v_estimatedStations_.at(block).AttachMappedFileRegion(addr);
 			break;
 		case sf_original_stns:
 			addr = originalStations_map_.GetBlockRegionAddr(block);
-			v_originalStations_.at(block).ReadMappedFileRegion(addr);
+			v_originalStations_.at(block).AttachMappedFileRegion(addr);
 			break;
 		case sf_rigorous_stns:
 			addr = rigorousStations_map_.GetBlockRegionAddr(block);
-			v_rigorousStations_.at(block).ReadMappedFileRegion(addr);
+			v_rigorousStations_.at(block).AttachMappedFileRegion(addr);
 			break;
 		case sf_junction_vars:
 			addr = junctionVariances_map_.GetBlockRegionAddr(block);
-			v_junctionVariances_.at(block).ReadMappedFileRegion(addr);
+			v_junctionVariances_.at(block).AttachMappedFileRegion(addr);
 			break;
 		case sf_junction_vars_f:
 			addr = junctionVariancesFwd_map_.GetBlockRegionAddr(block);
-			v_junctionVariancesFwd_.at(block).ReadMappedFileRegion(addr);
+			v_junctionVariancesFwd_.at(block).AttachMappedFileRegion(addr);
 			break;
 		case sf_junction_ests_f:
 			addr = junctionEstimatesFwd_map_.GetBlockRegionAddr(block);
-			v_junctionEstimatesFwd_.at(block).ReadMappedFileRegion(addr);
+			v_junctionEstimatesFwd_.at(block).AttachMappedFileRegion(addr);
 			break;
 		case sf_junction_ests_r:
 			addr = junctionEstimatesRev_map_.GetBlockRegionAddr(block);
-			v_junctionEstimatesRev_.at(block).ReadMappedFileRegion(addr);
+			v_junctionEstimatesRev_.at(block).AttachMappedFileRegion(addr);
 			break;
 		case sf_rigorous_vars:
 			addr = rigorousVariances_map_.GetBlockRegionAddr(block);
-			v_rigorousVariances_.at(block).ReadMappedFileRegion(addr);
+			v_rigorousVariances_.at(block).AttachMappedFileRegion(addr);
 			break;
 		case sf_prec_adj_msrs:
 			addr = precAdjMsrs_map_.GetBlockRegionAddr(block);
-			v_precAdjMsrsFull_.at(block).ReadMappedFileRegion(addr);
+			v_precAdjMsrsFull_.at(block).AttachMappedFileRegion(addr);
 			break;
 		case sf_corrections:
 			addr = corrections_map_.GetBlockRegionAddr(block);
-			v_corrections_.at(block).ReadMappedFileRegion(addr);
+			v_corrections_.at(block).AttachMappedFileRegion(addr);
 
 			if (v_blockMeta_.at(block)._blockLast)
 				v_correctionsR_.at(block).allocate();
@@ -232,6 +234,14 @@ void dna_adjust::DeserialiseBlockFromMappedFile(const UINT32& block, const int f
 		}
 	}
 	va_end(vlist);
+
+	if (profileTimings_)
+	{
+		const auto elapsed = std::chrono::steady_clock::now() - profile_start;
+		profileStageLoadNs_.fetch_add(
+			static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed).count()),
+			std::memory_order_relaxed);
+	}
 }
 
 void dna_adjust::SerialiseBlockToMappedFile(const UINT32& block, const int file_count, ...)
@@ -240,14 +250,16 @@ void dna_adjust::SerialiseBlockToMappedFile(const UINT32& block, const int file_
 	{
 		// serialise all.  That is, call this function again, but with 
 		// arguments for all files
-		SerialiseBlockToMappedFile(block, 16, 
-			sf_normals, sf_normals_r, sf_atvinv, sf_design, sf_meas_minus_comp,
+		SerialiseBlockToMappedFile(block, 12,
+			sf_normals_r, sf_meas_minus_comp,
 			sf_estimated_stns, sf_original_stns, sf_rigorous_stns,
 			sf_junction_vars, sf_junction_vars_f, sf_junction_ests_f, sf_junction_ests_r,
 			sf_rigorous_vars, sf_prec_adj_msrs, sf_corrections);
 		return;
 	}
 
+	const auto profile_start = profileTimings_ ? std::chrono::steady_clock::now() : std::chrono::steady_clock::time_point{};
+
 	va_list vlist;
 	va_start(vlist, file_count);
 	
@@ -257,16 +269,10 @@ void dna_adjust::SerialiseBlockToMappedFile(const UINT32& block, const int file_
 	{
 		switch (va_arg(vlist, int))
 		{
-		case sf_normals:
-			break;
 		case sf_normals_r:
 			addr = normalsR_map_.GetBlockRegionAddr(block);
 			v_normalsR_.at(block).WriteMappedFileRegion(addr);
 			break;
-		case sf_atvinv:
-			break;
-		case sf_design:
-			break;
 		case sf_meas_minus_comp:
 			addr = measMinusComp_map_.GetBlockRegionAddr(block);
 			v_measMinusComp_.at(block).WriteMappedFileRegion(addr);
@@ -314,6 +320,14 @@ void dna_adjust::SerialiseBlockToMappedFile(const UINT32& block, const int file_
 		}
 	}
 	va_end(vlist);
+
+	if (profileTimings_)
+	{
+		const auto elapsed = std::chrono::steady_clock::now() - profile_start;
+		profileStageStoreNs_.fetch_add(
+			static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed).count()),
+			std::memory_order_relaxed);
+	}
 }
 	
 
@@ -395,7 +409,11 @@ void dna_adjust::OpenStageFileStreams(const int file_count, ...)
 	}
 
 	std::stringstream ss;
-	ss << projectSettings_.g.output_folder << FOLDER_SLASH << projectSettings_.g.network_name << "-";
+	if (projectSettings_.a.stage_path.empty())
+		ss << projectSettings_.g.output_folder;
+	else
+		ss << projectSettings_.a.stage_path;
+	ss << FOLDER_SLASH << projectSettings_.g.network_name << "-";
 	std::string filePath(ss.str());
 
 	v_stageFileStreams_.clear();
@@ -851,6 +869,46 @@ void dna_adjust::OffloadBlockToMappedFile(const UINT32& block)
 
 	// Unload block matrix data from memory
 	UnloadBlock(block);
+
+	// Advise kernel that mapped pages for this block are no longer needed,
+	// freeing page cache for upcoming blocks
+	AdviseBlockDontNeed(block);
+}
+
+
+void dna_adjust::AdviseBlockDontNeed(const UINT32& block)
+{
+	using advice = boost::interprocess::mapped_region::advice_types;
+	normalsR_map_.AdviseRegion(block, advice::advice_dontneed);
+	measMinusComp_map_.AdviseRegion(block, advice::advice_dontneed);
+	estimatedStations_map_.AdviseRegion(block, advice::advice_dontneed);
+	originalStations_map_.AdviseRegion(block, advice::advice_dontneed);
+	rigorousStations_map_.AdviseRegion(block, advice::advice_dontneed);
+	junctionVariances_map_.AdviseRegion(block, advice::advice_dontneed);
+	junctionVariancesFwd_map_.AdviseRegion(block, advice::advice_dontneed);
+	junctionEstimatesFwd_map_.AdviseRegion(block, advice::advice_dontneed);
+	junctionEstimatesRev_map_.AdviseRegion(block, advice::advice_dontneed);
+	rigorousVariances_map_.AdviseRegion(block, advice::advice_dontneed);
+	precAdjMsrs_map_.AdviseRegion(block, advice::advice_dontneed);
+	corrections_map_.AdviseRegion(block, advice::advice_dontneed);
+}
+
+
+void dna_adjust::AdviseBlockWillNeed(const UINT32& block)
+{
+	using advice = boost::interprocess::mapped_region::advice_types;
+	normalsR_map_.AdviseRegion(block, advice::advice_willneed);
+	measMinusComp_map_.AdviseRegion(block, advice::advice_willneed);
+	estimatedStations_map_.AdviseRegion(block, advice::advice_willneed);
+	originalStations_map_.AdviseRegion(block, advice::advice_willneed);
+	rigorousStations_map_.AdviseRegion(block, advice::advice_willneed);
+	junctionVariances_map_.AdviseRegion(block, advice::advice_willneed);
+	junctionVariancesFwd_map_.AdviseRegion(block, advice::advice_willneed);
+	junctionEstimatesFwd_map_.AdviseRegion(block, advice::advice_willneed);
+	junctionEstimatesRev_map_.AdviseRegion(block, advice::advice_willneed);
+	rigorousVariances_map_.AdviseRegion(block, advice::advice_willneed);
+	precAdjMsrs_map_.AdviseRegion(block, advice::advice_willneed);
+	corrections_map_.AdviseRegion(block, advice::advice_willneed);
 }
 	
 
@@ -896,7 +954,7 @@ void dna_adjust::UnloadBlock(const UINT32& block, const int file_count, ...)
 	if (file_count == 0)
 	{
 		// deserialise all
-		UnloadBlock(block, 16, 
+		UnloadBlock(block, 15,
 			sf_normals, sf_normals_r, sf_atvinv, sf_design, sf_meas_minus_comp,
 			sf_estimated_stns, sf_original_stns, sf_rigorous_stns,
 			sf_junction_vars, sf_junction_vars_f, sf_junction_ests_f, sf_junction_ests_r,
@@ -907,58 +965,60 @@ void dna_adjust::UnloadBlock(const UINT32& block, const int file_count, ...)
 	va_list vlist;
 	va_start(vlist, file_count);
 
-	// Unload block matrix data from memory
+	// Unload block matrix data from memory by freeing buffers.
+	// Use deallocate() instead of explicit destructor calls to keep
+	// the matrix objects in a valid state for later reuse.
 	for (UINT16 file(0); file<file_count; ++file)
 	{
 		switch (va_arg(vlist, int))
 		{
 		case sf_normals:
-			v_normals_.at(block).~matrix_2d();
+			v_normals_.at(block).deallocate();
 			break;
 		case sf_normals_r:
-			v_normalsR_.at(block).~matrix_2d();
+			v_normalsR_.at(block).deallocate();
 			break;
 		case sf_atvinv:
-			v_AtVinv_.at(block).~matrix_2d();
+			v_AtVinv_.at(block).deallocate();
 			break;
 		case sf_design:
-			v_design_.at(block).~matrix_2d();
+			v_design_.at(block).deallocate();
 			break;
 		case sf_meas_minus_comp:
-			v_measMinusComp_.at(block).~matrix_2d();
+			v_measMinusComp_.at(block).deallocate();
 			break;
 		case sf_estimated_stns:
-			v_estimatedStations_.at(block).~matrix_2d();
+			v_estimatedStations_.at(block).deallocate();
 			break;
 		case sf_original_stns:
-			v_originalStations_.at(block).~matrix_2d();
+			v_originalStations_.at(block).deallocate();
 			break;
 		case sf_rigorous_stns:
-			v_rigorousStations_.at(block).~matrix_2d();
+			v_rigorousStations_.at(block).deallocate();
 			break;
 		case sf_junction_vars:
-			v_junctionVariances_.at(block).~matrix_2d();
+			v_junctionVariances_.at(block).deallocate();
 			break;
 		case sf_junction_vars_f:
-			v_junctionVariancesFwd_.at(block).~matrix_2d();
+			v_junctionVariancesFwd_.at(block).deallocate();
 			break;
 		case sf_junction_ests_f:
-			v_junctionEstimatesFwd_.at(block).~matrix_2d();
+			v_junctionEstimatesFwd_.at(block).deallocate();
 			break;
 		case sf_junction_ests_r:
-			v_junctionEstimatesRev_.at(block).~matrix_2d();
+			v_junctionEstimatesRev_.at(block).deallocate();
 			break;
 		case sf_rigorous_vars:
-			v_rigorousVariances_.at(block).~matrix_2d();
+			v_rigorousVariances_.at(block).deallocate();
 			break;
 		case sf_prec_adj_msrs:
-			v_precAdjMsrsFull_.at(block).~matrix_2d();
+			v_precAdjMsrsFull_.at(block).deallocate();
 			break;
 		case sf_corrections:
-			v_corrections_.at(block).~matrix_2d();
+			v_corrections_.at(block).deallocate();
 
 			if (v_blockMeta_.at(block)._blockLast)
-				v_correctionsR_.at(block).~matrix_2d();
+				v_correctionsR_.at(block).deallocate();
 			break;
 		}
 	}
@@ -1009,4 +1069,3 @@ void dna_adjust::CloseStageFileStreams()
 
 }	// namespace networkadjust
 }	// namespace dynadjust
-
diff --git a/dynadjust/dynadjust/dnaadjust/dnaadjust.cpp b/dynadjust/dynadjust/dnaadjust/dnaadjust.cpp
index 06dd3827c..a86ce96e4 100644
--- a/dynadjust/dynadjust/dnaadjust/dnaadjust.cpp
+++ b/dynadjust/dynadjust/dnaadjust/dnaadjust.cpp
@@ -17,7 +17,10 @@
 // Description  : DynAdjust Network Adjustment library
 //============================================================================
 
+#include <cstdlib>
+
 #include <dynadjust/dnaadjust/dnaadjust.hpp>
+#include <dynadjust/dnaadjust/dnaadjust_json_printer.hpp>
 #include <dynadjust/dnaadjust/dnaadjust-multi.cpp>
 
 namespace dynadjust {
@@ -32,6 +35,9 @@ concurrent_queue<UINT32> combineAdjustmentQueue;
 concurrent_queue<UINT32> prepareAdjustmentQueue;
 std::exception_ptr fwd_error, rev_error, cmb_error, prep_error;
 
+void dna_adjust::SetMaxBlasThreads(int n) { dynadjust::math::set_max_blas_threads(n); }
+int dna_adjust::GetMaxBlasThreads() { return dynadjust::math::get_max_blas_threads(); }
+
 dna_adjust::dna_adjust()
 	: isPreparing_(false)
 	, isAdjusting_(false)
@@ -42,7 +48,12 @@ dna_adjust::dna_adjust()
 	, isAdjustmentQuestionable_(false)
 	, blockCount_(1)
 	, currentBlock_(0)
+	, lastBlockElapsedMs_(0)
 	, total_time_(0)
+	, profileTimings_(std::getenv("DYNADJUST_PROFILE") != nullptr)
+	, profileUpdateNormalsNs_(0)
+	, profileStageLoadNs_(0)
+	, profileStageStoreNs_(0)
 	, adjustStatus_(ADJUST_SUCCESS)
 	, currentIteration_(0)
 	, datum_(DEFAULT_EPSG_U)
@@ -133,10 +144,9 @@ dna_adjust::dna_adjust()
 		v_correctionsR_.clear();
 	}
 
-	// Initialize the printer
 	printer_ = std::make_unique<DynAdjustPrinter>(*this);
 }
-	
+
 
 dna_adjust::~dna_adjust()
 {
@@ -172,8 +182,15 @@ UINT32& dna_adjust::incrementIteration()
 	return ++currentIteration_; 
 }
 
-void dna_adjust::initialiseIteration(const UINT32& iteration) 
-{ 
+void dna_adjust::decrementIteration()
+{
+	std::lock_guard<std::mutex> lock(current_iterationMutex);
+	if (currentIteration_ > 0)
+		--currentIteration_;
+}
+
+void dna_adjust::initialiseIteration(const UINT32& iteration)
+{
 	std::lock_guard<std::mutex> lock(current_iterationMutex);
 	currentIteration_ = iteration; 
 }
@@ -195,6 +212,9 @@ void dna_adjust::InitialiseAdjustment()
 
 	adjustStatus_ = ADJUST_SUCCESS;
 	statusMessages_.clear();
+	profileUpdateNormalsNs_.store(0, std::memory_order_relaxed);
+	profileStageLoadNs_.store(0, std::memory_order_relaxed);
+	profileStageStoreNs_.store(0, std::memory_order_relaxed);
 	currentBlock_ = 0;
 	initialiseIteration();
 	
@@ -240,6 +260,7 @@ void dna_adjust::PrepareAdjustment(const project_settings& projectSettings)
 	isPreparing_ = true;
 	isAdjusting_ = true;
 	isCombining_ = false;
+	rebuildingDesign_ = false;
 	isFirstTimeAdjustment_ = true;
 	projectSettings_ = projectSettings;
 
@@ -248,10 +269,17 @@ void dna_adjust::PrepareAdjustment(const project_settings& projectSettings)
 			projectSettings_.a.multi_thread))
 		projectSettings_.a.stage = false;
 
-	// Load the bst/bms meta and set the default 
+	// Load the bst/bms meta and set the default
 	// reference frame (via binary station file)
 	SetDefaultReferenceFrame();
 
+	if (projectSettings_.o._output_json)
+	{
+		auto json_printer = std::make_unique<DynAdjustJsonPrinter>(*this);
+		json_printer->OpenStreams();
+		printer_ = std::move(json_printer);
+	}
+
 	// Open output files for printing adjustment results
 	OpenOutputFileStreams();
 	printer_->PrintOutputFileHeaderInfo();
@@ -528,14 +556,14 @@ void dna_adjust::UpdateAdjustment(bool iterate)
 			// Hence, only design and msr-comp are required so as to compute stats
 			if (!iterate)
 				continue;
-			
+
 			switch (projectSettings_.a.adjust_mode)
 			{
 			case PhasedMode:
 			case Phased_Block_1Mode:
 				v_normals_.at(block).zero();
 				UpdateNormals(block, false);
-				
+
 				if (projectSettings_.a.multi_thread)
 				{
 					v_estimatedStationsR_.at(block) = v_rigorousStations_.at(block);
@@ -545,9 +573,9 @@ void dna_adjust::UpdateAdjustment(bool iterate)
 				}
 
 				// Back up normals.  This copy contains the contributions from all
-				// apriori measurement variances, excluding parameter station 
+				// apriori measurement variances, excluding parameter station
 				// variances and junction station variances
-				v_normalsR_.at(block) = v_normals_.at(block);				
+				v_normalsR_.at(block) = v_normals_.at(block);
 				AddConstraintStationstoNormalsForward(block);
 
 				break;
@@ -742,17 +770,19 @@ void dna_adjust::PrepareStationandVarianceMatrices(const UINT32& block)
 
 			// resize rigorous coordinate estimate array
 			v_rigorousStations_.at(block).redim(v_unknownsCount_.at(block), 1);
-		
-			// resize rigorous variances
-			v_rigorousVariances_.at(block).redim(v_unknownsCount_.at(block), v_unknownsCount_.at(block));
+
+			if (projectSettings_.a.stage || projectSettings_.a.multi_thread)
+				v_rigorousVariances_.at(block).redim_packed(v_unknownsCount_.at(block));
+			else
+				v_rigorousVariances_.at(block).redim(v_unknownsCount_.at(block), v_unknownsCount_.at(block));
 
 			// resize junction variances
-			v_junctionVariances_.at(block).redim(j, j);
+			v_junctionVariances_.at(block).redim_packed(j);
 
 			// resize junction station coordinate estimate arrays
 			if (!v_blockMeta_.at(block)._blockLast && !v_blockMeta_.at(block)._blockIsolated)
 			{
-				v_junctionVariancesFwd_.at(block).redim(j, j);
+				v_junctionVariancesFwd_.at(block).redim_packed(j);
 				v_junctionEstimatesFwd_.at(block).redim(j, 1);
 				v_junctionEstimatesRev_.at(block+1).redim(j, 1);
 			}
@@ -860,11 +890,10 @@ void dna_adjust::PrepareDesignAndMsrMnsCmpMatrices(const UINT32& block)
 	// Simultaneous, phased (multithreaded and block1) adjustments
 
 	// Redim all matrices
-	v_normals_.at(block).redim(v_unknownsCount_.at(block), v_unknownsCount_.at(block));
+	v_normals_.at(block).redim_packed(v_unknownsCount_.at(block));
 	
 	v_design_.at(block).redim(v_measurementCount_.at(block), v_unknownsCount_.at(block));
 	v_corrections_.at(block).redim(v_unknownsCount_.at(block), 1);
-	v_precAdjMsrsFull_.at(block).redim(v_measurementVarianceCount_.at(block), 1);
 	
 	// All blocks in v_correctionsR_ are used for multi thread mode, but only the last is used
 	// in single thread mode
@@ -897,9 +926,7 @@ void dna_adjust::PrepareDesignAndMsrMnsCmpMatricesStage(const UINT32& block)
 	if (projectSettings_.a.recreate_stage_files || !bms_meta_.reduced)
 	{
 		// Redim NormalsR
-		v_normalsR_.at(block).redim(
-			v_unknownsCount_.at(block), 
-			v_unknownsCount_.at(block));
+		v_normalsR_.at(block).redim_packed(v_unknownsCount_.at(block));
 
 		// Redimension the corrections matrices
 		v_corrections_.at(block).redim(v_unknownsCount_.at(block), 1);
@@ -930,7 +957,41 @@ void dna_adjust::PrepareDesignAndMsrMnsCmpMatricesStage(const UINT32& block)
 		// Creating new memory mapped files?  Form the design matrices
 		FillDesignNormalMeasurementsMatrices(true, block, false);
 }
-	
+
+
+void dna_adjust::RebuildDesignAndAtVinv(const UINT32& block)
+{
+	UINT32 pseudoMsrElemCount(0);
+
+	if (!v_blockMeta_.at(block)._blockIsolated)
+	{
+		UINT32 pseudoMsrCount = static_cast<UINT32>(v_JSL_.at(block).size());
+		if (!v_blockMeta_.at(block)._blockFirst)
+			pseudoMsrCount += static_cast<UINT32>(v_JSL_.at(block-1).size());
+		pseudoMsrElemCount = pseudoMsrCount * 3;
+	}
+
+	v_design_.at(block).redim(v_measurementCount_.at(block), v_unknownsCount_.at(block));
+	v_AtVinv_.at(block).redim(
+		v_unknownsCount_.at(block),
+		v_measurementCount_.at(block) + pseudoMsrElemCount);
+
+	if (pseudoMsrElemCount > 0)
+		v_AtVinv_.at(block).shrink(0, pseudoMsrElemCount);
+
+	assert(v_design_.at(block).getbuffer() != nullptr && "RebuildDesignAtVinv: design null after redim");
+	assert(v_AtVinv_.at(block).getbuffer() != nullptr && "RebuildDesignAtVinv: AtVinv null after redim");
+	assert(v_estimatedStations_.at(block).getbuffer() != nullptr && "RebuildDesignAtVinv: estimatedStations null");
+	assert(v_measMinusComp_.at(block).getbuffer() != nullptr && "RebuildDesignAtVinv: measMinusComp null");
+
+	rebuildingDesign_ = true;
+	FillDesignNormalMeasurementsMatrices(true, block, false, true);
+	rebuildingDesign_ = false;
+
+	assert(v_design_.at(block).getbuffer() != nullptr && "RebuildDesignAtVinv: design null after Fill");
+	assert(v_AtVinv_.at(block).getbuffer() != nullptr && "RebuildDesignAtVinv: AtVinv null after Fill");
+}
+
 
 // Re-form At * V-1 for next block using estimated junction parameter station variances
 // nextBlock = currentBlock+1
@@ -1233,9 +1294,9 @@ void dna_adjust::UpdateAtVinv(pit_vmsr_t _it_msr, const UINT32& stn1, const UINT
 				std::fixed << std::setprecision(16) << std::setw(26) << variance << std::endl;
 
 	// Build  At * V-1
-	AtVinv->put(stn1, design_row, variance * design->get(design_row, stn1));
-	AtVinv->put(stn1+1, design_row, variance * design->get(design_row, stn1+1));
-	AtVinv->put(stn1+2, design_row, variance * design->get(design_row, stn1+2));
+	AtVinv->dense_put(stn1, design_row, variance * design->dense_get(design_row, stn1));
+	AtVinv->dense_put(stn1+1, design_row, variance * design->dense_get(design_row, stn1+1));
+	AtVinv->dense_put(stn1+2, design_row, variance * design->dense_get(design_row, stn1+2));
 	
 	// Single station measurements
 	switch ((*_it_msr)->measType)
@@ -1250,16 +1311,16 @@ void dna_adjust::UpdateAtVinv(pit_vmsr_t _it_msr, const UINT32& stn1, const UINT
 	}
 
 	// Two station measurements
-	AtVinv->put(stn2, design_row, variance * design->get(design_row, stn2));
-	AtVinv->put(stn2+1, design_row, variance * design->get(design_row, stn2+1));
-	AtVinv->put(stn2+2, design_row, variance * design->get(design_row, stn2+2));
+	AtVinv->dense_put(stn2, design_row, variance * design->dense_get(design_row, stn2));
+	AtVinv->dense_put(stn2+1, design_row, variance * design->dense_get(design_row, stn2+1));
+	AtVinv->dense_put(stn2+2, design_row, variance * design->dense_get(design_row, stn2+2));
 
 	switch ((*_it_msr)->measType)
 	{
 	case 'A':	// Horizontal angle
-		AtVinv->put(stn3, design_row, variance * design->get(design_row, stn3));
-		AtVinv->put(stn3+1, design_row, variance * design->get(design_row, stn3+1));
-		AtVinv->put(stn3+2, design_row, variance * design->get(design_row, stn3+2));
+		AtVinv->dense_put(stn3, design_row, variance * design->dense_get(design_row, stn3));
+		AtVinv->dense_put(stn3+1, design_row, variance * design->dense_get(design_row, stn3+1));
+		AtVinv->dense_put(stn3+2, design_row, variance * design->dense_get(design_row, stn3+2));
 	}
 }
 	
@@ -1269,27 +1330,27 @@ void dna_adjust::UpdateAtVinv_D(const UINT32& stn1, const UINT32& stn2, const UI
 							UINT32& design_row, UINT32& design_row_begin,
 							matrix_2d* Vinv, matrix_2d* design, matrix_2d* AtVinv)
 {
+	const double angle_variance = Vinv->dense_get(angle, angle);
 	for (UINT32 j, i(0); i<3; ++i)													// for each coordinate element (x, y, z)
 	{
 		// add variances
-		AtVinv->elementadd(stn1+i, design_row,											// station1
-			design->get(design_row, stn1+i) * Vinv->get(angle, angle));
-		AtVinv->elementadd(stn2+i, design_row,											// station2
-			design->get(design_row, stn2+i) * Vinv->get(angle, angle));
-		AtVinv->elementadd(stn3+i, design_row,											// station3
-			design->get(design_row, stn3+i) * Vinv->get(angle, angle));
+		const double design1 = design->dense_get(design_row, stn1+i);
+		const double design2 = design->dense_get(design_row, stn2+i);
+		const double design3 = design->dense_get(design_row, stn3+i);
+
+		AtVinv->dense_add(stn1+i, design_row, design1 * angle_variance);				// station1
+		AtVinv->dense_add(stn2+i, design_row, design2 * angle_variance);				// station2
+		AtVinv->dense_add(stn3+i, design_row, design3 * angle_variance);				// station3
 		
 		// add covariances
 		for (j=0; j<angle_count; ++j)
 		{
 			if (j == angle)
 				continue;
-			AtVinv->elementadd(stn1+i, design_row_begin+j,								// station1
-				design->get(design_row, stn1+i) * Vinv->get(angle, j));
-			AtVinv->elementadd(stn2+i, design_row_begin+j,								// station2
-				design->get(design_row, stn2+i) * Vinv->get(angle, j));
-			AtVinv->elementadd(stn3+i, design_row_begin+j,								// station3
-				design->get(design_row, stn3+i) * Vinv->get(angle, j));
+			const double angle_covariance = Vinv->dense_get(angle, j);
+			AtVinv->dense_add(stn1+i, design_row_begin+j, design1 * angle_covariance);	// station1
+			AtVinv->dense_add(stn2+i, design_row_begin+j, design2 * angle_covariance);	// station2
+			AtVinv->dense_add(stn3+i, design_row_begin+j, design3 * angle_covariance);	// station3
 		}			
 	}
 }
@@ -1302,6 +1363,7 @@ void dna_adjust::UpdateAtVinv_D(const UINT32& stn1, const UINT32& stn2, const UI
 //		- PrepareFwdAdj (used by adjust_forward_thread)
 void dna_adjust::UpdateNormals(const UINT32& block, bool MT_ReverseOrCombine)
 {
+	const auto profile_start = profileTimings_ ? std::chrono::steady_clock::now() : std::chrono::steady_clock::time_point{};
 	UINT32 stn1, stn2, stn3, design_row(0);
 	
 	it_vUINT32 _it_block_msr;
@@ -1382,22 +1444,59 @@ void dna_adjust::UpdateNormals(const UINT32& block, bool MT_ReverseOrCombine)
 				"'." << std::endl;
 			SignalExceptionAdjustment(ss.str(), block);
 		}		
-	}	
+	}
+
+	if (profileTimings_)
+	{
+		const auto elapsed = std::chrono::steady_clock::now() - profile_start;
+		profileUpdateNormalsNs_.fetch_add(
+			static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed).count()),
+			std::memory_order_relaxed);
+	}
 }
 	
 
+namespace {
+
+inline void add_normal_3x3_from_design_row(UINT32 design_row, UINT32 atvinv_station, UINT32 design_station,
+	matrix_2d* normals, const matrix_2d* design, const matrix_2d* AtVinv)
+{
+	const double* atvinv_col = AtVinv->dense_ptr(atvinv_station, design_row);
+
+	for (UINT32 col = 0; col < 3; ++col)
+	{
+		const double design_value = *design->dense_ptr(design_row, design_station + col);
+		normals->lower_add(atvinv_station, design_station + col,
+			atvinv_col[0] * design_value);
+		normals->lower_add(atvinv_station + 1, design_station + col,
+			atvinv_col[1] * design_value);
+		normals->lower_add(atvinv_station + 2, design_station + col,
+			atvinv_col[2] * design_value);
+	}
+}
+
+inline void add_normal_3x3_from_atvinv_columns(UINT32 design_row, UINT32 atvinv_station, UINT32 normal_station,
+	double scale, matrix_2d* normals, const matrix_2d* AtVinv)
+{
+	for (UINT32 col = 0; col < 3; ++col)
+	{
+		const double* atvinv_col = AtVinv->dense_ptr(atvinv_station, design_row + col);
+		normals->lower_add(atvinv_station, normal_station + col,
+			scale * atvinv_col[0]);
+		normals->lower_add(atvinv_station + 1, normal_station + col,
+			scale * atvinv_col[1]);
+		normals->lower_add(atvinv_station + 2, normal_station + col,
+			scale * atvinv_col[2]);
+	}
+}
+
+} // namespace
+
 void dna_adjust::AddMsrtoNormalsVar(const UINT32& design_row, const UINT32& stn,
 										 matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv)
 {
 	// Add weighted measurement contributions to normal matrix
-	for (UINT32 row, col(0); col<3; ++col)
-	{
-		for (row=0; row<3; ++row)
-		{
-			normals->elementadd(stn+row, stn+col,
-				AtVinv->get(stn+row, design_row) * design->get(design_row, stn+col));
-		}
-	}
+	add_normal_3x3_from_design_row(design_row, stn, stn, normals, design, AtVinv);
 }
 	
 
@@ -1405,50 +1504,20 @@ void dna_adjust::AddMsrtoNormalsCoVar2(const UINT32& design_row, const UINT32& s
 										 matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv)
 {
 	// Add covariance terms (station 1 and station 2) to normal matrix
-	for (UINT32 row, col(0); col<3; ++col)
-	{
-		for (row=0; row<3; ++row)
-		{
-			// 1-2
-			normals->elementadd(stn1+row, stn2+col,
-				AtVinv->get(stn1+row, design_row) * design->get(design_row, stn2+col));
-
-			normals->elementadd(stn2+row, stn1+col,
-				AtVinv->get(stn2+row, design_row) * design->get(design_row, stn1+col));
-		}
-	}
+	add_normal_3x3_from_design_row(design_row, stn1, stn2, normals, design, AtVinv);
+	add_normal_3x3_from_design_row(design_row, stn2, stn1, normals, design, AtVinv);
 }
 
 void dna_adjust::AddMsrtoNormalsCoVar3(const UINT32& design_row, const UINT32& stn1, const UINT32& stn2, const UINT32& stn3,
 										 matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv)
 {
 	// Add covariance terms (station 1, station 2, station 3) to normal matrix
-	for (UINT32 row, col(0); col<3; ++col)
-	{
-		for (row=0; row<3; ++row)
-		{
-			// 1-2
-			normals->elementadd(stn1+row, stn2+col,
-				AtVinv->get(stn1+row, design_row) * design->get(design_row, stn2+col));
-
-			normals->elementadd(stn2+row, stn1+col,
-				AtVinv->get(stn2+row, design_row) * design->get(design_row, stn1+col));
-
-			// 1-3
-			normals->elementadd(stn1+row, stn3+col,
-				AtVinv->get(stn1+row, design_row) * design->get(design_row, stn3+col));
-
-			normals->elementadd(stn3+row, stn1+col,
-				AtVinv->get(stn3+row, design_row) * design->get(design_row, stn1+col));
-			
-			// 2-3
-			normals->elementadd(stn2+row, stn3+col,
-				AtVinv->get(stn2+row, design_row) * design->get(design_row, stn3+col));
-
-			normals->elementadd(stn3+row, stn2+col,
-				AtVinv->get(stn3+row, design_row) * design->get(design_row, stn2+col));
-		}
-	}
+	add_normal_3x3_from_design_row(design_row, stn1, stn2, normals, design, AtVinv);
+	add_normal_3x3_from_design_row(design_row, stn2, stn1, normals, design, AtVinv);
+	add_normal_3x3_from_design_row(design_row, stn1, stn3, normals, design, AtVinv);
+	add_normal_3x3_from_design_row(design_row, stn3, stn1, normals, design, AtVinv);
+	add_normal_3x3_from_design_row(design_row, stn2, stn3, normals, design, AtVinv);
+	add_normal_3x3_from_design_row(design_row, stn3, stn2, normals, design, AtVinv);
 }
 
 
@@ -1471,7 +1540,7 @@ void dna_adjust::UpdateNormals_A(const UINT32& stn1, const UINT32& stn2, const U
 void dna_adjust::UpdateNormals_D(const UINT32& block, it_vmsr_t& _it_msr, UINT32& design_row,
 										 matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv)
 {
-	UINT32 row, col, a, angle_count(_it_msr->vectorCount2 - 1);
+	UINT32 a, angle_count(_it_msr->vectorCount2 - 1);
 	UINT32 skip(0), ignored(_it_msr->vectorCount1 - _it_msr->vectorCount2);
 
 	std::vector<UINT32> stations;
@@ -1522,22 +1591,11 @@ void dna_adjust::UpdateNormals_D(const UINT32& block, it_vmsr_t& _it_msr, UINT32
 		}
 
 		// station 1
-		for (col=0; col<3; ++col)
-			for (row=0; row<3; ++row)
-				normals->elementadd(stn1+row, stn1+col,
-					AtVinv->get(stn1+row, design_row+a) * design->get(design_row+a, stn1+col));
-		//
+		add_normal_3x3_from_design_row(design_row+a, stn1, stn1, normals, design, AtVinv);
 		// station 2
-		for (col=0; col<3; ++col)
-			for (row=0; row<3; ++row)
-				normals->elementadd(stn2+row, stn2+col,
-					AtVinv->get(stn2+row, design_row+a) * design->get(design_row+a, stn2+col));
-		//
+		add_normal_3x3_from_design_row(design_row+a, stn2, stn2, normals, design, AtVinv);
 		// station 3
-		for (col=0; col<3; ++col)
-			for (row=0; row<3; ++row)
-				normals->elementadd(stn3+row, stn3+col,
-					AtVinv->get(stn3+row, design_row+a) * design->get(design_row+a, stn3+col));
+		add_normal_3x3_from_design_row(design_row+a, stn3, stn3, normals, design, AtVinv);
 
 		if (a+1 == angle_count)
 			break;
@@ -1568,17 +1626,8 @@ void dna_adjust::UpdateNormals_D(const UINT32& block, it_vmsr_t& _it_msr, UINT32
 				if (stn2 == stn1)
 					continue;
 
-				for (col=0; col<3; ++col)
-				{
-					for (row=0; row<3; ++row)
-					{
-						// 1-2
-						normals->elementadd(stn1+row, stn2+col,
-							AtVinv->get(stn1+row, design_row+a) * design->get(design_row+a, stn2+col));
-						normals->elementadd(stn2+row, stn1+col,
-							AtVinv->get(stn2+row, design_row+a) * design->get(design_row+a, stn1+col));
-					}				
-				}
+				add_normal_3x3_from_design_row(design_row+a, stn1, stn2, normals, design, AtVinv);
+				add_normal_3x3_from_design_row(design_row+a, stn2, stn1, normals, design, AtVinv);
 			}
 		}
 		it_angle++;
@@ -1615,39 +1664,21 @@ void dna_adjust::UpdateNormals_HIJPQR(const UINT32& stn1, UINT32& design_row,
 void dna_adjust::UpdateNormals_G(const UINT32& stn1, const UINT32& stn2, UINT32& design_row,
 										 matrix_2d* normals, matrix_2d* AtVinv)
 {
-	UINT32 col, row;
-
 	// station 2
-	for (col=0; col<3; ++col)
-		for (row=0; row<3; ++row)
-			normals->elementadd(stn2+row, stn2+col,
-				// AtVinv->get(stn2+row, design_row+col) * design->get(design_row+col, stn2+col));
-				// No need to multiply by 1 as stn2 design element is always 1.  See UpdateDesignMeasMatrices_GX()
-				AtVinv->get(stn2+row, design_row+col));
+	// No need to multiply by 1 as stn2 design element is always 1.  See UpdateDesignMeasMatrices_GX()
+	add_normal_3x3_from_atvinv_columns(design_row, stn2, stn2, 1., normals, AtVinv);
 
 	// station 1
-	for (col=0; col<3; ++col)
-		for (row=0; row<3; ++row)
-			normals->elementadd(stn1+row, stn1+col,
-				// AtVinv->get(stn1+row, design_row+col) * design->get(design_row+col, stn1+col));
-				// No need to multiply by -1 as stn1 design element is always -1.  See UpdateDesignMeasMatrices_GX()
-				-AtVinv->get(stn1+row, design_row+col));
+	// No need to multiply by -1 as stn1 design element is always -1.  See UpdateDesignMeasMatrices_GX()
+	add_normal_3x3_from_atvinv_columns(design_row, stn1, stn1, -1., normals, AtVinv);
 
 	// covariance terms (station 1 and station 2)
-	for (col=0; col<3; ++col)
-		for (row=0; row<3; ++row)
-			normals->elementadd(stn1+row, stn2+col,
-				// AtVinv->get(stn1+row, design_row+col) * design->get(design_row+col, stn2+col));
-				// No need to multiply as stn2 is always 1.  See UpdateDesignMeasMatrices_GX()
-				AtVinv->get(stn1+row, design_row+col));
+	// No need to multiply as stn2 is always 1.  See UpdateDesignMeasMatrices_GX()
+	add_normal_3x3_from_atvinv_columns(design_row, stn1, stn2, 1., normals, AtVinv);
 
 	// covariance terms (station 2 and station 1)
-	for (col=0; col<3; ++col)
-		for (row=0; row<3; ++row)
-			normals->elementadd(stn2+row, stn1+col,
-				// AtVinv->get(stn2+row, design_row+col) * design->get(design_row+col, stn1+col));
-				// No need to multiply by -1 as stn1 design element is always -1.  See UpdateDesignMeasMatrices_GX()
-				-AtVinv->get(stn2+row, design_row+col));
+	// No need to multiply by -1 as stn1 design element is always -1.  See UpdateDesignMeasMatrices_GX()
+	add_normal_3x3_from_atvinv_columns(design_row, stn2, stn1, -1., normals, AtVinv);
 
 	design_row += 3;
 }
@@ -2112,6 +2143,7 @@ _ADJUST_STATUS_ dna_adjust::AdjustNetwork()
 	isIterationComplete_ = false;
 	isAdjustmentQuestionable_ = false;
 	iterationCorrections_.clear_messages();
+	iterationTimes_.clear_messages();
 
 	if (projectSettings_.o._database_ids)
 		LoadDatabaseId();
@@ -2171,8 +2203,7 @@ _ADJUST_STATUS_ dna_adjust::AdjustNetwork()
 	
 void dna_adjust::PrintAdjustedNetworkStations()
 {
-	networkadjust::DynAdjustPrinter printer(*this);
-	printer.PrintAdjustedNetworkStations();
+	printer_->PrintAdjustedNetworkStations();
 }
 	
 // First item in the file is a UINT32 value - the number of records in the file
@@ -2383,7 +2414,12 @@ void dna_adjust::AdjustSimultaneous()
 {
 	adjustStatus_ = ADJUST_SUCCESS;
 	initialiseIteration();
-	
+
+	// Reset oscillation diagnostics
+	corrPrev_.clear();
+	stnOscCount_.clear();
+	oscHistory_.clear();
+
 	std::ostringstream ss;
 	std::string corr_msg;
 	std::chrono::milliseconds elapsed_time(std::chrono::milliseconds(0));
@@ -2429,9 +2465,11 @@ void dna_adjust::AdjustSimultaneous()
 		// Compute and print largest correction
 		maxCorr_ = v_corrections_.at(0).compute_maximum_value();
 		OutputLargestCorrection(corr_msg);
+		UpdateIterationDiagnostics();
 
 		// update data for messages
 		iterationCorrections_.add_message(corr_msg);
+		iterationTimes_.add_message(FormatElapsedTime(it_time.elapsed().wall.count() / 1.0e9));
 		iterationQueue_.push_and_notify(CurrentIteration());	// currentIteration begins at 1, so not zero-indexed
 		isIterationComplete_ = true;
 		
@@ -2489,7 +2527,7 @@ void dna_adjust::ValidateandFinaliseAdjustment(cpu_timer& tot_time)
 		fabs(maxCorr_) > projectSettings_.a.iteration_threshold)
 		adjustStatus_ = ADJUST_MAX_ITERATIONS_EXCEEDED;
 
-	// Back up simultaneous rigorous variance estimates (for serialising 
+	// Back up simultaneous rigorous variance estimates (for serialising
 	// to disk at SerialiseAdjustedVarianceMatrices() ), so that executing adjust
 	// in report-results mode has access to the latest variance estimates
 	switch (projectSettings_.a.adjust_mode)
@@ -2507,6 +2545,7 @@ void dna_adjust::ValidateandFinaliseAdjustment(cpu_timer& tot_time)
 	printer_->PrintAdjustmentStatus();
 	// Compute and print time taken to run adjustment
 	PrintAdjustmentTime(tot_time, total_time);
+	PrintPerformanceProfile();
 }
 	
 void dna_adjust::PrintAdjustmentTime(cpu_timer& time, _TIMER_TYPE_ timerType)
@@ -2520,17 +2559,39 @@ void dna_adjust::PrintAdjustmentTime(cpu_timer& time, _TIMER_TYPE_ timerType)
 	printer_->PrintAdjustmentTime(time, static_cast<int>(timerType));
 }
 
+void dna_adjust::PrintPerformanceProfile() const
+{
+	if (!profileTimings_)
+		return;
+
+	const auto ns_to_ms = [](uint64_t ns) {
+		return static_cast<double>(ns) / 1000000.0;
+	};
+
+	std::cerr << "DynAdjust profile timings:"
+			  << " update_normals=" << std::fixed << std::setprecision(3)
+			  << ns_to_ms(profileUpdateNormalsNs_.load(std::memory_order_relaxed)) << "ms"
+			  << " stage_load=" << ns_to_ms(profileStageLoadNs_.load(std::memory_order_relaxed)) << "ms"
+			  << " stage_store=" << ns_to_ms(profileStageStoreNs_.load(std::memory_order_relaxed)) << "ms"
+			  << std::endl;
+}
+
 void dna_adjust::AdjustPhased()
 {
 	initialiseIteration();
 
+	// Reset oscillation diagnostics
+	corrPrev_.clear();
+	stnOscCount_.clear();
+	oscHistory_.clear();
+
 	std::string corr_msg;
 	std::ostringstream ss;
 	UINT32 i;
 	bool iterate(true);
 
 	cpu_timer it_time, tot_time;
-		
+
 	// do until convergence criteria is met
 	for (i=0; i<projectSettings_.a.max_iterations; ++i)
 	{
@@ -2548,10 +2609,10 @@ void dna_adjust::AdjustPhased()
 		potentialOutlierCount_ = 0;
 		chiSquaredStage_ = 0.;
 		measurementParams_ = 0;
-	
+
 		// Print the iteration # to adj file
 		printer_->PrintIteration(incrementIteration());
-		
+
 		it_time.start();
 
 		AdjustPhasedForward();
@@ -2567,8 +2628,10 @@ void dna_adjust::AdjustPhased()
 
 		// Calculate and print largest adjustment correction and station ID
 		OutputLargestCorrection(corr_msg);
-		
+		UpdateIterationDiagnostics();
+
 		iterationCorrections_.add_message(corr_msg);
+		iterationTimes_.add_message(FormatElapsedTime(it_time.elapsed().wall.count() / 1.0e9));
 		iterationQueue_.push_and_notify(CurrentIteration());	// currentIteration begins at 1, so not zero-indexed
 		isIterationComplete_ = true;
 
@@ -2581,7 +2644,7 @@ void dna_adjust::AdjustPhased()
 		// Similar to PrepareAdjustment, UpdateAdjustment prepares every block
 		// in the network so that forward and reverse adjustments can commence
 		// at the same time.
-		UpdateAdjustment(iterate);	
+		UpdateAdjustment(iterate);
 		if (IsCancelled())
 			break;
 
@@ -2590,7 +2653,7 @@ void dna_adjust::AdjustPhased()
 		{
 			// Compute network statistics
 			ComputeStatisticsOnIteration();
-			
+
 			// Print statistics summary to adj file
 			printer_->PrintStatistics(false);
 		}
@@ -2645,8 +2708,9 @@ void dna_adjust::AdjustPhasedBlock1()
 
 	if (fabs(maxCorr_) > projectSettings_.a.iteration_threshold)
 		adjustStatus_ = ADJUST_THRESHOLD_EXCEEDED;
-		
+
 	iterationCorrections_.add_message(corr_msg);
+	iterationTimes_.add_message(FormatElapsedTime(it_time.elapsed().wall.count() / 1.0e9));
 	iterationQueue_.push_and_notify(CurrentIteration());	// currentIteration begins at 1, so not zero-indexed
 
 	ValidateandFinaliseAdjustment(tot_time);
@@ -2695,9 +2759,10 @@ void dna_adjust::AdjustPhasedForward()
 
 	UINT32 currentBlock(0);
 
-	// For staged adjustments, load the first block from mapped memory file
+	// For staged adjustments, prefetch and load the first block from mapped memory file
 	if (projectSettings_.a.stage)
 	{
+		AdviseBlockWillNeed(currentBlock);
 		DeserialiseBlockFromMappedFile(currentBlock);
 		RebuildNormals(currentBlock, __forward__, true, true);
 		if (IsCancelled())
@@ -2735,16 +2800,21 @@ void dna_adjust::AdjustPhasedForward()
 		// At this point, whether first iteration or not, if currentBlock is the first block, 
 		// the normals will have been initialised.  For all later blocks, the normals will contain
 		// the contribution of junction station coordinates and variances from preceding blocks.
-		// In either case, the block is ready for adjustment.  Junction station coordinates and 
+		// In either case, the block is ready for adjustment.  Junction station coordinates and
 		// variances are carried forward below
 
+		assert(v_design_.at(currentBlock).getbuffer() != nullptr && "AdjFwd: design null before SolveTry");
+		assert(v_AtVinv_.at(currentBlock).getbuffer() != nullptr && "AdjFwd: AtVinv null before SolveTry");
+		assert(v_normals_.at(currentBlock).getbuffer() != nullptr && "AdjFwd: normals null before SolveTry");
+		assert(v_measMinusComp_.at(currentBlock).getbuffer() != nullptr && "AdjFwd: measMinusComp null before SolveTry");
+
 		// Least Squares Solution
 		SolveTry(true, currentBlock);
 
 		// Does the user want to print adjusted measurements
 		// on each iteration?
-		if (projectSettings_.o._adj_msr_iteration || 
-			projectSettings_.o._adj_stn_iteration || 
+		if (projectSettings_.o._adj_msr_iteration ||
+			projectSettings_.o._adj_stn_iteration ||
 			projectSettings_.o._cmp_msr_iteration)
 			adj_file << " done." << std::endl;
 
@@ -2766,21 +2836,21 @@ void dna_adjust::AdjustPhasedForward()
 		// OK, now shrink matrices back to normal size
 		ShrinkForwardMatrices(currentBlock);
 
-		// Carry the estimated junction station coordinates and variances 
+		// Carry the estimated junction station coordinates and variances
 		// to the next block for applicable blocks only.  For staged
-		// Deserialise the next block from mapped files and rebuild 
+		// Deserialise the next block from mapped files and rebuild
 		// normals
 		CarryForwardJunctions(currentBlock, currentBlock+1);
 
 		// For staged adjustments, write to disk and unload matrix data
 		if (projectSettings_.a.stage)
-			// Don't offload last block since the reverse adjustment 
+			// Don't offload last block since the reverse adjustment
 			// will need this block
 			if (currentBlock < (blockCount_ - 1))
 				OffloadBlockToMappedFile(currentBlock);
 	}
 }
-	
+
 
 void dna_adjust::PurgeMatricesFromDisk()
 {
@@ -2885,8 +2955,7 @@ void dna_adjust::PrepareAdjustmentBlock(const UINT32 block, const UINT32 thread_
 		v_normalsR_.at(block) = v_normals_.at(block);
 
 		if (projectSettings_.a.multi_thread) {
-			v_normalsRC_.at(block).redim(
-				v_normalsR_.at(block).rows(), v_normalsR_.at(block).columns());
+			v_normalsRC_.at(block).redim_packed(v_normalsR_.at(block).rows());
 		}
 
 		switch (projectSettings_.a.adjust_mode)
@@ -2940,6 +3009,8 @@ void dna_adjust::ShrinkForwardMatrices(const UINT32 currentBlock)
 	{
 		pseudoMsrElemCount = static_cast<UINT32>(v_JSL_.at(currentBlock-1).size() * 3);
 
+		assert(v_measMinusComp_.at(currentBlock).getbuffer() != nullptr && "ShrinkFwd: measMinusComp null");
+		assert(v_AtVinv_.at(currentBlock).getbuffer() != nullptr && "ShrinkFwd: AtVinv null");
 		v_measMinusComp_.at(currentBlock).shrink(pseudoMsrElemCount, 0);
 		v_AtVinv_.at(currentBlock).shrink(0, pseudoMsrElemCount);
 	}
@@ -2974,7 +3045,9 @@ void dna_adjust::UpdateEstimatesForward(const UINT32 currentBlock)
 
 		// Now copy 'estimated' coordinates to 'rigorous' for comparison on the next iteration
 		v_rigorousStations_.at(currentBlock) = v_estimatedStations_.at(currentBlock);
+		assert(v_normals_.at(currentBlock).getbuffer() != nullptr && "UpdateEstFwd: normals null before copy to rigorousVariances");
 		v_rigorousVariances_.at(currentBlock) = v_normals_.at(currentBlock);
+		assert(v_rigorousVariances_.at(currentBlock).getbuffer() != nullptr && "UpdateEstFwd: rigorousVariances null after copy");
 
 		// Temporarily hold corrections for last block.  These corrections will be restored
 		// in UpdateEstimatesFinal()
@@ -3024,9 +3097,10 @@ void dna_adjust::CarryForwardJunctions(const UINT32 thisBlock, const UINT32 next
 	if (v_blockMeta_.at(nextBlock)._blockIsolated)
 		return;
 	
-	// For staged adjustments, load block info for nextBlock
+	// For staged adjustments, prefetch and load block info for nextBlock
 	if (projectSettings_.a.stage)
 	{
+		AdviseBlockWillNeed(nextBlock);
 		DeserialiseBlockFromMappedFile(nextBlock);
 		RebuildNormals(nextBlock, __forward__, true, true);
 	}
@@ -3061,7 +3135,7 @@ bool dna_adjust::PrepareAdjustmentReverse(const UINT32 currentBlock, bool MT_Rev
 
 	// OK. currentBlock is the last block, and this is the commencement of
 	// a reverse run, so reset coordinates
-	matrix_2d* estimatedStations(&v_estimatedStations_.at(currentBlock));	
+	matrix_2d* estimatedStations(&v_estimatedStations_.at(currentBlock));
 
 	if (MT_ReverseOrCombine)
 	{
@@ -3069,15 +3143,23 @@ bool dna_adjust::PrepareAdjustmentReverse(const UINT32 currentBlock, bool MT_Rev
 	}
 	else
 	{
-		// Restore back up copy of normals for reverse adjustment in 
+		// Restore back up copy of normals for reverse adjustment in
 		// single thread mode
+		assert(v_normalsR_.at(currentBlock).getbuffer() != nullptr && "PrepareAdjReverse: normalsR null before copy");
+		assert(v_normalsR_.at(currentBlock).rows() > 0 && "PrepareAdjReverse: normalsR has 0 rows");
 		v_normals_.at(currentBlock) = v_normalsR_.at(currentBlock);
+		assert(v_normals_.at(currentBlock).getbuffer() != nullptr && "PrepareAdjReverse: normals null after copy");
 
 	}
 
+	assert(v_originalStations_.at(currentBlock).getbuffer() != nullptr && "PrepareAdjReverse: originalStations null");
 	// Reset coordinates to original values
 	*estimatedStations = v_originalStations_.at(currentBlock);
-	
+
+	assert(v_design_.at(currentBlock).rows() > 0 && "PrepareAdjReverse: design has 0 rows");
+	assert(v_AtVinv_.at(currentBlock).rows() > 0 && "PrepareAdjReverse: AtVinv has 0 rows");
+	assert(v_measMinusComp_.at(currentBlock).rows() > 0 && "PrepareAdjReverse: measMinusComp has 0 rows");
+
 	AddConstraintStationstoNormalsReverse(currentBlock, MT_ReverseOrCombine);
 
 	return true;
@@ -3417,6 +3499,11 @@ void dna_adjust::AdjustPhasedReverseCombine()
 		if (projectSettings_.g.verbose > 3)
 			debug_file << "In isolation" << std::endl;
 
+		assert(v_design_.at(currentBlock).getbuffer() != nullptr && "design null before SolveTry (reverse combine)");
+		assert(v_AtVinv_.at(currentBlock).getbuffer() != nullptr && "AtVinv null before SolveTry (reverse combine)");
+		assert(v_normals_.at(currentBlock).getbuffer() != nullptr && "normals null before SolveTry (reverse combine)");
+		assert(v_measMinusComp_.at(currentBlock).getbuffer() != nullptr && "measMinusComp null before SolveTry (reverse combine)");
+
 		// Backup normals prior to inversion for re-use in combination
 		// adjustment... only if a combination is required
 		BackupNormals(currentBlock, false);
@@ -3429,7 +3516,7 @@ void dna_adjust::AdjustPhasedReverseCombine()
 
 		// Add corrections to estimates.
 		// If --output-adj-iter-stat argument is supplied or currentBlock
-		// is the first block, then compute geographic coordinates, recompute 
+		// is the first block, then compute geographic coordinates, recompute
 		// meas-minus-computed vector, then print statistics.
 		// Output of stats also prints largest correction.
 		// If --output-adj-iter-stn argument is supplied, print station coords
@@ -3437,16 +3524,16 @@ void dna_adjust::AdjustPhasedReverseCombine()
 
 		// Debug and diagnose (if required)
 		debug_BlockInformation(currentBlock, "(reverse, in isolation)");
-		
+
 		// Carry the estimated junction station coordinates and variances to the next block and
 		// combine.  CarryReverseEstimates will return false if currentBlock is the first block
-		// or an isolated block.  If estimates can be carried, CarryReverseEstimates updates 
+		// or an isolated block.  If estimates can be carried, CarryReverseEstimates updates
 		// geographic coords (if req'd), recomputes meas-minus-comp vector and updates normals for
 		// the next block.
 		if (CarryReverseJunctions(currentBlock, currentBlock-1, false))
-		{			
+		{
 			//////////////////////////////////////////////////////////////////////////
-			// Combination Adjustment 
+			// Combination Adjustment
 			//
 			// Perform combination on all blocks except the first and last as they will
 			// be rigorous from reverse and forward adjustments respectively
@@ -3454,13 +3541,13 @@ void dna_adjust::AdjustPhasedReverseCombine()
 			// First, carry the junction station estimates and variances of the next block
 			// (obtained during the forward pass).  These were copied to v_junctionEstimatesFwd_
 			// and v_junctionVariances_ in CarryStnEstimatesandVariancesForward(..) during
-			// the forward pass. 
+			// the forward pass.
 			if (PrepareAdjustmentCombine(currentBlock, pseudomsrJSLCount, false))
 			{
 				isCombining_ = true;
 				if (projectSettings_.g.verbose > 3)
 					debug_file << "Rigorous" << std::endl;
-			
+
 				if (projectSettings_.o._adj_stn_iteration)
 					if (!v_blockMeta_.at(currentBlock)._blockFirst)
 						adj_file << std::endl << std::left << "Adjusting block " << currentBlock+1 << " (reverse, rigorous)... ";
@@ -3501,7 +3588,7 @@ void dna_adjust::AdjustPhasedReverseCombine()
 
 	}	// for (UINT32 block=0; block<blockCount_; ++block, --currentBlock)
 }
-	
+
 
 // Single thread reverse and combination adjustment
 void dna_adjust::AdjustPhasedReverse()
@@ -3510,9 +3597,12 @@ void dna_adjust::AdjustPhasedReverse()
 	isCombining_ = false;
 	UINT32 currentBlock(blockCount_ - 1);
 
-	// For staged adjustments, load the last block from mapped memory file
+	// For staged adjustments, prefetch and load the last block from mapped memory file
 	if (projectSettings_.a.stage)
+	{
+		AdviseBlockWillNeed(currentBlock);
 		DeserialiseBlockFromMappedFile(currentBlock);
+	}
 
 	for (UINT32 block=0; block<blockCount_; ++block, --currentBlock)
 	{
@@ -3553,10 +3643,10 @@ void dna_adjust::AdjustPhasedReverse()
 
 		if (projectSettings_.o._adj_stn_iteration)
 			adj_file << " done." << std::endl;
-		
+
 		// Add corrections to estimates.
 		// If --output-adj-iter-stat argument is supplied or currentBlock
-		// is the first block, then compute geographic coordinates, recompute 
+		// is the first block, then compute geographic coordinates, recompute
 		// meas-minus-computed vector, then print statistics.
 		// Output of stats also prints largest correction.
 		// If --output-adj-iter-stn argument is supplied, print station coords
@@ -3567,7 +3657,7 @@ void dna_adjust::AdjustPhasedReverse()
 
 		// Carry the estimated junction station coordinates and variances to the next block and
 		// combine.  CarryReverseEstimates will return false if currentBlock is the first block
-		// or an isolated block.  If estimates can be carried, CarryReverseEstimates updates 
+		// or an isolated block.  If estimates can be carried, CarryReverseEstimates updates
 		// geographic coords (if req'd), recomputes meas-minus-comp vector and updates normals for
 		// the next block.
 		CarryReverseJunctions(currentBlock, currentBlock-1, false);
@@ -3581,9 +3671,9 @@ void dna_adjust::AdjustPhasedReverse()
 
 	}	// for (UINT32 block=0; block<blockCount_; ++block, --currentBlock)
 }
-	
 
-// This method will not be reached if currentBlock is a single (isolated) block, since 
+
+// This method will not be reached if currentBlock is a single (isolated) block, since
 // PrepareAdjustmentReverse performs this test.
 void dna_adjust::UpdateEstimatesReverse(const UINT32 currentBlock, bool MT_ReverseOrCombine)
 {
@@ -3678,7 +3768,11 @@ void dna_adjust::UpdateEstimatesFinal(const UINT32 currentBlock)
 		AtVinv = &v_AtVinvR_.at(currentBlock);
 		measMinusComp = &v_measMinusCompR_.at(currentBlock);
 		aposterioriVariances = &v_normalsR_.at(currentBlock);
-	}	
+	}
+
+	assert(AtVinv->getbuffer() != nullptr && "UpdateEstFinal: AtVinv null");
+	assert(measMinusComp->getbuffer() != nullptr && "UpdateEstFinal: measMinusComp null");
+	assert(aposterioriVariances->getbuffer() != nullptr && "UpdateEstFinal: aposterioriVariances null");
 
 	if (v_blockMeta_.at(currentBlock)._blockFirst)
 	{
@@ -3758,13 +3852,16 @@ bool dna_adjust::CarryReverseJunctions(const UINT32 currentBlock, const UINT32 n
 			v_normals_.at(nextBlock) = v_normalsR_.at(nextBlock);
 	}
 
-	// For staged adjustments, load blocks info for nextBlock
+	// For staged adjustments, prefetch and load blocks info for nextBlock
 	if (projectSettings_.a.stage)
+	{
+		AdviseBlockWillNeed(nextBlock);
 		DeserialiseBlockFromMappedFile(nextBlock);
+	}
 
 	// Next, update estimates for next block to original estimates
 	*estimatedStationsNext = v_originalStations_.at(nextBlock);
-	
+
 	// For staged adjustments, rebuild design and AtVinv
 	if (projectSettings_.a.stage)
 		RebuildNormals(nextBlock, __reverse__, false, false);
@@ -3788,25 +3885,25 @@ bool dna_adjust::CarryReverseJunctions(const UINT32 currentBlock, const UINT32 n
 
 
 // go through each of the measurements in the binary measurements file and formulate partial derivatives
-void dna_adjust::FillDesignNormalMeasurementsMatrices(bool buildnewMatrices, const UINT32& block, bool MT_ReverseOrCombine)
+void dna_adjust::FillDesignNormalMeasurementsMatrices(bool buildnewMatrices, const UINT32& block, bool MT_ReverseOrCombine, bool skipNormals)
 {
 	UINT32 design_row(0);
-	
+
 	it_vUINT32 _it_block_msr;
-	it_vmsr_t _it_msr; 
+	it_vmsr_t _it_msr;
 
 	for (_it_block_msr=v_CML_.at(block).begin(); _it_block_msr!=v_CML_.at(block).end(); ++_it_block_msr)
 	{
 		if (InitialiseandValidateMsrPointer(_it_block_msr, _it_msr))
 			continue;
 
-		// When a target direction is found, continue to next element.  
+		// When a target direction is found, continue to next element.
 		if (_it_msr->measType == 'D')
 			if (_it_msr->vectorCount2 < 1)
 				continue;
 
 		// Build AtVinv, Normals and Meas minus Comp vectors
-		UpdateDesignNormalMeasMatrices(&_it_msr, design_row, buildnewMatrices, block, MT_ReverseOrCombine);
+		UpdateDesignNormalMeasMatrices(&_it_msr, design_row, buildnewMatrices, block, MT_ReverseOrCombine, skipNormals);
 	}
 }
 
@@ -3815,6 +3912,9 @@ void dna_adjust::FillDesignNormalMeasurementsMatrices(bool buildnewMatrices, con
 // pre-adjustment value, otherwise back up the current value.
 bool dna_adjust::InitialiseMeasurement(pit_vmsr_t _it_msr, bool buildnewMatrices)
 {
+	if (rebuildingDesign_)
+		return false;
+
 	if (buildnewMatrices)
 	{
 		// Was this measurement reduced from previous
@@ -3835,7 +3935,7 @@ bool dna_adjust::InitialiseMeasurement(pit_vmsr_t _it_msr, bool buildnewMatrices
 }
 	
 
-void dna_adjust::UpdateDesignNormalMeasMatrices(pit_vmsr_t _it_msr, UINT32& design_row, bool buildnewMatrices, const UINT32& block, bool MT_ReverseOrCombine)
+void dna_adjust::UpdateDesignNormalMeasMatrices(pit_vmsr_t _it_msr, UINT32& design_row, bool buildnewMatrices, const UINT32& block, bool MT_ReverseOrCombine, bool skipNormals)
 {
 	std::stringstream ss;
 
@@ -3851,101 +3951,101 @@ void dna_adjust::UpdateDesignNormalMeasMatrices(pit_vmsr_t _it_msr, UINT32& desi
 		design = &v_designR_.at(block);
 		AtVinv = &v_AtVinvR_.at(block);
 		measMinusComp = &v_measMinusCompR_.at(block);
-	}	
+	}
 
 	switch ((*_it_msr)->measType)
 	{
 	case 'A':	// Horizontal angle
 		UpdateDesignNormalMeasMatrices_A(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 		break;
 	case 'B':	// Geodetic azimuth
 	case 'K':	// Astronomic azimuth
-		// Note: UpdateDesignNormalMeasMatrices_BK reduces K measurements to the geodetic reference frame, 
+		// Note: UpdateDesignNormalMeasMatrices_BK reduces K measurements to the geodetic reference frame,
 		// after which UpdateDesignNormalMeasMatrices_BK treats K measurements as B measurements upon forming
 		// design matrix elements.
 		UpdateDesignNormalMeasMatrices_BK(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);	
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 		break;
 	case 'C':	// Chord dist
 		UpdateDesignNormalMeasMatrices_C(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 		break;
-	case 'D':	// Direction set	
+	case 'D':	// Direction set
 		UpdateDesignNormalMeasMatrices_D(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 		break;
 	case 'E':	// Ellipsoid arc
 		UpdateDesignNormalMeasMatrices_E(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 		break;
 	case 'G':	// GPS Baseline
 		UpdateDesignNormalMeasMatrices_G(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 		break;
 	case 'H':	// Orthometric height
 		// Note: UpdateDesignNormalMeasMatrices_H reduces term1 to ellipsoid height, after which
 		// UpdateDesignNormalMeasMatrices_HR is used to form design elements.
 		UpdateDesignNormalMeasMatrices_H(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 		break;
 	case 'I':	// Astronomic latitude
 		// Note: UpdateDesignNormalMeasMatrices_I reduces term1 to geodetic latitude, after which
 		// UpdateDesignNormalMeasMatrices_IP is used to form design elements.
 		UpdateDesignNormalMeasMatrices_I(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 		break;
 	case 'J':	// Astronomic longitude
 		// Note: UpdateDesignNormalMeasMatrices_J reduces term1 to geodetic longitude, after which
 		// UpdateDesignNormalMeasMatrices_JQ is used to form design elements.
 		UpdateDesignNormalMeasMatrices_J(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
-		break;		
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
+		break;
 	case 'L':	// Level difference
 		UpdateDesignNormalMeasMatrices_L(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
-		break;		
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
+		break;
 	case 'M':	// MSL arc
 		UpdateDesignNormalMeasMatrices_M(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
-		break;		
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
+		break;
 	case 'P':	// Geodetic latitude
 		// Note: UpdateDesignNormalMeasMatrices_P archives the raw measurement, after which
 		// UpdateDesignNormalMeasMatrices_IP is used to form design elements.
 		UpdateDesignNormalMeasMatrices_P(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
-		break;		
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
+		break;
 	case 'Q':	// Geodetic longitude
 		// Note: UpdateDesignNormalMeasMatrices_Q archives the raw measurement, after which
 		// UpdateDesignNormalMeasMatrices_JQ is used to form design elements.
 		UpdateDesignNormalMeasMatrices_Q(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
-		break;		
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
+		break;
 	case 'R':	// Ellipsoidal height
 		// Note: UpdateDesignNormalMeasMatrices_R archives the raw measurement, after which
 		// UpdateDesignNormalMeasMatrices_HR is used to form design elements.
 		UpdateDesignNormalMeasMatrices_R(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 		break;
 	case 'S':	// Slope distance
 		UpdateDesignNormalMeasMatrices_S(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 		break;
 	case 'V':	// Zenith distance
 		UpdateDesignNormalMeasMatrices_V(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
-		break;		
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
+		break;
 	case 'X':	// GPS Baseline cluster
 		UpdateDesignNormalMeasMatrices_X(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, design, AtVinv, buildnewMatrices);
-		break;		
+			measMinusComp, estimatedStations, design, AtVinv, buildnewMatrices, skipNormals);
+		break;
 	case 'Y':	// GPS Point cluster
 		UpdateDesignNormalMeasMatrices_Y(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, design, AtVinv, buildnewMatrices);
-		break;		
+			measMinusComp, estimatedStations, design, AtVinv, buildnewMatrices, skipNormals);
+		break;
 	case 'Z':	// Vertical angle
 		UpdateDesignNormalMeasMatrices_Z(_it_msr, design_row, block,
-			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+			measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 		break;
 	default:
 		ss << "UpdateDesignNormalMeasMatrices(): Unknown measurement type - '" <<
@@ -4652,8 +4752,8 @@ void dna_adjust::AddMsrtoMeasMinusComp(pit_vmsr_t _it_msr, const UINT32& design_
 	
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_A(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
 	UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
@@ -4679,11 +4779,11 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_A(pit_vmsr_t _it_msr, UINT32& de
 		&direction12, &direction13, 
 		&local_12e, &local_12n, &local_13e, &local_13n));
 	
-	// Initialise measurement.  No need to test if no further calculations are 
+	// Initialise measurement.  No need to test if no further calculations are
 	// required (as in stage mode), as this is done later (below)
 	InitialiseMeasurement(_it_msr, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !rebuildingDesign_)
 	{
 		// deflections available?
 		if (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION || fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION)
@@ -4802,7 +4902,7 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_A(pit_vmsr_t _it_msr, UINT32& de
 
 	UpdateAtVinv(_it_msr, stn1, stn2, stn3, design_row, design, AtVinv, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !skipNormals)
 		// Add weighted measurement contributions to normal matrix
 		UpdateNormals_A(stn1, stn2, stn3, design_row, normals, design, AtVinv);
 	else
@@ -4811,8 +4911,8 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_A(pit_vmsr_t _it_msr, UINT32& de
 
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_BK(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
 	UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
@@ -4834,11 +4934,11 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_BK(pit_vmsr_t _it_msr, UINT32& d
 		stn1_it->currentLongitude,
 		&local_12e, &local_12n));
 	
-	// Initialise measurement.  No need to test if no further calculations are 
+	// Initialise measurement.  No need to test if no further calculations are
 	// required (as in stage mode), as this is done later (below)
 	InitialiseMeasurement(_it_msr, buildnewMatrices);
-	
-	if (buildnewMatrices)
+
+	if (buildnewMatrices && !rebuildingDesign_)
 	{
 		// deflections available?
 		if ((*_it_msr)->measType == 'K' &&						// Astro
@@ -4906,19 +5006,19 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_BK(pit_vmsr_t _it_msr, UINT32& d
 	// Update AtVinv based on new design matrix elements
 	UpdateAtVinv(_it_msr, stn1, stn2, 0, design_row, design, AtVinv, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !skipNormals)
 		// Add weighted measurement contributions to normal matrix
 		UpdateNormals_BCEKLMSVZ(stn1, stn2, design_row, normals, design, AtVinv);
 	else
 		design_row++;
 }
-	
+
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_C(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
-	// Initialise measurement and test if no further calculations are 
+	// Initialise measurement and test if no further calculations are
 	// required (as in stage mode)
 	if (InitialiseMeasurement(_it_msr, buildnewMatrices))
 		return;
@@ -4929,13 +5029,13 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_C(pit_vmsr_t _it_msr, UINT32& de
 
 	// Now call UpdateDesignNormalMeasMatrices_CEM
 	UpdateDesignNormalMeasMatrices_CEM(_it_msr, design_row, block,
-		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 }
 	
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_CEM(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
 	UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
@@ -4971,17 +5071,17 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_CEM(pit_vmsr_t _it_msr, UINT32&
 	// Update AtVinv based on new design matrix elements
 	UpdateAtVinv(_it_msr, stn1, stn2, 0, design_row, design, AtVinv, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !skipNormals)
 		// Add weighted measurement contributions to normal matrix
 		UpdateNormals_BCEKLMSVZ(stn1, stn2, design_row, normals, design, AtVinv);
 	else
 		design_row++;
 }
-	
+
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_D(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	it_vmsr_t _it_msr_first(*_it_msr);
 	UINT32 design_row_begin(design_row);
@@ -5030,7 +5130,7 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_D(pit_vmsr_t _it_msr, UINT32& de
 
 			it_angle->station3 = (*_it_msr)->station2;
 			
-			if (buildnewMatrices)
+			if (buildnewMatrices && !rebuildingDesign_)
 			{
 				// Was this measurement reduced from previous
 				// adjustment, which was serialised to disk?
@@ -5063,7 +5163,7 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_D(pit_vmsr_t _it_msr, UINT32& de
 			UpdateDesignNormalMeasMatrices_A(&it_angle, design_row, block,
 				measMinusComp, estimatedStations, 0, design, AtVinv, buildnewMatrices);
 
-			if (buildnewMatrices)
+			if (buildnewMatrices && !rebuildingDesign_)
 			{
 				// Update derived angle, corrected for deflection of vertical
 				(*_it_msr)->scale1 = it_angle->term1;
@@ -5134,14 +5234,14 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_D(pit_vmsr_t _it_msr, UINT32& de
 		it_angle++;
 	}
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !skipNormals)
 		// Add weighted measurement contributions to normal matrix
 		UpdateNormals_D(block, _it_msr_first, design_row_begin, normals, design, AtVinv);
 }
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_E(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	// Initialise measurement and test if no further calculations are 
 	// required (as in stage mode)
@@ -5177,7 +5277,7 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_E(pit_vmsr_t _it_msr, UINT32& de
 
 	// Now that the ellipsoid arc has been reduced to a chord, call UpdateDesignNormalMeasMatrices_CEM
 	UpdateDesignNormalMeasMatrices_CEM(_it_msr, design_row, block,
-		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 }
 
 void dna_adjust::UpdateDesignMeasMatrices_GX(pit_vmsr_t _it_msr, UINT32& design_row,
@@ -5251,8 +5351,8 @@ void dna_adjust::UpdateDesignMeasMatrices_GX(pit_vmsr_t _it_msr, UINT32& design_
 }
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_G(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	it_vmsr_t _it_msr_first(*_it_msr);
 	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
@@ -5274,7 +5374,7 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_G(pit_vmsr_t _it_msr, UINT32& de
 
 
 	// For first time run or staged adjustment mode
-	if (buildnewMatrices || projectSettings_.a.stage)
+	if (buildnewMatrices || projectSettings_.a.stage || skipNormals)
 	{
 		// Load GPS Variance matrix.  For the first run, scaling is applied
 		// and the variances are written to the binary measurements list.
@@ -5283,23 +5383,23 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_G(pit_vmsr_t _it_msr, UINT32& de
 
 		if (buildnewMatrices && projectSettings_.a.stage)
 			return;
-	
+
 		// Build  At * V-1
 		AtVinv->replace(stn1, design_row_begin, var_cart * -1);
 		AtVinv->replace(stn2, design_row_begin, var_cart);
 
-		if (buildnewMatrices && !projectSettings_.a.stage)
+		if (buildnewMatrices && !projectSettings_.a.stage && !skipNormals)
 			// Add weighted measurement contributions to normal matrix
 			UpdateNormals_G(stn1, stn2, design_row_begin, normals, AtVinv);
 	}
-	
+
 	design_row++;
 }
-	
+
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_M(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	// Initialise measurement and test if no further calculations are 
 	// required (as in stage mode)
@@ -5324,22 +5424,22 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_M(pit_vmsr_t _it_msr, UINT32& de
 
 	// Now that the MSL arc has been reduced to a chord, call UpdateDesignNormalMeasMatrices_CEM
 	UpdateDesignNormalMeasMatrices_CEM(_it_msr, design_row, block,
-		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 }
 
 // Like zenith distances and vertical angles, the relationship between slope distances and the
 // coordinates of p1 and p2 requires a little extra work to take into consideration instrument
 // and target height.  For the measurements-minus-computed vector, the "computed" distance
-// is the true distance between the instrument and target, and so must take into consideration 
+// is the true distance between the instrument and target, and so must take into consideration
 // instrument and target heights.  However, the dX, dY, dZ components for the partial 
 // derivatives represent the true geometric difference between the two stations (not 
 // instrument and target).
 void dna_adjust::UpdateDesignNormalMeasMatrices_S(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	// preAdjMeas is used to store original measured MSL arc distance
-	if (buildnewMatrices)
+	if (buildnewMatrices && !rebuildingDesign_)
 	{
 		// This is the first time adjust has run, so
 		// back up the raw measurement
@@ -5349,7 +5449,7 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_S(pit_vmsr_t _it_msr, UINT32& de
 			return;
 	}
 
-	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
+	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr));
 	UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
 
 	it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
@@ -5357,7 +5457,7 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_S(pit_vmsr_t _it_msr, UINT32& de
 	// compute dX, dY, dZ for instrument height (ih) and target height (th)
 	double dXih, dYih, dZih, dXth, dYth, dZth;
 	CartesianElementsFromInstrumentHeight((*_it_msr)->term3,				// instrument height
-		&dXih, &dYih, &dZih, 
+		&dXih, &dYih, &dZih,
 		stn1_it->currentLatitude,
 		stn1_it->currentLongitude);
 	CartesianElementsFromInstrumentHeight((*_it_msr)->term4,				// target height
@@ -5385,7 +5485,7 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_S(pit_vmsr_t _it_msr, UINT32& de
 	// Update AtVinv based on new design matrix elements
 	UpdateAtVinv(_it_msr, stn1, stn2, 0, design_row, design, AtVinv, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !skipNormals)
 		// Add weighted measurement contributions to normal matrix
 		UpdateNormals_BCEKLMSVZ(stn1, stn2, design_row, normals, design, AtVinv);
 	else
@@ -5402,10 +5502,10 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_S(pit_vmsr_t _it_msr, UINT32& de
 // partial derivatives represent the true geometric difference between the two stations (not 
 // instrument and target).
 void dna_adjust::UpdateDesignNormalMeasMatrices_V(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
-	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
+	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr));
 	UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
 
 	it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
@@ -5413,11 +5513,11 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_V(pit_vmsr_t _it_msr, UINT32& de
 
 	double local_12e, local_12n, local_12up;
 
-	// Initialise measurement.  No need to test if no further calculations are 
+	// Initialise measurement.  No need to test if no further calculations are
 	// required (as in stage mode), as this is done later (below)
 	InitialiseMeasurement(_it_msr, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !rebuildingDesign_)
 	{
 		// deflections available?
 		if (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION || fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION)
@@ -5493,7 +5593,7 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_V(pit_vmsr_t _it_msr, UINT32& de
 	// Update AtVinv based on new design matrix elements
 	UpdateAtVinv(_it_msr, stn1, stn2, 0, design_row, design, AtVinv, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !skipNormals)
 		// Add weighted measurement contributions to normal matrix
 		UpdateNormals_BCEKLMSVZ(stn1, stn2, design_row, normals, design, AtVinv);
 	else
@@ -5506,15 +5606,15 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_V(pit_vmsr_t _it_msr, UINT32& de
 // Like zenith distances, the relationship between slope distances and the
 // coordinates of p1 and p2 requires a little extra work to take into consideration instrument
 // and target height.  For the measurements-minus-computed vector, the "computed" distance
-// is the true distance between the instrument and target, and so must take into consideration 
-// instrument and target heights.  However, the dX, dY, dZ components for the partial 
-// derivatives represent the true geometric difference between the two stations (not 
+// is the true distance between the instrument and target, and so must take into consideration
+// instrument and target heights.  However, the dX, dY, dZ components for the partial
+// derivatives represent the true geometric difference between the two stations (not
 // instrument and target).
 void dna_adjust::UpdateDesignNormalMeasMatrices_Z(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
-	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
+	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr));
 	UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
 
 	it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
@@ -5522,11 +5622,11 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_Z(pit_vmsr_t _it_msr, UINT32& de
 
 	double local_12e, local_12n, local_12up;
 
-	// Initialise measurement.  No need to test if no further calculations are 
+	// Initialise measurement.  No need to test if no further calculations are
 	// required (as in stage mode), as this is done later (below)
 	InitialiseMeasurement(_it_msr, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !rebuildingDesign_)
 	{
 		// deflections available?
 		if (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION || fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION)
@@ -5602,21 +5702,21 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_Z(pit_vmsr_t _it_msr, UINT32& de
 	// Update AtVinv based on new design matrix elements
 	UpdateAtVinv(_it_msr, stn1, stn2, 0, design_row, design, AtVinv, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !skipNormals)
 		// Add weighted measurement contributions to normal matrix
 		UpdateNormals_BCEKLMSVZ(stn1, stn2, design_row, normals, design, AtVinv);
 	else
 		design_row++;
 }
-	
+
 
 // Orthometric height difference.
-// This function requires geoid-ellipsoid separation in order to reduce 
-// to ellipsoidal height difference counterpart.  
+// This function requires geoid-ellipsoid separation in order to reduce
+// to ellipsoidal height difference counterpart.
 // Hence, run geoid with -f, -s and -n options
 void dna_adjust::UpdateDesignNormalMeasMatrices_L(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
 	UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
@@ -5641,11 +5741,11 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_L(pit_vmsr_t _it_msr, UINT32& de
 		&h1, &h2, &nu1, &nu2, &Zn1, &Zn2, 
 		datum_.GetEllipsoidRef()));
 
-	// Initialise measurement.  No need to test if no further calculations are 
+	// Initialise measurement.  No need to test if no further calculations are
 	// required (as in stage mode), as this is done later (below)
 	InitialiseMeasurement(_it_msr, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !rebuildingDesign_)
 	{
 		// N value available?
 		if (fabs(stn1_it->geoidSep) > PRECISION_1E4 ||
@@ -5676,7 +5776,7 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_L(pit_vmsr_t _it_msr, UINT32& de
 	// Update AtVinv based on new design matrix elements
 	UpdateAtVinv(_it_msr, stn1, stn2, 0, design_row, design, AtVinv, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !skipNormals)
 		// Add weighted measurement contributions to normal matrix
 		UpdateNormals_BCEKLMSVZ(stn1, stn2, design_row, normals, design, AtVinv);
 	else
@@ -5684,17 +5784,17 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_L(pit_vmsr_t _it_msr, UINT32& de
 }
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_I(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
-	// Initialise measurement.  No need to test if no further calculations are 
+	// Initialise measurement.  No need to test if no further calculations are
 	// required (as in stage mode), as this is done later (below)
 	InitialiseMeasurement(_it_msr, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !rebuildingDesign_)
 	{
 		it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
-	
+
 		// deflections available?
 		if (fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION)
 		{
@@ -5709,22 +5809,22 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_I(pit_vmsr_t _it_msr, UINT32& de
 	}    
 
 	UpdateDesignNormalMeasMatrices_IP(_it_msr, design_row, block,
-		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 }
 
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_J(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
-	// Initialise measurement.  No need to test if no further calculations are 
+	// Initialise measurement.  No need to test if no further calculations are
 	// required (as in stage mode), as this is done later (below)
 	InitialiseMeasurement(_it_msr, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !rebuildingDesign_)
 	{
 		it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
-	
+
 		// deflections available?
 		if (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION)
 		{
@@ -5740,27 +5840,27 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_J(pit_vmsr_t _it_msr, UINT32& de
 	}    
 
 	UpdateDesignNormalMeasMatrices_JQ(_it_msr, design_row, block,
-		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 }
 
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_P(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
-	// Initialise measurement and test if no further calculations are 
+	// Initialise measurement and test if no further calculations are
 	// required (as in stage mode)
 	if (InitialiseMeasurement(_it_msr, buildnewMatrices))
 		return;
 
 	UpdateDesignNormalMeasMatrices_IP(_it_msr, design_row, block,
-		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 }
-	
+
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_IP(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
 	
@@ -5806,31 +5906,31 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_IP(pit_vmsr_t _it_msr, UINT32& d
 	// Update AtVinv based on new design matrix elements
 	UpdateAtVinv(_it_msr, stn1, 0, 0, design_row, design, AtVinv, buildnewMatrices);
 	
-	if (buildnewMatrices)
+	if (buildnewMatrices && !skipNormals)
 		// Add weighted measurement contributions to normal matrix
 		UpdateNormals_HIJPQR(stn1, design_row, normals, design, AtVinv);
 	else
 		design_row++;
 }
-	
+
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_Q(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
-	// Initialise measurement and test if no further calculations are 
+	// Initialise measurement and test if no further calculations are
 	// required (as in stage mode)
 	if (InitialiseMeasurement(_it_msr, buildnewMatrices))
 		return;
 
 	UpdateDesignNormalMeasMatrices_JQ(_it_msr, design_row, block,
-		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 }
-	
+
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_JQ(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
 	
@@ -5858,26 +5958,26 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_JQ(pit_vmsr_t _it_msr, UINT32& d
 	// Update AtVinv based on new design matrix elements
 	UpdateAtVinv(_it_msr, stn1, 0, 0, design_row, design, AtVinv, buildnewMatrices);
 	
-	if (buildnewMatrices)
+	if (buildnewMatrices && !skipNormals)
 		// Add weighted measurement contributions to normal matrix
 		UpdateNormals_HIJPQR(stn1, design_row, normals, design, AtVinv);
 	else
 		design_row++;
 }
-	
+
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_H(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
-	// Initialise measurement.  No need to test if no further calculations are 
+	// Initialise measurement.  No need to test if no further calculations are
 	// required (as in stage mode), as this is done later (below)
 	InitialiseMeasurement(_it_msr, buildnewMatrices);
 
-	if (buildnewMatrices)
+	if (buildnewMatrices && !rebuildingDesign_)
 	{
 		it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
-	
+
 		// N value available?
 		if (fabs(stn1_it->geoidSep) > PRECISION_1E4)
 		{
@@ -5891,13 +5991,13 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_H(pit_vmsr_t _it_msr, UINT32& de
 	}
 
 	UpdateDesignNormalMeasMatrices_HR(_it_msr, design_row, block,
-		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 }
 
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_HR(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr));
 
@@ -5931,31 +6031,31 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_HR(pit_vmsr_t _it_msr, UINT32& d
 	// Update AtVinv based on new design matrix elements
 	UpdateAtVinv(_it_msr, stn1, 0, 0, design_row, design, AtVinv, buildnewMatrices);
 	
-	if (buildnewMatrices)
+	if (buildnewMatrices && !skipNormals)
 		// Add weighted measurement contributions to normal matrix
 		UpdateNormals_HIJPQR(stn1, design_row, normals, design, AtVinv);
 	else
 		design_row++;
 }
-	
+
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_R(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
-	// Initialise measurement and test if no further calculations are 
+	// Initialise measurement and test if no further calculations are
 	// required (as in stage mode)
 	if (InitialiseMeasurement(_it_msr, buildnewMatrices))
 		return;
 
 	UpdateDesignNormalMeasMatrices_HR(_it_msr, design_row, block,
-		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
+		measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices, skipNormals);
 }
-	
+
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_X(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	it_vmsr_t _it_msr_first(*_it_msr);
 
@@ -5992,7 +6092,7 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_X(pit_vmsr_t _it_msr, UINT32& de
 
 	matrix_2d var_cart(baseline_count * 3, baseline_count * 3);
 
-	if (buildnewMatrices || projectSettings_.a.stage)
+	if (buildnewMatrices || projectSettings_.a.stage || skipNormals)
 	{
 		// Load apriori variance matrix, and assign to binary measurement
 		// If required, apply scalars
@@ -6002,10 +6102,10 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_X(pit_vmsr_t _it_msr, UINT32& de
 			return;
 	}
 
-	// If this method is called via PrepareAdjustment() and the adjustment 
+	// If this method is called via PrepareAdjustment() and the adjustment
 	// mode is staged, then don't update the AtVinv matrix.  This will be
 	// done during an adjustment via AdjustPhasedForward().
-	if (!buildnewMatrices && !projectSettings_.a.stage)
+	if (!buildnewMatrices && !projectSettings_.a.stage && !skipNormals)
 		return;
 
 	UINT32 cluster_cov;
@@ -6064,11 +6164,11 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_X(pit_vmsr_t _it_msr, UINT32& de
 			_it_msr_temp += 3;
 	}
 
-	if (projectSettings_.a.stage || !buildnewMatrices)
+	if (projectSettings_.a.stage || !buildnewMatrices || skipNormals)
 		return;
-	
+
 	_it_msr_temp = _it_msr_first;
-	
+
 	matrix_2d tmp0(3, 3);
 
 	// Build  At * V-1 * A variances
@@ -6147,8 +6247,8 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_X(pit_vmsr_t _it_msr, UINT32& de
 
 
 void dna_adjust::UpdateDesignNormalMeasMatrices_Y(pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
-											  matrix_2d* measMinusComp, matrix_2d* estimatedStations, 
-											  matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices)
+											  matrix_2d* measMinusComp, matrix_2d* estimatedStations,
+											  matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices, bool skipNormals)
 {
 	it_vmsr_t _it_msr_first(*_it_msr);
 	it_vmsr_t tmp_msr;
@@ -6361,23 +6461,23 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_Y(pit_vmsr_t _it_msr, UINT32& de
 
 	matrix_2d var_cart(point_count * 3, point_count * 3);
 
-	if (buildnewMatrices || projectSettings_.a.stage)
+	if (buildnewMatrices || projectSettings_.a.stage || skipNormals)
 	{
 		// Load apriori variance matrix, and assign to binary measurement
-		// If required, propagate to cartesian reference frame and apply 
+		// If required, propagate to cartesian reference frame and apply
 		// scalars
 		LoadVarianceMatrix_Y(_it_msr_first, &var_cart, coordType);
-	
+
 		// If preparing for a stage adjustment, return
 		// Normals will be built for each block as needed
 		if (buildnewMatrices && projectSettings_.a.stage)
 			return;
 	}
-	
-	// If this method is called via PrepareAdjustment() and the adjustment 
+
+	// If this method is called via PrepareAdjustment() and the adjustment
 	// mode is staged, then don't update the AtVinv matrix.  This will be
 	// done during an adjustment via AdjustPhasedForward().
-	if (!buildnewMatrices && !projectSettings_.a.stage)
+	if (!buildnewMatrices && !projectSettings_.a.stage && !skipNormals)
 		return;
 
 	UINT32 cluster_cov;
@@ -6420,9 +6520,9 @@ void dna_adjust::UpdateDesignNormalMeasMatrices_Y(pit_vmsr_t _it_msr, UINT32& de
 		design_row_begin += 3;
 	}
 
-	if (projectSettings_.a.stage || !buildnewMatrices)
+	if (projectSettings_.a.stage || !buildnewMatrices || skipNormals)
 		return;
-	
+
 	_it_msr_temp = _it_msr_first;
 
 	// Add to At * V-1 * A
@@ -6485,6 +6585,13 @@ void dna_adjust::SolveTry(bool COMPUTE_INVERSE, const UINT32& block)
 
 void dna_adjust::Solve(bool COMPUTE_INVERSE, const UINT32& block)
 {
+	assert(v_design_.at(block).rows() > 0 && "Solve: design has 0 rows");
+	assert(v_design_.at(block).columns() > 0 && "Solve: design has 0 columns");
+	assert(v_AtVinv_.at(block).rows() > 0 && "Solve: AtVinv has 0 rows");
+	assert(v_AtVinv_.at(block).columns() > 0 && "Solve: AtVinv has 0 columns");
+	assert(v_normals_.at(block).rows() > 0 && "Solve: normals has 0 rows");
+	assert(v_measMinusComp_.at(block).rows() > 0 && "Solve: measMinusComp has 0 rows");
+
 	// debug matrices if required
 	debug_SolutionInformation(block);
 
@@ -6504,33 +6611,24 @@ void dna_adjust::Solve(bool COMPUTE_INVERSE, const UINT32& block)
 		// the normal matrix before inversion and subsequently reversing the effect.
 		//
 
-		// 1. Create scalar matrix
-		matrix_2d *S = nullptr, *SN = nullptr;
+		// 1. Scale normals to unity using diagonal scaling
+		UINT32 n = v_normals_.at(block).rows();
+		std::vector<double> s_diag;
 
 		if (projectSettings_.a.scale_normals_to_unity)
 		{
-			S = new matrix_2d(v_normals_.at(block).rows(), v_normals_.at(block).rows());
-			SN = new matrix_2d(v_normals_.at(block).rows(), v_normals_.at(block).rows());
-			for (UINT32 i(0); i<v_normals_.at(block).rows(); ++i)
-				S->put(i, i, sqrt(v_normals_.at(block).get(i, i)));
-			// 2. Scale Normals to reduce the diagonal elements of Normals to unity
-			//SN->multiply(*S, v_normals_.at(block));
-			SN->multiply(*S, "N", v_normals_.at(block), "N");
-			
-			//v_normals_.at(block).multiply(*SN, *S);
-			v_normals_.at(block).multiply(*SN, "N", *S, "N");
+			s_diag.resize(n);
+			for (UINT32 i(0); i<n; ++i)
+				s_diag[i] = 1.0 / sqrt(v_normals_.at(block).get(i, i));
+			v_normals_.at(block).scale_symmetric_diagonal(s_diag.data());
 		}
 		//////////////////
-	
-		// Clear upper triangle to match expected structure for cholesky_inverse
-		v_normals_.at(block).clearupper();
-		
+
 		// Calculate Inverse of AT * V-1 * A
-		// Explicitly set LOWER_IS_CLEARED to false (data is in lower triangle)
-		FormInverseVarianceMatrix(&(v_normals_.at(block)), false);
+		FormInverseVarianceMatrix(&(v_normals_.at(block)), false, false);
 
 		// Check for a failed inverse solution
-		if (boost::math::isnan(v_normals_.at(block).get(0, 0)) || 
+		if (boost::math::isnan(v_normals_.at(block).get(0, 0)) ||
 			boost::math::isinf(v_normals_.at(block).get(0, 0)))
 		{
 			std::stringstream ss;
@@ -6540,17 +6638,10 @@ void dna_adjust::Solve(bool COMPUTE_INVERSE, const UINT32& block)
 		}
 
 		//////////////////
-		// 2. Compute inverse of N (via S * (SNS)-1 * S)
+		// 2. Reverse the scaling on the inverse
 		if (projectSettings_.a.scale_normals_to_unity)
 		{
-			//SN->multiply(*S, v_normals_.at(block));
-			SN->multiply(*S, "N", v_normals_.at(block), "N");
-
-			//v_normals_.at(block).multiply(*SN, *S);
-			v_normals_.at(block).multiply(*SN, "N", *S, "N");
-
-			delete S;
-			delete SN;
+			v_normals_.at(block).scale_symmetric_diagonal(s_diag.data());
 		}
 		//////////////////
 	}
@@ -6567,10 +6658,13 @@ void dna_adjust::Solve(bool COMPUTE_INVERSE, const UINT32& block)
 	// compute weighted "measured minus computed"
 	matrix_2d At_Vinv_m(v_design_.at(block).columns(), 1);
 	At_Vinv_m.multiply(v_AtVinv_.at(block), "N", v_measMinusComp_.at(block), "N");
-	
+
 	// Solve corrections from normal equations
 	v_corrections_.at(block).redim(v_design_.at(block).columns(), 1);
-	v_corrections_.at(block).multiply(v_normals_.at(block), "N", At_Vinv_m, "N");
+	if (v_normals_.at(block).is_symmetric())
+		v_corrections_.at(block).multiply_sym(v_normals_.at(block), At_Vinv_m);
+	else
+		v_corrections_.at(block).multiply(v_normals_.at(block), "N", At_Vinv_m, "N");
 
 	if (projectSettings_.g.verbose > 0)
 	{
@@ -6854,21 +6948,26 @@ void dna_adjust::ComputeAdjustedMsrPrecisions()
 			if (projectSettings_.a.stage)
 			{
 				DeserialiseBlockFromMappedFile(block, 7,
-					sf_normals, sf_rigorous_vars, 
+					sf_normals, sf_rigorous_vars,
 					sf_design, sf_atvinv, sf_estimated_stns,
 					sf_meas_minus_comp, sf_prec_adj_msrs);
 				v_normals_.at(block) = v_rigorousVariances_.at(block);
 
 				FillDesignNormalMeasurementsMatrices(false, block, false);
 			}
-
 			// Compute adjusted measurement precisions (v_precAdjMsrsFull_)
-			// from design and rigorous station variances 
+			// from design and rigorous station variances
 			ComputePrecisionAdjMsrs(block);
 
 			// Update measurement records and Pelzer's Global reliability
 			UpdateMsrRecords(block);
 
+			if (projectSettings_.a.stage)
+			{
+				// Persist final residuals/precisions before chi-square reloads staged matrices.
+				SerialiseBlockToMappedFile(block, 2, sf_meas_minus_comp, sf_prec_adj_msrs);
+			}
+
 			// For staged adjustments, unload all matrix data
 			if (projectSettings_.a.stage)
 				UnloadBlock(block);
@@ -6877,9 +6976,9 @@ void dna_adjust::ComputeAdjustedMsrPrecisions()
 	case SimultaneousMode:
 	case Phased_Block_1Mode:			// only block 1 is rigorous
 		// Compute adjusted measurement precisions (v_precAdjMsrsFull_)
-		// from design and rigorous station variances 
+		// from design and rigorous station variances
 		ComputePrecisionAdjMsrs();
-		
+
 		// Update measurement records and Pelzer's Global reliability
 		UpdateMsrRecords();
 		break;
@@ -7062,8 +7161,9 @@ void dna_adjust::ComputeandPrintAdjMsrOnIteration()
 	for (UINT32 block(0); block<blockCount_; ++block)
 	{
 		if (projectSettings_.a.stage)
-			DeserialiseBlockFromMappedFile(block, 4, sf_normals,
-				sf_meas_minus_comp, sf_design, sf_prec_adj_msrs);
+			DeserialiseBlockFromMappedFile(block, 5, sf_normals,
+				sf_meas_minus_comp, sf_design, sf_prec_adj_msrs,
+				sf_estimated_stns);
 
 		// send subvector of measurements from this block
 		end = begin + v_CML_.at(block).size();
@@ -7072,8 +7172,9 @@ void dna_adjust::ComputeandPrintAdjMsrOnIteration()
 		printHeader = false;
 
 		if (projectSettings_.a.stage)
-			UnloadBlock(block, 4, sf_normals,
-				sf_meas_minus_comp, sf_design, sf_prec_adj_msrs);
+			UnloadBlock(block, 5, sf_normals,
+				sf_meas_minus_comp, sf_design, sf_prec_adj_msrs,
+				sf_estimated_stns);
 	}
 }
 
@@ -7126,6 +7227,13 @@ void dna_adjust::ComputeandPrintAdjMsrBlockOnIteration(const UINT32& block, v_ui
 {
 	// Compute adjusted measurements
 	ComputeAdjMsrBlockOnIteration(block);
+
+	if (projectSettings_.a.stage)
+	{
+		// Alternate GNSS unit printing reloads adjusted measurement precisions
+		// from the staged file, so persist the per-iteration recomputation first.
+		SerialiseBlockToMappedFile(block, 1, sf_prec_adj_msrs);
+	}
 	
 	// Print adjusted measurements
 	printer_->PrintAdjMeasurements(msr_block, printHeader);
@@ -7239,7 +7347,6 @@ void dna_adjust::ComputeChiSquareNetwork()
 	}
 }
 	
-
 void dna_adjust::ComputeChiSquarePhased(const UINT32& block)
 {
 	// Compute adjusted measurement statistics
@@ -7339,7 +7446,341 @@ void dna_adjust::OutputLargestCorrection(std::string& formatted_msg)
 
 	formatted_msg = ss.str();
 }
-	
+
+void dna_adjust::UpdateIterationDiagnostics()
+{
+	for (UINT32 block = 0; block < blockCount_; ++block)
+	{
+		// For staged adjustments, load corrections from mapped file
+		if (projectSettings_.a.stage)
+			DeserialiseBlockFromMappedFile(block, 1, sf_corrections);
+
+		UINT32 nParams = v_corrections_.at(block).rows();
+		UINT32 nStations = nParams / 3;
+
+		for (UINT32 s = 0; s < nStations; ++s)
+		{
+			UINT32 stnIdx = v_parameterStationList_.at(block).at(s);
+			UINT32 base = s * 3;
+
+			double cx = v_corrections_.at(block).get(base, 0);
+			double cy = v_corrections_.at(block).get(base + 1, 0);
+			double cz = v_corrections_.at(block).get(base + 2, 0);
+
+			double magCurr = sqrt(cx*cx + cy*cy + cz*cz);
+
+			auto prevIt = corrPrev_.find(stnIdx);
+			if (prevIt == corrPrev_.end())
+			{
+				// First time seeing this station — store and move on
+				corrPrev_[stnIdx] = {cx, cy, cz};
+				continue;
+			}
+
+			double px = prevIt->second.cx;
+			double py = prevIt->second.cy;
+			double pz = prevIt->second.cz;
+			double magPrev = sqrt(px*px + py*py + pz*pz);
+
+			// Update stored corrections
+			prevIt->second = {cx, cy, cz};
+
+			// Skip tiny corrections (sub-millimetre)
+			if (magCurr < 0.001 && magPrev < 0.001)
+			{
+				stnOscCount_[stnIdx] = 0;
+				continue;
+			}
+
+			// Dot product and cosine of angle between correction vectors
+			double dot = cx*px + cy*py + cz*pz;
+			double denom = magCurr * magPrev;
+			double cosAngle = (denom > 1e-30) ? dot / denom : 0.0;
+
+			// Magnitude ratio
+			double ratio = (magPrev > 1e-30) ? magCurr / magPrev : 0.0;
+
+			// Oscillation: anti-parallel (cos < -0.5), similar magnitude (ratio 0.3–3.0)
+			if (cosAngle < -0.5 && ratio > 0.3 && ratio < 3.0)
+				stnOscCount_[stnIdx]++;
+			else
+				stnOscCount_[stnIdx] = 0;
+
+			if (stnOscCount_[stnIdx] >= 2)
+			{
+				// Convert to local (e, n, up)
+				matrix_2d cart(3, 1), local(3, 1);
+				cart.put(0, 0, cx);
+				cart.put(1, 0, cy);
+				cart.put(2, 0, cz);
+				Rotate_CartLocal<double>(cart, &local,
+					bstBinaryRecords_.at(stnIdx).currentLatitude,
+					bstBinaryRecords_.at(stnIdx).currentLongitude);
+
+				double localMag = sqrt(local.get(0,0)*local.get(0,0) +
+					local.get(1,0)*local.get(1,0) + local.get(2,0)*local.get(2,0));
+
+				auto hit = oscHistory_.find(stnIdx);
+				if (hit == oscHistory_.end())
+				{
+					OscillationRecord rec;
+					rec.stnBstIdx = stnIdx;
+					rec.firstIteration = CurrentIteration();
+					rec.lastIteration = CurrentIteration();
+					rec.maxCycles = stnOscCount_[stnIdx];
+					rec.firstMag = localMag;
+					rec.lastMag = localMag;
+					rec.lastE = local.get(0, 0);
+					rec.lastN = local.get(1, 0);
+					rec.lastUp = local.get(2, 0);
+					oscHistory_[stnIdx] = rec;
+				}
+				else
+				{
+					hit->second.lastIteration = CurrentIteration();
+					hit->second.maxCycles = stnOscCount_[stnIdx];
+					hit->second.lastMag = localMag;
+					hit->second.lastE = local.get(0, 0);
+					hit->second.lastN = local.get(1, 0);
+					hit->second.lastUp = local.get(2, 0);
+				}
+			}
+		}
+
+		// For staged adjustments, unload corrections
+		if (projectSettings_.a.stage)
+			UnloadBlock(block, 1, sf_corrections);
+	}
+}
+
+void dna_adjust::PrintOscillationSummary()
+{
+	if (oscHistory_.empty())
+		return;
+
+	// Collect records with meaningful magnitude, sort descending
+	std::vector<const OscillationRecord*> sorted;
+	for (auto& kv : oscHistory_)
+	{
+		double peak = std::max(kv.second.firstMag, kv.second.lastMag);
+		if (peak >= 0.1)
+			sorted.push_back(&kv.second);
+	}
+
+	if (sorted.empty())
+		return;
+
+	std::sort(sorted.begin(), sorted.end(),
+		[](const OscillationRecord* a, const OscillationRecord* b) {
+			return std::max(a->firstMag, a->lastMag) > std::max(b->firstMag, b->lastMag);
+		});
+
+	// Cap at 20 stations
+	size_t limit = std::min(sorted.size(), static_cast<size_t>(20));
+
+	std::cout << std::endl;
+	std::cout << "+ Oscillating stations detected (" << sorted.size() << " total, showing top "
+		<< limit << "):" << std::endl;
+
+	for (size_t i = 0; i < limit; ++i)
+	{
+		const auto* rec = sorted[i];
+
+		// Classify direction
+		double horizMag = sqrt(rec->lastE * rec->lastE + rec->lastN * rec->lastN);
+		double vertMag = fabs(rec->lastUp);
+		std::string direction;
+		if (vertMag < 0.01 * horizMag)
+			direction = "horizontal";
+		else if (horizMag < 0.01 * vertMag)
+			direction = "vertical";
+		else
+			direction = "3D";
+
+		std::cout << "  - " << bstBinaryRecords_.at(rec->stnBstIdx).stationName
+			<< std::fixed << std::setprecision(1)
+			<< " — " << rec->firstMag << "m to " << rec->lastMag << "m"
+			<< ", " << direction
+			<< ", " << rec->maxCycles << " cycles"
+			<< " (iterations " << rec->firstIteration << "-" << rec->lastIteration << ")"
+			<< std::endl;
+	}
+}
+
+bool dna_adjust::MeasurementTouchesOscillatingStation(const UINT32& msrIndex) const
+{
+	if (oscHistory_.empty() || msrIndex >= bmsBinaryRecords_.size())
+		return false;
+
+	std::vector<UINT32> msrStations;
+	GetMsrStations<UINT32>(bmsBinaryRecords_, msrIndex, msrStations);
+
+	for (const auto& stnIndex : msrStations)
+	{
+		if (oscHistory_.find(stnIndex) != oscHistory_.end())
+			return true;
+	}
+
+	return false;
+}
+
+std::string dna_adjust::MeasurementStationNames(const UINT32& msrIndex) const
+{
+	if (msrIndex >= bmsBinaryRecords_.size())
+		return "(measurement index unavailable)";
+
+	std::vector<UINT32> msrStations;
+	GetMsrStations<UINT32>(bmsBinaryRecords_, msrIndex, msrStations);
+
+	std::string stationNames;
+	for (const auto& stnIndex : msrStations)
+	{
+		if (stnIndex >= bstBinaryRecords_.size())
+			continue;
+
+		if (!stationNames.empty())
+			stationNames += " -> ";
+		stationNames += bstBinaryRecords_.at(stnIndex).stationName;
+	}
+
+	if (stationNames.empty())
+		return "(stations unavailable)";
+
+	return stationNames;
+}
+
+void dna_adjust::PrintSuspectMeasurementSummary(std::ostream& os, size_t limit) const
+{
+	struct SuspectMeasurementRecord {
+		UINT32 msrIndex;
+		char measType;
+		UINT32 clusterID;
+		UINT32 fileOrder;
+		double absNStat;
+		double nStat;
+		double tStat;
+		double measCorr;
+		double residualPrec;
+		double pelzerRel;
+		bool exceedsCritical;
+		bool touchesOscillatingStation;
+		std::string stationNames;
+	};
+
+	if (bmsBinaryRecords_.empty() || limit == 0)
+		return;
+
+	std::vector<SuspectMeasurementRecord> records;
+	records.reserve(bmsBinaryRecords_.size());
+
+	for (UINT32 msrIndex = 0; msrIndex < bmsBinaryRecords_.size(); ++msrIndex)
+	{
+		const auto& msr = bmsBinaryRecords_.at(msrIndex);
+		if (msr.ignore ||
+			!std::isfinite(msr.NStat) ||
+			!std::isfinite(msr.residualPrec) ||
+			msr.residualPrec <= 0.0)
+			continue;
+
+		const double absNStat = fabs(msr.NStat);
+		const bool exceedsCritical = absNStat > criticalValue_;
+		const bool touchesOscillatingStation = MeasurementTouchesOscillatingStation(msrIndex);
+
+		if (!exceedsCritical && !touchesOscillatingStation)
+			continue;
+
+		records.push_back({
+			msrIndex,
+			msr.measType,
+			msr.clusterID,
+			msr.fileOrder,
+			absNStat,
+			msr.NStat,
+			msr.TStat,
+			msr.measCorr,
+			msr.residualPrec,
+			msr.PelzerRel,
+			exceedsCritical,
+			touchesOscillatingStation,
+			MeasurementStationNames(msrIndex)
+		});
+	}
+
+	if (records.empty())
+		return;
+
+	std::vector<const SuspectMeasurementRecord*> oscillatingRecords;
+	std::vector<const SuspectMeasurementRecord*> outlierRecords;
+	oscillatingRecords.reserve(records.size());
+	outlierRecords.reserve(records.size());
+
+	for (const auto& record : records)
+	{
+		if (record.touchesOscillatingStation)
+			oscillatingRecords.push_back(&record);
+		if (record.exceedsCritical && !record.touchesOscillatingStation)
+			outlierRecords.push_back(&record);
+	}
+
+	auto sortByNStat = [](const SuspectMeasurementRecord* lhs,
+		const SuspectMeasurementRecord* rhs) {
+		if (lhs->absNStat == rhs->absNStat)
+			return lhs->msrIndex < rhs->msrIndex;
+		return lhs->absNStat > rhs->absNStat;
+	};
+
+	std::sort(oscillatingRecords.begin(), oscillatingRecords.end(), sortByNStat);
+	std::sort(outlierRecords.begin(), outlierRecords.end(), sortByNStat);
+
+	std::ios::fmtflags oldFlags = os.flags();
+	std::streamsize oldPrecision = os.precision();
+
+	auto printRecord = [&os](const SuspectMeasurementRecord& record) {
+		os << "  - " << record.measType
+			<< " msr " << record.msrIndex
+			<< " cluster " << record.clusterID
+			<< " file-order " << record.fileOrder
+			<< " " << record.stationNames
+			<< ": N=" << std::fixed << std::setprecision(2) << record.nStat;
+
+		if (std::isfinite(record.tStat) && fabs(record.tStat) > 0.0)
+			os << ", T=" << std::fixed << std::setprecision(2) << record.tStat;
+
+		os << ", corr=" << std::scientific << std::setprecision(3) << record.measCorr
+			<< ", residual precision=" << std::scientific << std::setprecision(3) << record.residualPrec
+			<< ", Pelzer=" << std::fixed << std::setprecision(2) << record.pelzerRel;
+
+		if (record.exceedsCritical)
+			os << ", exceeds critical";
+		if (record.touchesOscillatingStation)
+			os << ", touches oscillating station";
+
+		os << std::endl;
+	};
+
+	auto printList = [&os, &printRecord, limit](const std::string& title,
+		const std::vector<const SuspectMeasurementRecord*>& list) {
+		if (list.empty())
+			return;
+
+		const size_t listLimit = std::min(list.size(), limit);
+		os << std::endl << "+ " << title << " (" << list.size()
+			<< " total, showing top " << listLimit << "):" << std::endl;
+
+		for (size_t i = 0; i < listLimit; ++i)
+			printRecord(*list.at(i));
+	};
+
+	if (!oscillatingRecords.empty())
+		printList("Suspect measurements connected to oscillating stations", oscillatingRecords);
+
+	printList(oscillatingRecords.empty() ? "Largest measurement N-statistics" :
+		"Largest remaining measurement N-statistics", outlierRecords);
+
+	os.flags(oldFlags);
+	os.precision(oldPrecision);
+}
+
 void dna_adjust::ComputePrecisionAdjMsrs(const UINT32& block /*= 0*/)
 {
 	if (projectSettings_.a.report_mode)
@@ -7348,6 +7789,7 @@ void dna_adjust::ComputePrecisionAdjMsrs(const UINT32& block /*= 0*/)
 	// A*V-1*At, where:
 	//   - A is design matrix
 	//   - V is the inverse of the normals (i.e. precision of estimates)
+	v_precAdjMsrsFull_.at(block).redim(v_measurementVarianceCount_.at(block), 1);
 	v_precAdjMsrsFull_.at(block).zero();
 
 	UINT32 design_row(0);
@@ -8027,19 +8469,19 @@ void dna_adjust::ComputeChiSquare_D(it_vmsr_t& _it_msr, UINT32& measurement_inde
 }
 	
 
-void dna_adjust::FormInverseVarianceMatrix(matrix_2d* vmat, bool LOWER_IS_CLEARED)
+void dna_adjust::FormInverseVarianceMatrix(matrix_2d* vmat, bool LOWER_IS_CLEARED, bool mark_symmetric)
 {
 	if (vmat->rows() == 1)
 	{
 		vmat->put(0, 0, 1./vmat->get(0, 0));
 		return;
 	}
-	
+
 	// As of version 3.2.0, force all inversions to use MKL.  This change
 	// is enforced for two reasons:
 	// 1. Sweep, Gaussian inverse and numerical recipes cholesky
-	//    all require matrix data to be stored in row wise fashion, upper 
-	//    triangle only, whereas contiguous matrix class stores matrix data 
+	//    all require matrix data to be stored in row wise fashion, upper
+	//    triangle only, whereas contiguous matrix class stores matrix data
 	//    in column wise fashion, lower triangle.
 	// 2. Sweep, Gaussian never really offered a stable solution.
 	// The following switch is kept in case future development warrants
@@ -8049,8 +8491,8 @@ void dna_adjust::FormInverseVarianceMatrix(matrix_2d* vmat, bool LOWER_IS_CLEARE
 
 	// TODO: All functions which load variance matrix from binary files
 	// store the data in upper triangular form.  This could be changed to
-	// lower triangular form, thus alleviating the need to pass 
-	// LOWER_IS_CLEARED.  That is, force all operations to use a lower 
+	// lower triangular form, thus alleviating the need to pass
+	// LOWER_IS_CLEARED.  That is, force all operations to use a lower
 	// triangular matrix.  Not sure if this would create an efficiency or not.
 	switch (projectSettings_.a.inverse_method_msr)
 	{
@@ -8062,8 +8504,7 @@ void dna_adjust::FormInverseVarianceMatrix(matrix_2d* vmat, bool LOWER_IS_CLEARE
 //		break;
 	case Cholesky_mkl:
 	default:
-		// Inversion using Intel MKL
-		vmat->cholesky_inverse(LOWER_IS_CLEARED);
+		vmat->cholesky_inverse(LOWER_IS_CLEARED, mark_symmetric);
 		break;
 	// choleskyinverse broke once the storage order of the matrix buffer was
 	// changed from row-wise to column wise.
diff --git a/dynadjust/dynadjust/dnaadjust/dnaadjust.hpp b/dynadjust/dynadjust/dnaadjust/dnaadjust.hpp
index 9039f7711..33fe58c7a 100644
--- a/dynadjust/dynadjust/dnaadjust/dnaadjust.hpp
+++ b/dynadjust/dynadjust/dnaadjust/dnaadjust.hpp
@@ -33,6 +33,7 @@
 #include <exception>
 #include <fstream>
 #include <iostream>
+#include <map>
 #include <math.h>
 #include <queue>
 #include <stdexcept>
@@ -102,6 +103,7 @@ namespace networkadjust {
 extern std::mutex maxCorrMutex;
 
 using dynadjust::cpu_timer;
+using dynadjust::FormatElapsedTime;
 
 // forward declaration of dna_adjust
 class dna_adjust;
@@ -210,6 +212,7 @@ class DNAADJUST_API dna_adjust {
 class dna_adjust {
 #endif
     friend class DynAdjustPrinter;
+    friend class DynAdjustJsonPrinter;
     
   public:
     dna_adjust();
@@ -288,16 +291,26 @@ class dna_adjust {
     // void PrintEstimatedStationCoordinatestoDNAXML_Y(const std::string& msrFile,
     //                                                 INPUT_FILE_TYPE t);
 
+    void PrintOscillationSummary();
+    void PrintSuspectMeasurementSummary(std::ostream& os = std::cout,
+                                        size_t limit = 20) const;
     void CloseOutputFiles();
     void UpdateBinaryFiles();
 
     UINT32 CurrentIteration() const;
     UINT32& incrementIteration();
+    void decrementIteration();
     void initialiseIteration(const UINT32& iteration = 0);
 
     inline UINT32 CurrentBlock() const { return currentBlock_; };
 
-    inline void SetcurrentBlock(const UINT32 b) { currentBlock_ = b; };
+    inline void SetcurrentBlock(const UINT32 b) {
+        auto now = std::chrono::steady_clock::now();
+        if (b != currentBlock_ && blockStartTime_.time_since_epoch().count() > 0)
+            lastBlockElapsedMs_ = std::chrono::duration_cast<std::chrono::milliseconds>(now - blockStartTime_).count();
+        currentBlock_ = b;
+        blockStartTime_ = now;
+    };
 
     inline void SetmaxCorr(const double c) {
 
@@ -311,6 +324,15 @@ class dna_adjust {
     }
     inline bool processingForward() { return forward_; }
     inline bool processingCombine() { return isCombining_; }
+    inline int64_t LastBlockElapsedMs() const { return lastBlockElapsedMs_; }
+    inline UINT32 CurrentBlockStationCount() const {
+        if (currentBlock_ < v_blockStationsMap_.size())
+            return static_cast<UINT32>(v_blockStationsMap_.at(currentBlock_).size());
+        return 0;
+    }
+    static void SetMaxBlasThreads(int n);
+    static int GetMaxBlasThreads();
+
     inline int GetDegreesOfFreedom() const { return degreesofFreedom_; }
     inline UINT32 GetMeasurementCount() const { return measurementParams_; }
     inline UINT32 GetUnknownsCount() const { return unknownParams_; }
@@ -350,6 +372,12 @@ class dna_adjust {
             return iterationCorrections_.get_message(iteration); // safe guard
         return iterationCorrections_.get_message(iteration - 1);
     };
+
+    inline std::string GetIterationTime(const UINT32& iteration) const {
+        if (iteration == 0)
+            return iterationTimes_.get_message(iteration); // safe guard
+        return iterationTimes_.get_message(iteration - 1);
+    };
     /////////////////////////////
 
     concurrent_ofstream<std::string> concurrent_adj_ofstream;
@@ -380,14 +408,21 @@ class dna_adjust {
     bool isAdjusting_;
     bool isCombining_;
     bool forward_;
+    bool rebuildingDesign_;
     bool isFirstTimeAdjustment_;
     bool isIterationComplete_;
     bool isAdjustmentQuestionable_;
 
     UINT32 blockCount_;
     UINT32 currentBlock_;
+    std::chrono::steady_clock::time_point blockStartTime_;
+    int64_t lastBlockElapsedMs_;
 
     std::chrono::milliseconds total_time_;
+    bool profileTimings_;
+    std::atomic<uint64_t> profileUpdateNormalsNs_;
+    std::atomic<uint64_t> profileStageLoadNs_;
+    std::atomic<uint64_t> profileStageStoreNs_;
     _ADJUST_STATUS_ adjustStatus_;
     vstring statusMessages_;
     UINT32 currentIteration_;
@@ -437,6 +472,7 @@ class dna_adjust {
     void UpdateAdjustment(bool iterate);
     void ValidateandFinaliseAdjustment(cpu_timer& tot_time);
     void PrintAdjustmentTime(cpu_timer& time, _TIMER_TYPE_);
+    void PrintPerformanceProfile() const;
     void InitialiseAdjustment();
     void SetDefaultReferenceFrame();
     void LoadNetworkFiles();
@@ -499,6 +535,8 @@ class dna_adjust {
     void DeserialiseBlockFromMappedFile(const UINT32& block,
                                         const int count = 0, ...);
     void UnloadBlock(const UINT32& block, const int file_count = 0, ...);
+    void AdviseBlockDontNeed(const UINT32& block);
+    void AdviseBlockWillNeed(const UINT32& block);
     void PurgeMatricesFromDisk();
 
     // Helpers
@@ -534,7 +572,8 @@ class dna_adjust {
     void
     UpdateDesignNormalMeasMatrices(pit_vmsr_t _it_msr, UINT32& design_row,
                                    bool buildnewMatrices, const UINT32& block,
-                                   bool MT_ReverseOrCombine);
+                                   bool MT_ReverseOrCombine,
+                                   bool skipNormals = false);
 
     void
     UpdateDesignNormalMeasMatrices_A(pit_vmsr_t _it_msr, UINT32& design_row,
@@ -542,40 +581,45 @@ class dna_adjust {
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_BK(pit_vmsr_t _it_msr, UINT32& design_row,
                                       const UINT32& block,
                                       matrix_2d* measMinusComp,
                                       matrix_2d* estimatedStations,
                                       matrix_2d* normals, matrix_2d* design,
-                                      matrix_2d* AtVinv, bool buildnewMatrices);
+                                      matrix_2d* AtVinv, bool buildnewMatrices,
+                                      bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_C(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void UpdateDesignNormalMeasMatrices_CEM(
         pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
         matrix_2d* measMinusComp, matrix_2d* estimatedStations,
         matrix_2d* normals, matrix_2d* design, matrix_2d* AtVinv,
-        bool buildnewMatrices);
+        bool buildnewMatrices, bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_D(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_E(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void UpdateDesignMeasMatrices_GX(pit_vmsr_t _it_msr, UINT32& design_row,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
@@ -587,113 +631,130 @@ class dna_adjust {
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_H(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_HR(pit_vmsr_t _it_msr, UINT32& design_row,
                                       const UINT32& block,
                                       matrix_2d* measMinusComp,
                                       matrix_2d* estimatedStations,
                                       matrix_2d* normals, matrix_2d* design,
-                                      matrix_2d* AtVinv, bool buildnewMatrices);
+                                      matrix_2d* AtVinv, bool buildnewMatrices,
+                                      bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_I(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_IP(pit_vmsr_t _it_msr, UINT32& design_row,
                                       const UINT32& block,
                                       matrix_2d* measMinusComp,
                                       matrix_2d* estimatedStations,
                                       matrix_2d* normals, matrix_2d* design,
-                                      matrix_2d* AtVinv, bool buildnewMatrices);
+                                      matrix_2d* AtVinv, bool buildnewMatrices,
+                                      bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_J(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_JQ(pit_vmsr_t _it_msr, UINT32& design_row,
                                       const UINT32& block,
                                       matrix_2d* measMinusComp,
                                       matrix_2d* estimatedStations,
                                       matrix_2d* normals, matrix_2d* design,
-                                      matrix_2d* AtVinv, bool buildnewMatrices);
+                                      matrix_2d* AtVinv, bool buildnewMatrices,
+                                      bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_L(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_M(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_P(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_Q(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_R(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_S(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_V(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
     void UpdateDesignNormalMeasMatrices_X(
         pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
         matrix_2d* measMinusComp, matrix_2d* estimatedStations,
-        matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices);
+        matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices,
+        bool skipNormals = false);
     void UpdateDesignNormalMeasMatrices_Y(
         pit_vmsr_t _it_msr, UINT32& design_row, const UINT32& block,
         matrix_2d* measMinusComp, matrix_2d* estimatedStations,
-        matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices);
+        matrix_2d* design, matrix_2d* AtVinv, bool buildnewMatrices,
+        bool skipNormals = false);
     void
     UpdateDesignNormalMeasMatrices_Z(pit_vmsr_t _it_msr, UINT32& design_row,
                                      const UINT32& block,
                                      matrix_2d* measMinusComp,
                                      matrix_2d* estimatedStations,
                                      matrix_2d* normals, matrix_2d* design,
-                                     matrix_2d* AtVinv, bool buildnewMatrices);
+                                     matrix_2d* AtVinv, bool buildnewMatrices,
+                                     bool skipNormals = false);
 
     void UpdateIgnoredMeasurements(pit_vmsr_t _it_msr,
                                    bool storeOriginalMeasurement);
@@ -827,7 +888,9 @@ class dna_adjust {
     void PrepareDesignAndMsrMnsCmpMatricesStage(const UINT32& block);
     void FillDesignNormalMeasurementsMatrices(bool buildnewMatrices,
                                               const UINT32& block,
-                                              bool MT_ReverseOrCombine);
+                                              bool MT_ReverseOrCombine,
+                                              bool skipNormals = false);
+    void RebuildDesignAndAtVinv(const UINT32& block);
 
     // void RecomputeMeasurementsCommonJunctions(const UINT32& nextBlock, const
     // UINT32& thisBlock, const UINT32& prevBlock);
@@ -861,11 +924,11 @@ class dna_adjust {
                                                bool printHeader);
     void ComputeAdjMsrBlockOnIteration(const UINT32& block);
 
-    void ComputeAdjustedMsrPrecisions();
+	void ComputeAdjustedMsrPrecisions();
 
-    void ComputeChiSquareNetwork();
-    void ComputeChiSquare(const UINT32& block);
-    void ComputeChiSquareSimultaneous();
+	void ComputeChiSquareNetwork();
+	void ComputeChiSquare(const UINT32& block);
+	void ComputeChiSquareSimultaneous();
     void ComputeChiSquarePhased(const UINT32& block);
 
     void ComputeTestStat(const double& dof, double& chiUpper, double& chiLower,
@@ -929,7 +992,7 @@ class dna_adjust {
                         matrix_2d* measMinusComp);
 
     void
-    FormInverseVarianceMatrix(matrix_2d* vmat, bool LOWER_IS_CLEARED = false);
+    FormInverseVarianceMatrix(matrix_2d* vmat, bool LOWER_IS_CLEARED = false, bool mark_symmetric = false);
     void
     FormInverseGPSVarianceMatrix(const it_vmsr_t& _it_msr, matrix_2d* vmat);
     bool
@@ -1118,6 +1181,7 @@ class dna_adjust {
     bool allStationsFixed_;
 
     message_bank<std::string> iterationCorrections_;
+    message_bank<std::string> iterationTimes_;
 
     // For each block
     vUINT32 v_ContiguousNetList_; // vector of contiguous network IDs
@@ -1205,6 +1269,27 @@ class dna_adjust {
     v_mat_2d v_corrections_;          // vector of residuals matrices
     v_mat_2d v_correctionsR_;         // vector of residuals matrices
 
+	// ----------------------------------------------
+	// Iteration diagnostics — oscillation detection
+    struct StationCorrRecord {
+        double cx, cy, cz;         // Cartesian corrections
+    };
+    struct OscillationRecord {
+        UINT32 stnBstIdx;          // BST record index
+        UINT32 firstIteration;
+        UINT32 lastIteration;
+        UINT32 maxCycles;
+        double firstMag;
+        double lastMag;
+        double lastE, lastN, lastUp;
+    };
+    std::map<UINT32, StationCorrRecord> corrPrev_;    // keyed by BST station index
+    std::map<UINT32, UINT32> stnOscCount_;            // keyed by BST station index
+    std::map<UINT32, OscillationRecord> oscHistory_;  // keyed by BST station index
+    void UpdateIterationDiagnostics();
+    bool MeasurementTouchesOscillatingStation(const UINT32& msrIndex) const;
+    std::string MeasurementStationNames(const UINT32& msrIndex) const;
+
     // ----------------------------------------------
     // Adjustment functions and variables for staged adjustment
 
diff --git a/dynadjust/dynadjust/dnaadjust/dnaadjust_json_printer.cpp b/dynadjust/dynadjust/dnaadjust/dnaadjust_json_printer.cpp
new file mode 100644
index 000000000..117bacf49
--- /dev/null
+++ b/dynadjust/dynadjust/dnaadjust/dnaadjust_json_printer.cpp
@@ -0,0 +1,615 @@
+//============================================================================
+// Name         : dnaadjust_json_printer.cpp
+// Author       : Dale Roberts <dale.o.roberts@gmail.com>
+// Copyright    : Copyright 2026 Geoscience Australia
+//
+//                Licensed under the Apache License, Version 2.0 (the "License");
+//                you may not use this file except in compliance with the License.
+//                You may obtain a copy of the License at
+//
+//                http://www.apache.org/licenses/LICENSE-2.0
+//
+//                Unless required by applicable law or agreed to in writing, software
+//                distributed under the License is distributed on an "AS IS" BASIS,
+//                WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//                See the License for the specific language governing permissions and
+//                limitations under the License.
+//
+// Description  : JSONL output implementation.  Builds nlohmann::json objects
+//                from the same in-memory data consumed by the text printer
+//                and emits one JSON object per line.  Key names mirror the
+//                DynaML / JSONL input schema so records round-trip through
+//                dnaimport.
+//============================================================================
+
+#include <cmath>
+#include <mutex>
+#include <string>
+
+#include <include/config/dnaversion.hpp>
+#include <include/functions/dnaiostreamfuncs.hpp>
+#include <include/functions/dnastrmanipfuncs.hpp>
+#include <include/functions/dnatemplatecalcfuncs.hpp>
+#include <include/functions/dnatemplatematrixfuncs.hpp>
+#include <include/measurement_types/dnameasurement.hpp>
+#include <include/parameters/dnadatum.hpp>
+#include <include/parameters/dnaellipsoid.hpp>
+#include <include/thirdparty/nlohmann/json.hpp>
+
+#include <dynadjust/dnaadjust/dnaadjust_json_printer.hpp>
+#include <dynadjust/dnaadjust/dnaadjust.hpp>
+
+namespace dynadjust {
+namespace networkadjust {
+
+namespace {
+
+using nlohmann::json;
+
+// Trim trailing space/\r/\n from a fixed-width station field. Fields are
+// right-padded with spaces on disk and null-terminated in memory, so the
+// std::string(const char*) conversion plus trimstr yields the clean name.
+std::string Trimmed(const char* buf) {
+  return trimstr<std::string>(std::string(buf));
+}
+
+json HeaderRecord(const CDnaDatum& datum, const char* report_kind) {
+  json hdr;
+  hdr["type"] = "Adjustment";
+  hdr["report"] = report_kind;
+  hdr["software"] = std::string("DynAdjust ") + __BINARY_VERSION__;
+  hdr["referenceframe"] = datum.GetName();
+  hdr["epoch"] = datum.GetEpoch_s();
+  // Output wrapper distinct from DnaXmlFormat (used by DynaML XML / JSONL
+  // input) so readers can tell an adjustment report apart from input data.
+  // The JSONL input parser recognises both wrappers as a header line.
+  return json{{"DnaAdjustmentReport", hdr}};
+}
+
+json StationIdentity(const it_vstn_t& stn_it) {
+  json s;
+  s["Name"] = Trimmed(stn_it->stationName);
+  s["Constraints"] = Trimmed(stn_it->stationConst);
+  // Round-trip StationCoord blocks on .xyz records carry Lat/Lon in
+  // DMS-packed form, so the type tag is always LLH for adjustment output.
+  s["Type"] = "LLH";
+  const std::string desc = Trimmed(stn_it->description);
+  if (!desc.empty())
+    s["Description"] = desc;
+  return s;
+}
+
+// Geographic representation of an adjusted Cartesian position, computed once
+// per station so OnAdjustedStation does not run CartToGeo twice.
+struct AdjustedPosition {
+  double x, y, z;
+  double lat, lon, height;  // lat/lon in radians, height in metres
+};
+
+AdjustedPosition PositionFromContext(
+    const matrix_2d* estimates, const UINT32& mat_idx,
+    const DynAdjustPrinter::AdjustedStationContext& ctx) {
+  // x/y/z read straight from the estimate matrix; lat/lon/h were already
+  // computed by PrintAdjStation and threaded through ctx, so CartToGeo
+  // does not need to run again.
+  AdjustedPosition p;
+  p.x = estimates->get(mat_idx, 0);
+  p.y = estimates->get(mat_idx + 1, 0);
+  p.z = estimates->get(mat_idx + 2, 0);
+  p.lat = ctx.lat;
+  p.lon = ctx.lon;
+  p.height = ctx.height;
+  return p;
+}
+
+// Lat and Lon come out of the adjustment as radians but are written in DynaML
+// XML output as DMS-packed decimal (31.483180 ≡ 31°48'31.80").  Emitting the
+// same encoding keeps the JSONL round-trip through SetXAxis/SetYAxis, whose
+// DmstoDeg() converts the decimal back to radians.
+json InitialCoords(const it_vstn_t& stn_it) {
+  json init;
+  init["Lat"] = RadtoDms(stn_it->initialLatitude);
+  init["Lon"] = RadtoDmsL(stn_it->initialLongitude);
+  init["Height"] = stn_it->initialHeight;
+  return init;
+}
+
+json AdjustedCoords(const AdjustedPosition& p) {
+  json adj;
+  adj["X"] = p.x;
+  adj["Y"] = p.y;
+  adj["Z"] = p.z;
+  adj["Lat"] = RadtoDms(p.lat);
+  adj["Lon"] = RadtoDmsL(p.lon);
+  adj["Height"] = p.height;
+  return adj;
+}
+
+// Round-trippable StationCoord block using the DynaML LLH convention so the
+// JSONL input parser can re-ingest an adjustment report as a station file.
+json StationCoordLLH(const it_vstn_t& stn_it, const AdjustedPosition& p) {
+  json c;
+  c["Name"] = Trimmed(stn_it->stationName);
+  c["XAxis"] = RadtoDms(p.lat);   // Lat, DMS-packed decimal
+  c["YAxis"] = RadtoDmsL(p.lon);  // Lon, DMS-packed decimal
+  c["Height"] = p.height;
+  return c;
+}
+
+json UncertaintyBlockFromCart(const it_vstn_t& stn_it,
+                              const matrix_2d& var_cart,
+                              const matrix_2d& var_local_with_geoid) {
+  // var_local already has geoid variance in (2,2) per AdjustedStationContext
+  // contract; ellipse + PU are derived from it directly so the numeric
+  // output matches the previous path byte-for-byte.
+  double semimajor = 0., semiminor = 0., azimuth = 0.;
+  ErrorEllipseParameters<double>(var_local_with_geoid,
+                                 semimajor, semiminor, azimuth);
+  double hz_pos_u = 0., vt_pos_u = 0.;
+  PositionalUncertainty<double>(semimajor, semiminor,
+      std::sqrt(var_local_with_geoid.get(2, 2)), hz_pos_u, vt_pos_u);
+
+  (void)stn_it;  // reserved for future fields; currently all values come
+                 // from ctx-derived matrices.
+
+  json u;
+  u["SE"] = std::sqrt(var_local_with_geoid.get(0, 0));
+  u["SN"] = std::sqrt(var_local_with_geoid.get(1, 1));
+  u["SU"] = std::sqrt(var_local_with_geoid.get(2, 2));
+  u["SemiMajor"] = semimajor;
+  u["SemiMinor"] = semiminor;
+  u["Orientation"] = azimuth;
+  u["HzPosU"] = hz_pos_u;
+  u["VtPosU"] = vt_pos_u;
+  u["VarianceLocal"] = {
+      {var_local_with_geoid.get(0, 0), var_local_with_geoid.get(0, 1),
+       var_local_with_geoid.get(0, 2)},
+      {var_local_with_geoid.get(1, 0), var_local_with_geoid.get(1, 1),
+       var_local_with_geoid.get(1, 2)},
+      {var_local_with_geoid.get(2, 0), var_local_with_geoid.get(2, 1),
+       var_local_with_geoid.get(2, 2)}};
+  u["VarianceCart"] = {
+      {var_cart.get(0, 0), var_cart.get(0, 1), var_cart.get(0, 2)},
+      {var_cart.get(1, 0), var_cart.get(1, 1), var_cart.get(1, 2)},
+      {var_cart.get(2, 0), var_cart.get(2, 1), var_cart.get(2, 2)}};
+  return u;
+}
+
+// Applies the geoid model variance to var_local[2,2] and re-derives the
+// ellipse + positional uncertainty terms.  Used by OnPositionalUncertainty
+// to keep .apu.jsonl numerics identical to the pre-refactor behaviour:
+// text .apu excludes geoid from ellipse/PU, but the JSON sibling has
+// always included it and downstream consumers depend on that.
+json UncertaintyBlockWithGeoid(const it_vstn_t& stn_it,
+                               const matrix_2d& var_cart,
+                               const matrix_2d& var_local_no_geoid) {
+  matrix_2d var_local = var_local_no_geoid;  // copy; keeps base var_local clean
+  var_local.elementadd(2, 2,
+      static_cast<double>(stn_it->geoidSepUnc) * stn_it->geoidSepUnc);
+  return UncertaintyBlockFromCart(stn_it, var_cart, var_local);
+}
+
+json CorrectionsBlockFromContext(
+    const DynAdjustPrinter::StationCorrectionContext& ctx) {
+  json c;
+  c["dE"] = ctx.cor_e;
+  c["dN"] = ctx.cor_n;
+  c["dUp"] = ctx.cor_up;
+  return c;
+}
+
+bool ScalarUsesAngularInputUnits(const char type) {
+  switch (type) {
+    case 'A':
+    case 'B':
+    case 'D':
+    case 'I':
+    case 'J':
+    case 'K':
+    case 'P':
+    case 'Q':
+    case 'V':
+    case 'Z':
+      return true;
+    default:
+      return false;
+  }
+}
+
+double ScalarInputValue(const it_vmsr_t& it_msr) {
+  return ScalarUsesAngularInputUnits(it_msr->measType)
+      ? RadtoDms(it_msr->term1)
+      : it_msr->term1;
+}
+
+double ScalarInputStdDev(const it_vmsr_t& it_msr) {
+  const double stddev = std::sqrt(it_msr->term2);
+  return ScalarUsesAngularInputUnits(it_msr->measType)
+      ? Seconds(stddev)
+      : stddev;
+}
+
+void AddObservationEpoch(json& m, const measurement_t& msr) {
+  const std::string observation_epoch = Trimmed(msr.observation_epoch);
+  if (!observation_epoch.empty())
+    m["EpochOfObservation"] = observation_epoch;
+}
+
+// Populate the scalar DnaMeasurement fields common to every type.  Used for
+// non-cluster types (A/B/C/E/H/I/J/K/L/M/P/Q/R/S/V/Z) where the bms iterator
+// points to a single record whose adjusted value is the scalar term1/measAdj.
+json ScalarMeasurement(const vstn_t& stations, const it_vmsr_t& it_msr) {
+  json m;
+  m["Type"] = std::string(1, it_msr->measType);
+  AddObservationEpoch(m, *it_msr);
+  if (it_msr->ignore)
+    m["Ignore"] = true;
+  m["First"] = Trimmed(stations.at(it_msr->station1).stationName);
+  if (it_msr->measurementStations >= 2)
+    m["Second"] = Trimmed(stations.at(it_msr->station2).stationName);
+  if (it_msr->measurementStations >= 3)
+    m["Third"] = Trimmed(stations.at(it_msr->station3).stationName);
+  m["Value"] = ScalarInputValue(it_msr);
+  m["StdDev"] = ScalarInputStdDev(it_msr);
+  m["Adjusted"] = it_msr->measAdj;
+  m["Correction"] = it_msr->measCorr;
+  m["AdjustedPrecision"] = it_msr->measAdjPrec;
+  m["ResidualPrecision"] = it_msr->residualPrec;
+  m["NStat"] = it_msr->NStat;
+  m["TStat"] = it_msr->TStat;
+  m["PelzerRel"] = it_msr->PelzerRel;
+  return m;
+}
+
+json DirectionEntry(const vstn_t& stations, const it_vmsr_t& it_dir) {
+  json direction;
+  direction["Target"] = Trimmed(stations.at(it_dir->station2).stationName);
+  direction["Value"] = ScalarInputValue(it_dir);
+  direction["StdDev"] = ScalarInputStdDev(it_dir);
+  if (it_dir->ignore)
+    direction["Ignore"] = true;
+
+  direction["Adjusted"] = it_dir->measAdj;
+  direction["Correction"] = it_dir->measCorr;
+  direction["AdjustedPrecision"] = it_dir->measAdjPrec;
+  direction["ResidualPrecision"] = it_dir->residualPrec;
+  direction["NStat"] = it_dir->NStat;
+  direction["TStat"] = it_dir->TStat;
+  direction["PelzerRel"] = it_dir->PelzerRel;
+  return direction;
+}
+
+json DirectionSetJson(const vstn_t& stations, const it_vmsr_t& it_set) {
+  json m = ScalarMeasurement(stations, it_set);
+  json directions = json::array();
+
+  const UINT32 direction_count =
+      it_set->vectorCount1 > 0 ? it_set->vectorCount1 - 1 : 0;
+  it_vmsr_t it_dir = it_set + 1;
+  for (UINT32 dir = 0; dir < direction_count; ++dir, ++it_dir)
+    directions.push_back(DirectionEntry(stations, it_dir));
+
+  m["Total"] = direction_count;
+  m["Directions"] = directions;
+  return m;
+}
+
+json ComponentTriple(const it_vmsr_t& it_x, double measurement_t::*field) {
+  const it_vmsr_t it_y = it_x + 1;
+  const it_vmsr_t it_z = it_x + 2;
+  return json{{"X", (*it_x).*field},
+              {"Y", (*it_y).*field},
+              {"Z", (*it_z).*field}};
+}
+
+json CovarianceComponent(const it_vmsr_t& it_cov_x) {
+  const it_vmsr_t it_cov_y = it_cov_x + 1;
+  const it_vmsr_t it_cov_z = it_cov_x + 2;
+
+  return json{{"m11", it_cov_x->term1},
+              {"m12", it_cov_x->term2},
+              {"m13", it_cov_x->term3},
+              {"m21", it_cov_y->term1},
+              {"m22", it_cov_y->term2},
+              {"m23", it_cov_y->term3},
+              {"m31", it_cov_z->term1},
+              {"m32", it_cov_z->term2},
+              {"m33", it_cov_z->term3}};
+}
+
+// Build one parser-compatible GPSBaseline or Clusterpoint entry from three
+// consecutive bms records (X/Y/Z).  Any covariance rows immediately following
+// the triplet are attached to the component using the input grammar.
+json ClusterComponent(const vstn_t& stations, const it_vmsr_t& it_x) {
+  const it_vmsr_t it_y = it_x + 1;
+  const it_vmsr_t it_z = it_x + 2;
+  json component;
+
+  component["First"] = Trimmed(stations.at(it_x->station1).stationName);
+  if (it_x->measType != 'Y')
+    component["Second"] = Trimmed(stations.at(it_x->station2).stationName);
+  component["X"] = it_x->term1;
+  component["Y"] = it_y->term1;
+  component["Z"] = it_z->term1;
+  component["SigmaXX"] = it_x->term2;
+  component["SigmaXY"] = it_y->term2;
+  component["SigmaXZ"] = it_z->term2;
+  component["SigmaYY"] = it_y->term3;
+  component["SigmaYZ"] = it_z->term3;
+  component["SigmaZZ"] = it_z->term4;
+
+  const UINT32 covariance_count = it_x->vectorCount2;
+  if (covariance_count > 0) {
+    json covariances = json::array();
+    it_vmsr_t it_cov = it_x + 3;
+    for (UINT32 cov = 0; cov < covariance_count; ++cov) {
+      covariances.push_back(CovarianceComponent(it_cov));
+      it_cov += 3;
+    }
+    component[it_x->measType == 'Y' ? "PointCovariance" : "GPSCovariance"] =
+        covariances;
+  }
+
+  return component;
+}
+
+json CollapseSingletonArray(const json& values) {
+  return values.size() == 1 ? values.at(0) : values;
+}
+
+// Build a full G/X/Y cluster record. The iterator must point to the first X
+// component of the cluster. Each element is encoded in the same array shape the
+// JSONL parser consumes, preserving Total and inter-component covariance rows.
+json ClusterMeasurement(const vstn_t& stations, const it_vmsr_t& it_cluster) {
+  json m;
+  m["Type"] = std::string(1, it_cluster->measType);
+  AddObservationEpoch(m, *it_cluster);
+  if (it_cluster->ignore)
+    m["Ignore"] = true;
+  m["First"] = Trimmed(stations.at(it_cluster->station1).stationName);
+  // Y-clusters store a single station per point; G/X baselines reference a
+  // Second station on the far end of the first baseline. Child entries carry
+  // their own station names, which is what the parser uses for X clusters.
+  if (it_cluster->measType != 'Y')
+    m["Second"] = Trimmed(stations.at(it_cluster->station2).stationName);
+
+  const UINT32 cluster_count = it_cluster->vectorCount1;
+  m["Total"] = cluster_count;
+
+  json components = json::array();
+  json adjusted = json::array();
+  json correction = json::array();
+  json adjusted_precision = json::array();
+  json nstat = json::array();
+  json tstat = json::array();
+  json pelzer = json::array();
+
+  it_vmsr_t it_x = it_cluster;
+  for (UINT32 cluster_msr = 0; cluster_msr < cluster_count; ++cluster_msr) {
+    components.push_back(ClusterComponent(stations, it_x));
+    adjusted.push_back(ComponentTriple(it_x, &measurement_t::measAdj));
+    correction.push_back(ComponentTriple(it_x, &measurement_t::measCorr));
+    adjusted_precision.push_back(
+        ComponentTriple(it_x, &measurement_t::measAdjPrec));
+    nstat.push_back(ComponentTriple(it_x, &measurement_t::NStat));
+    tstat.push_back(ComponentTriple(it_x, &measurement_t::TStat));
+    pelzer.push_back(ComponentTriple(it_x, &measurement_t::PelzerRel));
+
+    it_x += 3 + (it_x->vectorCount2 * 3);
+  }
+
+  if (it_cluster->measType == 'Y') {
+    const std::string coords = Trimmed(it_cluster->coordType);
+    if (!coords.empty())
+      m["Coords"] = coords;
+    m["Clusterpoint"] = components;
+  } else {
+    m["GPSBaseline"] = components;
+  }
+
+  m["Adjusted"] = CollapseSingletonArray(adjusted);
+  m["Correction"] = CollapseSingletonArray(correction);
+  m["AdjustedPrecision"] = CollapseSingletonArray(adjusted_precision);
+  m["NStat"] = CollapseSingletonArray(nstat);
+  m["TStat"] = CollapseSingletonArray(tstat);
+  m["PelzerRel"] = CollapseSingletonArray(pelzer);
+  return m;
+}
+
+}  // namespace
+
+DynAdjustJsonPrinter::DynAdjustJsonPrinter(dna_adjust& adjust_instance)
+    : DynAdjustPrinter(adjust_instance) {}
+
+DynAdjustJsonPrinter::~DynAdjustJsonPrinter() { CloseStreams(); }
+
+// Serialise the record outside the lock so concurrent hooks can dump in
+// parallel; only the stream write is serialised.
+static void WriteRecord(DynAdjustJsonPrinter::JsonStream& js,
+                        const json& record) {
+  std::string line = record.dump();
+  line.push_back('\n');
+  std::lock_guard<std::mutex> lock(js.mu);
+  if (js.stream.is_open())
+    js.stream.write(line.data(), static_cast<std::streamsize>(line.size()));
+}
+
+void DynAdjustJsonPrinter::OpenStreams() {
+  const auto& o = adjust_.projectSettings_.o;
+
+  // Route file_opener failure through SignalExceptionAdjustment so a JSONL
+  // open error surfaces via the same channel as text-report open errors.
+  // SignalExceptionAdjustment throws, so control never returns past the
+  // catch; any already-opened streams are torn down by ~DynAdjustJsonPrinter.
+  auto open_with_header = [this](JsonStream& js,
+                                 const std::string& path,
+                                 const char* report_kind) {
+    if (path.empty())
+      return;
+    try {
+      file_opener(js.stream, path);
+    } catch (const std::runtime_error& e) {
+      adjust_.SignalExceptionAdjustment(e.what(), 0);
+    }
+    WriteRecord(js, HeaderRecord(adjust_.datum_, report_kind));
+  };
+
+  open_with_header(adj_, o._adj_json_file, "adj");
+  open_with_header(xyz_, o._xyz_json_file, "xyz");
+  open_with_header(apu_, o._apu_json_file, "apu");
+  open_with_header(cor_, o._cor_json_file, "cor");
+  open_with_header(m2s_, o._m2s_json_file, "m2s");
+}
+
+void DynAdjustJsonPrinter::CloseStreams() {
+  auto close_if_open = [](JsonStream& js) {
+    if (js.stream.is_open())
+      js.stream.close();
+  };
+  close_if_open(adj_);
+  close_if_open(xyz_);
+  close_if_open(apu_);
+  close_if_open(cor_);
+  close_if_open(m2s_);
+}
+
+void DynAdjustJsonPrinter::OnAdjustedStation(ReportKind kind,
+    const it_vstn_t& stn_it, const matrix_2d* estimates,
+    const matrix_2d* variances, const UINT32& mat_idx,
+    const AdjustedStationContext& ctx) {
+  (void)variances;
+  const AdjustedPosition p = PositionFromContext(estimates, mat_idx, ctx);
+
+  json station = StationIdentity(stn_it);
+  // StationCoord carries the adjusted Lat/Lon/H in the same encoding used
+  // by the JSONL input parser, so the emitted record can be re-ingested as
+  // initial inputs for a follow-on adjustment.
+  station["StationCoord"] = StationCoordLLH(stn_it, p);
+  station["Initial"] = InitialCoords(stn_it);
+  station["Adjusted"] = AdjustedCoords(p);
+  station["Uncertainty"] =
+      UncertaintyBlockFromCart(stn_it, ctx.var_cart, ctx.var_local);
+
+  const json record{{"DnaStation", station}};
+
+  // Route based on the caller-declared kind. Works under staged-mode where
+  // the text sink is a stringstream rather than the real file stream.
+  switch (kind) {
+    case ReportKind::kAdj: WriteRecord(adj_, record); break;
+    case ReportKind::kXyz: WriteRecord(xyz_, record); break;
+  }
+}
+
+void DynAdjustJsonPrinter::OnAdjustedMeasurement(const it_vmsr_t& it_msr) {
+  // Cluster types (G single baseline, X baseline cluster, Y point cluster)
+  // contain one or more X/Y/Z triplets plus covariance rows. Emit one JSONL
+  // DnaMeasurement for the full cluster. Everything else is a scalar.
+  const bool is_cluster =
+      it_msr->measType == 'G' || it_msr->measType == 'X' ||
+      it_msr->measType == 'Y';
+  const json body =
+      is_cluster ? ClusterMeasurement(adjust_.bstBinaryRecords_, it_msr)
+                 : (it_msr->measType == 'D'
+                        ? DirectionSetJson(adjust_.bstBinaryRecords_, it_msr)
+                        : ScalarMeasurement(adjust_.bstBinaryRecords_,
+                                            it_msr));
+  WriteRecord(adj_, json{{"DnaMeasurement", body}});
+}
+
+void DynAdjustJsonPrinter::OnPositionalUncertainty(const it_vstn_t& stn_it,
+    const matrix_2d* variances, const UINT32& mat_idx,
+    const PositionalUncertaintyContext& ctx) {
+  (void)variances;
+  (void)mat_idx;
+  json station = StationIdentity(stn_it);
+  station["Uncertainty"] =
+      UncertaintyBlockWithGeoid(stn_it, ctx.var_cart, ctx.var_local);
+  WriteRecord(apu_, json{{"DnaStation", station}});
+}
+
+void DynAdjustJsonPrinter::OnStationCorrection(const UINT32& block,
+    const it_vstn_t& stn_it, const matrix_2d* estimates,
+    const UINT32& mat_idx, const StationCorrectionContext& ctx) {
+  (void)estimates;
+  (void)mat_idx;
+  // Corrections are computed per-block; drop the record if the block index
+  // is out of range rather than emitting a malformed DnaStation with no
+  // Corrections payload.
+  if (block >= adjust_.v_originalStations_.size())
+    return;
+
+  json station = StationIdentity(stn_it);
+  station["Initial"] = InitialCoords(stn_it);
+  station["Corrections"] = CorrectionsBlockFromContext(ctx);
+  WriteRecord(cor_, json{{"DnaStation", station}});
+}
+
+void DynAdjustJsonPrinter::OnM2SRecord(const it_vstn_t& stn_it,
+    MsrTally& tally) {
+  json station = StationIdentity(stn_it);
+
+  // Enumerate the 20 canonical MsrTally fields directly rather than going
+  // through FillMsrList + MeasurementCount's switch-per-character.
+  station["MsrCounts"] = json{
+      {"A", tally.A}, {"B", tally.B}, {"C", tally.C}, {"D", tally.D},
+      {"E", tally.E}, {"G", tally.G}, {"H", tally.H}, {"I", tally.I},
+      {"J", tally.J}, {"K", tally.K}, {"L", tally.L}, {"M", tally.M},
+      {"P", tally.P}, {"Q", tally.Q}, {"R", tally.R}, {"S", tally.S},
+      {"V", tally.V}, {"X", tally.X}, {"Y", tally.Y}, {"Z", tally.Z}};
+  // totalCount is populated by CreateMsrToStnTally before this hook fires,
+  // so the cached value is current.
+  station["TotalMeasurements"] = tally.totalCount;
+  WriteRecord(m2s_, json{{"DnaStation", station}});
+}
+
+void DynAdjustJsonPrinter::OnStatistics() {
+  json stats;
+  // When _adj_stat_iteration is enabled, PrintStatistics also fires after
+  // each iteration before the terminal call, so include the iteration
+  // number with each record; consumers can pick the largest for the final
+  // outcome and reconstruct the convergence history from the rest.
+  stats["iteration"] = adjust_.CurrentIteration();
+  stats["unknown_parameters"] = adjust_.unknownParams_;
+  stats["measurement_params"] = adjust_.measurementParams_;
+  stats["potential_outliers"] = adjust_.potentialOutlierCount_;
+  stats["dof"] = adjust_.degreesofFreedom_;
+  stats["chisq"] = adjust_.chiSquared_;
+  stats["sigma_zero"] = adjust_.sigmaZero_;
+  stats["global_pelzer"] = adjust_.globalPelzerReliability_;
+  stats["chisq_lower"] = adjust_.chiSquaredLowerLimit_;
+  stats["chisq_upper"] = adjust_.chiSquaredUpperLimit_;
+  stats["confidence_interval"] =
+      adjust_.projectSettings_.a.confidence_interval;
+
+  const char* result = "unknown";
+  if (adjust_.degreesofFreedom_ < 1)
+    result = "no_redundancy";
+  else {
+    switch (adjust_.passFail_) {
+      case test_stat_pass:
+        result = "passed";
+        break;
+      case test_stat_warning:
+        result = "warning";
+        break;
+      case test_stat_fail:
+        result = "failed";
+        break;
+    }
+  }
+  stats["chisq_test"] = result;
+  WriteRecord(adj_, json{{"DnaStatistics", stats}});
+
+  // Flush every open stream so a subsequent crash or signal does not lose
+  // JSONL lines buffered by the C++ stream layer.  We flush on every
+  // statistics fire (terminal + per-iteration when enabled) — flush is
+  // cheap relative to the adjustment iteration that just completed.
+  for (JsonStream* js : {&adj_, &xyz_, &apu_, &cor_, &m2s_}) {
+    std::lock_guard<std::mutex> lock(js->mu);
+    if (js->stream.is_open())
+      js->stream.flush();
+  }
+}
+
+}  // namespace networkadjust
+}  // namespace dynadjust
diff --git a/dynadjust/dynadjust/dnaadjust/dnaadjust_json_printer.hpp b/dynadjust/dynadjust/dnaadjust/dnaadjust_json_printer.hpp
new file mode 100644
index 000000000..13342371a
--- /dev/null
+++ b/dynadjust/dynadjust/dnaadjust/dnaadjust_json_printer.hpp
@@ -0,0 +1,108 @@
+//============================================================================
+// Name         : dnaadjust_json_printer.hpp
+// Author       : Dale Roberts <dale.o.roberts@gmail.com>
+// Copyright    : Copyright 2026 Geoscience Australia
+//
+//                Licensed under the Apache License, Version 2.0 (the "License");
+//                you may not use this file except in compliance with the License.
+//                You may obtain a copy of the License at
+//
+//                http://www.apache.org/licenses/LICENSE-2.0
+//
+//                Unless required by applicable law or agreed to in writing, software
+//                distributed under the License is distributed on an "AS IS" BASIS,
+//                WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//                See the License for the specific language governing permissions and
+//                limitations under the License.
+//
+// Description  : JSONL side-channel printer emitted alongside the default
+//                DynAdjust text reports.  Subclass of DynAdjustPrinter that
+//                overrides the virtual hooks to write one JSON object per
+//                line for each adjusted record, using the same key names as
+//                the JSONL import parser so output can round-trip.
+//============================================================================
+
+#ifndef DNAADJUST_JSON_PRINTER_H_
+#define DNAADJUST_JSON_PRINTER_H_
+
+#if defined(_MSC_VER)
+#if defined(LIST_INCLUDES_ON_BUILD)
+#pragma message("  " __FILE__)
+#endif
+#endif
+
+#include <fstream>
+#include <mutex>
+
+#include <include/config/dnaexports.hpp>
+
+#include <dynadjust/dnaadjust/dnaadjust_printer.hpp>
+
+namespace dynadjust {
+namespace networkadjust {
+
+class DNAADJUST_API DynAdjustJsonPrinter : public DynAdjustPrinter {
+ public:
+  explicit DynAdjustJsonPrinter(dna_adjust& adjust_instance);
+  ~DynAdjustJsonPrinter() override;
+
+  // Open each JSONL output stream whose text sibling is enabled for this
+  // run and write the per-file header line.  Must be called after the
+  // printer is constructed but before any Print* method is invoked.
+  void OpenStreams();
+
+  // Flush and close any open JSONL output streams.  Called from the
+  // destructor so callers do not need to invoke it explicitly.
+  void CloseStreams();
+
+  // Pairs an output stream with its serialising mutex.  One instance per
+  // report file.  Public so helpers in the .cpp translation unit (which
+  // is where nlohmann::json is in scope) can hold references — the
+  // members themselves stay private.  Concurrent adjustment threads
+  // writing to different sibling files don't serialise on a single lock,
+  // and the critical section is only the stream write (the JSON dump
+  // happens outside).  Non-copyable and non-movable because std::mutex is.
+  struct JsonStream {
+    std::ofstream stream;
+    std::mutex mu;
+
+    JsonStream() = default;
+    JsonStream(const JsonStream&) = delete;
+    JsonStream& operator=(const JsonStream&) = delete;
+    JsonStream(JsonStream&&) = delete;
+    JsonStream& operator=(JsonStream&&) = delete;
+  };
+
+ protected:
+  void OnAdjustedStation(ReportKind kind,
+                         const it_vstn_t& stn_it,
+                         const matrix_2d* estimates,
+                         const matrix_2d* variances,
+                         const UINT32& mat_idx,
+                         const AdjustedStationContext& ctx) override;
+  void OnAdjustedMeasurement(const it_vmsr_t& it_msr) override;
+  void OnPositionalUncertainty(const it_vstn_t& stn_it,
+                               const matrix_2d* variances,
+                               const UINT32& mat_idx,
+                               const PositionalUncertaintyContext& ctx) override;
+  void OnStationCorrection(const UINT32& block,
+                           const it_vstn_t& stn_it,
+                           const matrix_2d* estimates,
+                           const UINT32& mat_idx,
+                           const StationCorrectionContext& ctx) override;
+  void OnM2SRecord(const it_vstn_t& stn_it,
+                   MsrTally& stn_msr_tally) override;
+  void OnStatistics() override;
+
+ private:
+  JsonStream adj_;
+  JsonStream xyz_;
+  JsonStream apu_;
+  JsonStream cor_;
+  JsonStream m2s_;
+};
+
+}  // namespace networkadjust
+}  // namespace dynadjust
+
+#endif  // DNAADJUST_JSON_PRINTER_H_
diff --git a/dynadjust/dynadjust/dnaadjust/dnaadjust_printer.cpp b/dynadjust/dynadjust/dnaadjust/dnaadjust_printer.cpp
index 0d40a6c4f..263c2fe24 100644
--- a/dynadjust/dynadjust/dnaadjust/dnaadjust_printer.cpp
+++ b/dynadjust/dynadjust/dnaadjust/dnaadjust_printer.cpp
@@ -80,22 +80,13 @@ void DynAdjustPrinter::PrintIteration(const UINT32& iteration) {
 }
 
 void DynAdjustPrinter::PrintAdjustmentTime(cpu_timer& time, int timer_type) {
-    // calculate and print total time
-    auto elapsed = time.elapsed();
-    double seconds = elapsed.wall.count() / 1.0e9;
-    
-    std::stringstream ss;
-    if (seconds >= 1.0) {
-        ss << std::fixed << std::setprecision(3) << seconds << "s";
-    } else {
-        ss << std::fixed << std::setprecision(3) << (seconds * 1000.0) << "ms";
-    }
+    std::string formatted = FormatElapsedTime(time.elapsed().wall.count() / 1.0e9);
 
     if (timer_type == 0) // iteration_time equivalent
-        adjust_.adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Elapsed time" << ss.str() << std::endl;
+        adjust_.adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Elapsed time" << formatted << std::endl;
     else
     {
-        adjust_.adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Total time" << ss.str() << std::endl << std::endl;
+        adjust_.adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Total time" << formatted << std::endl << std::endl;
     }
 }
 
@@ -547,18 +538,18 @@ void DynAdjustPrinter::PrintAdjustedNetworkStations() {
 
     switch (adjust_.projectSettings_.a.adjust_mode) {
     case SimultaneousMode:
-        PrintAdjStations(adjust_.adj_file, 0, &adjust_.v_estimatedStations_.at(0), &adjust_.v_rigorousVariances_.at(0), false, true, true, printHeader, true);
-        PrintAdjStations(adjust_.xyz_file, 0, &adjust_.v_estimatedStations_.at(0), &adjust_.v_rigorousVariances_.at(0), false, false, false, printHeader, false);
+        PrintAdjStations(ReportKind::kAdj, adjust_.adj_file, 0, &adjust_.v_estimatedStations_.at(0), &adjust_.v_rigorousVariances_.at(0), false, true, true, printHeader, true);
+        PrintAdjStations(ReportKind::kXyz, adjust_.xyz_file, 0, &adjust_.v_estimatedStations_.at(0), &adjust_.v_rigorousVariances_.at(0), false, false, false, printHeader, false);
         break;
     case PhasedMode:
     case Phased_Block_1Mode:
         // Output phased blocks as a single block?
         if (!adjust_.projectSettings_.o._output_stn_blocks) {
-            PrintAdjStationsUniqueList(adjust_.adj_file,
+            PrintAdjStationsUniqueList(ReportKind::kAdj, adjust_.adj_file,
                 &adjust_.v_rigorousStations_,
                 &adjust_.v_rigorousVariances_,
                 true, true, true);
-            PrintAdjStationsUniqueList(adjust_.xyz_file,
+            PrintAdjStationsUniqueList(ReportKind::kXyz, adjust_.xyz_file,
                 &adjust_.v_rigorousStations_,
                 &adjust_.v_rigorousVariances_,
                 true, true, false);
@@ -573,8 +564,8 @@ void DynAdjustPrinter::PrintAdjustedNetworkStations() {
                         adjust_.DeserialiseBlockFromMappedFile(block, 1, sf_original_stns);
 
                     // Print using original detailed function for staging compatibility
-                    PrintAdjStations(adjust_.adj_file, block, &adjust_.v_rigorousStations_.at(block), &adjust_.v_rigorousVariances_.at(block), true, true, true, printHeader, true);
-                    PrintAdjStations(adjust_.xyz_file, block, &adjust_.v_rigorousStations_.at(block), &adjust_.v_rigorousVariances_.at(block), true, false, false, printHeader, false);
+                    PrintAdjStations(ReportKind::kAdj, adjust_.adj_file, block, &adjust_.v_rigorousStations_.at(block), &adjust_.v_rigorousVariances_.at(block), true, true, true, printHeader, true);
+                    PrintAdjStations(ReportKind::kXyz, adjust_.xyz_file, block, &adjust_.v_rigorousStations_.at(block), &adjust_.v_rigorousVariances_.at(block), true, false, false, printHeader, false);
                     printHeader = false;
 
                     // Release block from memory
@@ -589,8 +580,8 @@ void DynAdjustPrinter::PrintAdjustedNetworkStations() {
             } else {
                 // Print stations for each block without staging
                 for (UINT32 block = 0; block < adjust_.blockCount_; ++block) {
-                    PrintAdjStations(adjust_.adj_file, block, &adjust_.v_estimatedStations_.at(block), &adjust_.v_rigorousVariances_.at(block), true, true, true, printHeader, true);
-                    PrintAdjStations(adjust_.xyz_file, block, &adjust_.v_estimatedStations_.at(block), &adjust_.v_rigorousVariances_.at(block), true, false, false, printHeader, false);
+                    PrintAdjStations(ReportKind::kAdj, adjust_.adj_file, block, &adjust_.v_estimatedStations_.at(block), &adjust_.v_rigorousVariances_.at(block), true, true, true, printHeader, true);
+                    PrintAdjStations(ReportKind::kXyz, adjust_.xyz_file, block, &adjust_.v_estimatedStations_.at(block), &adjust_.v_rigorousVariances_.at(block), true, false, false, printHeader, false);
                     printHeader = false;
                     
                     // Exit if block-1 mode
@@ -722,6 +713,8 @@ void DynAdjustPrinter::PrintStatistics(bool printPelzer) {
         ss << " ***";
     }
     adjust_.adj_file << std::setw(PASS_FAIL) << std::right << ss.str() << std::endl << std::endl;
+
+    OnStatistics();
 }
 
 void DynAdjustPrinter::PrintMeasurementsToStation() {
@@ -776,8 +769,11 @@ void DynAdjustPrinter::PrintMeasurementsToStation() {
     }
 
     // Print measurements to each station and the total count for each station
-    for (_it_stn=vStationList.begin(); _it_stn != vStationList.end(); ++_it_stn)
+    for (_it_stn=vStationList.begin(); _it_stn != vStationList.end(); ++_it_stn) {
         adjust_.v_stnmsrTally_.at(*_it_stn).coutSummaryMsrToStn(adjust_.adj_file, adjust_.bstBinaryRecords_.at(*_it_stn).stationName);
+        it_vstn_t stn_it = adjust_.bstBinaryRecords_.begin() + *_it_stn;
+        OnM2SRecord(stn_it, adjust_.v_stnmsrTally_.at(*_it_stn));
+    }
     
     // Print "the bottom line"
     MsrToStnSummaryHeaderLine(adjust_.adj_file);
@@ -871,9 +867,10 @@ void DynAdjustPrinter::PrintAdjMeasurements_A(it_vmsr_t& _it_msr) {
     adjust_.adj_file << std::left << std::setw(STATION) << adjust_.bstBinaryRecords_.at(_it_msr->station1).stationName;
     adjust_.adj_file << std::left << std::setw(STATION) << adjust_.bstBinaryRecords_.at(_it_msr->station2).stationName;
     adjust_.adj_file << std::left << std::setw(STATION) << adjust_.bstBinaryRecords_.at(_it_msr->station3).stationName;
-    // Print angular measurement, taking care of user requirements for 
+    // Print angular measurement, taking care of user requirements for
     // type, format and precision
     PrintAdjMeasurementsAngular(' ', _it_msr);
+    OnAdjustedMeasurement(_it_msr);
 }
 
 void DynAdjustPrinter::PrintAdjMeasurements_BKVZ(it_vmsr_t& _it_msr) {
@@ -881,9 +878,10 @@ void DynAdjustPrinter::PrintAdjMeasurements_BKVZ(it_vmsr_t& _it_msr) {
     adjust_.adj_file << std::left << std::setw(STATION) << adjust_.bstBinaryRecords_.at(_it_msr->station1).stationName;
     adjust_.adj_file << std::left << std::setw(STATION) << adjust_.bstBinaryRecords_.at(_it_msr->station2).stationName;
     adjust_.adj_file << std::left << std::setw(STATION) << " ";
-    // Print angular measurement, taking care of user requirements for 
+    // Print angular measurement, taking care of user requirements for
     // type, format and precision
     PrintAdjMeasurementsAngular(' ', _it_msr);
+    OnAdjustedMeasurement(_it_msr);
 }
 
 void DynAdjustPrinter::PrintAdjMeasurements_CELMS(it_vmsr_t& _it_msr) {
@@ -892,6 +890,7 @@ void DynAdjustPrinter::PrintAdjMeasurements_CELMS(it_vmsr_t& _it_msr) {
     adjust_.adj_file << std::left << std::setw(STATION) << adjust_.bstBinaryRecords_.at(_it_msr->station2).stationName;
     adjust_.adj_file << std::left << std::setw(STATION) << " ";
     PrintAdjMeasurementsLinear(' ', _it_msr);
+    OnAdjustedMeasurement(_it_msr);
 }
 
 void DynAdjustPrinter::PrintAdjMeasurements_HR(it_vmsr_t& _it_msr) {
@@ -901,6 +900,7 @@ void DynAdjustPrinter::PrintAdjMeasurements_HR(it_vmsr_t& _it_msr) {
     adjust_.adj_file << std::left << std::setw(STATION) << " ";
 
     PrintAdjMeasurementsLinear(' ', _it_msr);
+    OnAdjustedMeasurement(_it_msr);
 }
 
 void DynAdjustPrinter::PrintAdjMeasurements_IJPQ(it_vmsr_t& _it_msr) {
@@ -908,12 +908,15 @@ void DynAdjustPrinter::PrintAdjMeasurements_IJPQ(it_vmsr_t& _it_msr) {
     adjust_.adj_file << std::left << std::setw(STATION) << adjust_.bstBinaryRecords_.at(_it_msr->station1).stationName;
     adjust_.adj_file << std::left << std::setw(STATION) << " ";
     adjust_.adj_file << std::left << std::setw(STATION) << " ";
-    // Print angular measurement, taking care of user requirements for 
+    // Print angular measurement, taking care of user requirements for
     // type, format and precision
     PrintAdjMeasurementsAngular(' ', _it_msr);
+    OnAdjustedMeasurement(_it_msr);
 }
 
 void DynAdjustPrinter::PrintAdjMeasurements_D(it_vmsr_t& _it_msr) {
+    const it_vmsr_t direction_set_start = _it_msr;
+
     // normal format
     adjust_.adj_file << std::left << std::setw(STATION) << adjust_.bstBinaryRecords_.at(_it_msr->station1).stationName;
     adjust_.adj_file << std::left << std::setw(STATION) << adjust_.bstBinaryRecords_.at(_it_msr->station2).stationName;
@@ -959,14 +962,16 @@ void DynAdjustPrinter::PrintAdjMeasurements_D(it_vmsr_t& _it_msr) {
         adjust_.adj_file << std::left << std::setw(PAD2) << " ";                        // measurement type
         adjust_.adj_file << std::left << std::setw(STATION) << " ";                    // station1    (Instrument)
         adjust_.adj_file << std::left << std::setw(STATION) << " ";                    // station2 (RO)
-        adjust_.adj_file << std::left << std::setw(STATION) << 
+        adjust_.adj_file << std::left << std::setw(STATION) <<
             adjust_.bstBinaryRecords_.at(_it_msr->station2).stationName;    // target
 
-        // Print angular measurement, taking care of user requirements for 
-        // type, format and precision    
+        // Print angular measurement, taking care of user requirements for
+        // type, format and precision
         PrintAdjMeasurementsAngular(' ', _it_msr);
         _it_msr++;
     }
+
+    OnAdjustedMeasurement(direction_set_start);
 }
 
 void DynAdjustPrinter::PrintCompMeasurements_YLLH(it_vmsr_t& _it_msr, UINT32& design_row) {
@@ -1426,7 +1431,7 @@ void DynAdjustPrinter::PrintUniqueStationsList(std::ostream& os,
     os << "Unique stations list printed using existing detailed implementation." << std::endl;
 }
 
-void DynAdjustPrinter::PrintAdjStationsUniqueList(std::ostream& os,
+void DynAdjustPrinter::PrintAdjStationsUniqueList(ReportKind kind, std::ostream& os,
                                                            const v_mat_2d* stationEstimates, v_mat_2d* stationVariances,
                                                            bool recomputeGeographicCoords, bool updateGeographicCoords,
                                                            bool reapplyTypeBUncertainties) {
@@ -1476,9 +1481,9 @@ void DynAdjustPrinter::PrintAdjStationsUniqueList(std::ostream& os,
         mat_index = _it_bsmu->first.second * 3;
 
         // Use the refactored PrintAdjStation through the main class
-        PrintAdjStation(*outstream, 
-                               block, stn, mat_index, 
-                               &stationEstimates->at(block), &stationVariances->at(block), 
+        PrintAdjStation(kind, *outstream,
+                               block, stn, mat_index,
+                               &stationEstimates->at(block), &stationVariances->at(block),
                                recomputeGeographicCoords, updateGeographicCoords,
                                reapplyTypeBUncertainties);
 
@@ -1570,7 +1575,7 @@ void DynAdjustPrinter::PrintStationAdjustmentResults(std::ostream& os, const UIN
     
     // Delegate to existing implementation for complex coordinate transformations
     // and uncertainty calculations while using our new coordinate formatters
-    PrintAdjStation(os, block, stn, mat_idx, estimates, variances, true, false, true);
+    PrintAdjStation(ReportKind::kAdj, os, block, stn, mat_idx, estimates, variances, true, false, true);
 }
 
 // Enhanced coordinate transformation utilities for PrintAdjStation refactoring
@@ -2014,14 +2019,16 @@ void DynAdjustPrinter::PrintCompMeasurements(const UINT32& block, const std::str
     adjust_.adj_file << std::endl << std::endl;
 }
 
-// Helper function that consolidates measurement printing logic
+// Helper function that consolidates measurement printing logic.  JSON
+// hooks fire from the leaf PrintAdjMeasurements_* methods (not here), so
+// cluster records emit one JSONL record per component.
 void DynAdjustPrinter::PrintMeasurementRecords(const v_uint32_u32u32_pair& msr_block, bool adjustedMeasurements) {
     it_vmsr_t _it_msr;
     UINT32 clusterID(MAX_UINT32_VALUE);
 
     for (auto _it_block_msr = msr_block.begin(); _it_block_msr != msr_block.end(); ++_it_block_msr) {
         _it_msr = adjust_.bmsBinaryRecords_.begin() + (_it_block_msr->first);
-        
+
         // Skip non-measurement elements (Y, Z, covariance components)
         if (_it_msr->measStart != xMeas)
             continue;
@@ -2632,22 +2639,27 @@ void DynAdjustPrinter::PrintAdjMeasurements_YLLH(it_vmsr_t& _it_msr)
         // Print height
         _it_y_msr++;
         switch (_it_msr->station3)
-        { 
-        case LLh_type_i: 
+        {
+        case LLh_type_i:
             PrintAdjMeasurementsLinear('h', _it_y_msr);
             break;
         case LLH_type_i:
         default:
             PrintAdjMeasurementsLinear('H', _it_y_msr);
             break;
-        }        
+        }
 
         // skip covariances until next point
         _it_y_msr += covariance_count * 3;
-        
+
         if (covariance_count > 0)
             _it_y_msr++;
     }
+
+    // Emit the JSONL side-channel once for the whole Y cluster. The temporary
+    // y_msr vector above is only for text output; JSONL preserves the input
+    // grammar by walking the original binary cluster, including covariances.
+    OnAdjustedMeasurement(_it_msr_begin);
 }
 
 void DynAdjustPrinter::PrintPositionalUncertainty()
@@ -3401,14 +3413,15 @@ void DynAdjustPrinter::PrintBlockStations(std::ostream& os, const UINT32& block,
     
     UINT32 mat_idx, stn;
 
-    // Print stations according to the user-defined sort order
+    // PrintBlockStations is only called against adj_file, so route the
+    // JSON hook to the .adj sibling.
     for (UINT32 i(0); i<adjust_.v_blockStationsMap_.at(block).size(); ++i)
     {
         stn = v_blockStations.at(i);
         mat_idx = adjust_.v_blockStationsMap_.at(block)[stn] * 3;
 
-        PrintAdjStation(os, block, stn, mat_idx,
-            stationEstimates, stationVariances, 
+        PrintAdjStation(ReportKind::kAdj, os, block, stn, mat_idx,
+            stationEstimates, stationVariances,
             recomputeGeographicCoords, updateGeographicCoords,
             reapplyTypeBUncertainties);
     }
@@ -3772,9 +3785,9 @@ void DynAdjustPrinter::PrintStationsUniqueList(std::ostream& os,
         stn = _it_bsmu->first.first;
         mat_index = _it_bsmu->first.second * 3;
 
-        PrintAdjStation(*outstream,
+        PrintAdjStation(ReportKind::kAdj, *outstream,
             block, stn, mat_index,
-                &estimates->at(block), &stationVariances->at(block), 
+                &estimates->at(block), &stationVariances->at(block),
                 recomputeGeographicCoords, updateGeographicCoords,
                 reapplyTypeBUncertainties);
 
@@ -3901,7 +3914,7 @@ bool DynAdjustPrinter::IgnoredMeasurementContainsInvalidStation(pit_vmsr_t _it_m
     return true;
 }
 
-void DynAdjustPrinter::PrintAdjStation(std::ostream& os, 
+void DynAdjustPrinter::PrintAdjStation(ReportKind kind, std::ostream& os,
     const UINT32& block, const UINT32& stn, const UINT32& mat_idx,
     const matrix_2d* stationEstimates, matrix_2d* stationVariances,
     bool recomputeGeographicCoords, bool updateGeographicCoords,
@@ -4050,6 +4063,10 @@ void DynAdjustPrinter::PrintAdjStation(std::ostream& os,
     // description
     os << std::setw(PAD2) << " " << std::left << stn_it->description;
     os << std::endl;
+
+    AdjustedStationContext ctx{
+        estLatitude, estLongitude, estHeight, var_cart, var_local};
+    OnAdjustedStation(kind, stn_it, stationEstimates, stationVariances, mat_idx, ctx);
 }
 
 void DynAdjustPrinter::PrintAdjMeasurements_GXY(it_vmsr_t& _it_msr, const uint32_uint32_pair& b_pam)
@@ -4066,6 +4083,7 @@ void DynAdjustPrinter::PrintAdjMeasurements_GXY(it_vmsr_t& _it_msr, const uint32
         }
     }
 
+    const it_vmsr_t cluster_start = _it_msr;
     UINT32 cluster_msr, cluster_count(_it_msr->vectorCount1), covariance_count;
     bool nextElement(false);
 
@@ -4080,7 +4098,7 @@ void DynAdjustPrinter::PrintAdjMeasurements_GXY(it_vmsr_t& _it_msr, const uint32
 
         // first station
         adjust_.adj_file << std::left << std::setw(STATION) << adjust_.bstBinaryRecords_.at(_it_msr->station1).stationName;
-    
+
         // Print second station?
         switch (_it_msr->measType)
         {
@@ -4094,7 +4112,7 @@ void DynAdjustPrinter::PrintAdjMeasurements_GXY(it_vmsr_t& _it_msr, const uint32
 
         // third station
         adjust_.adj_file << std::left << std::setw(STATION) << " ";
-        
+
         // Print adjusted GNSS baseline measurements in alternate units?
         if (adjust_.projectSettings_.o._adj_gnss_units != XYZ_adj_gnss_ui &&
             _it_msr->measType != 'Y')
@@ -4103,22 +4121,26 @@ void DynAdjustPrinter::PrintAdjMeasurements_GXY(it_vmsr_t& _it_msr, const uint32
         {
             // Print X
             PrintAdjMeasurementsLinear('X', _it_msr);
-    
+
             // Print Y
-            _it_msr++;	
+            _it_msr++;
             PrintAdjMeasurementsLinear('Y', _it_msr);
 
             // Print Z
-            _it_msr++;	
+            _it_msr++;
             PrintAdjMeasurementsLinear('Z', _it_msr);
         }
 
         // skip covariances until next baseline
         _it_msr += covariance_count * 3;
-        
+
         if (covariance_count > 0)
             _it_msr++;
     }
+
+    // Emit the JSONL side-channel once for the whole GNSS cluster, not once per
+    // baseline. This preserves Total and all cross-covariance records.
+    OnAdjustedMeasurement(cluster_start);
 }
 
 void DynAdjustPrinter::PrintCorStation(std::ostream& os, 
@@ -4194,15 +4216,19 @@ void DynAdjustPrinter::PrintCorStation(std::ostream& os,
         std::setw(MSR) << std::setprecision(adjust_.PRECISION_MTR_STN) << std::fixed << std::right << horiz_distance;
 
     if (adjust_.isAdjustmentQuestionable_)
-        os << 
-            StringFromTW(local_12e, HEIGHT, adjust_.PRECISION_MTR_STN) << 
-            StringFromTW(local_12n, HEIGHT, adjust_.PRECISION_MTR_STN) << 
+        os <<
+            StringFromTW(local_12e, HEIGHT, adjust_.PRECISION_MTR_STN) <<
+            StringFromTW(local_12n, HEIGHT, adjust_.PRECISION_MTR_STN) <<
             StringFromTW(local_12up, HEIGHT, adjust_.PRECISION_MTR_STN) << std::endl;
     else
-        os << 
-            std::setw(HEIGHT) << std::setprecision(adjust_.PRECISION_MTR_STN) << std::fixed << std::right << local_12e << 
-            std::setw(HEIGHT) << std::setprecision(adjust_.PRECISION_MTR_STN) << std::fixed << std::right << local_12n << 
+        os <<
+            std::setw(HEIGHT) << std::setprecision(adjust_.PRECISION_MTR_STN) << std::fixed << std::right << local_12e <<
+            std::setw(HEIGHT) << std::setprecision(adjust_.PRECISION_MTR_STN) << std::fixed << std::right << local_12n <<
             std::setw(HEIGHT) << std::setprecision(adjust_.PRECISION_MTR_STN) << std::fixed << std::right << local_12up << std::endl;
+
+    it_vstn_t stn_it = adjust_.bstBinaryRecords_.begin() + stn;
+    StationCorrectionContext ctx{local_12e, local_12n, local_12up};
+    OnStationCorrection(block, stn_it, stationEstimates, mat_index, ctx);
 }
 
 void DynAdjustPrinter::PrintCorStations(std::ostream& cor_file, const UINT32& block)
@@ -4399,7 +4425,20 @@ void DynAdjustPrinter::PrintPosUncertainty(std::ostream& os, const UINT32& block
     else
         os <<
             std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(2, 2) << std::endl;		// up
-    
+
+    {
+        it_vstn_t stn_it = adjust_.bstBinaryRecords_.begin() + stn;
+        PositionalUncertaintyContext ctx{
+            stn_it->currentLatitude,
+            stn_it->currentLongitude,
+            stn_it->currentHeight,
+            variances_cart,
+            variances_local,
+            semimajor, semiminor, azimuth,
+            hzPosU, vtPosU};
+        OnPositionalUncertainty(stn_it, stationVariances, mat_idx, ctx);
+    }
+
     if (!adjust_.projectSettings_.o._output_pu_covariances)
         return;
 
@@ -4511,7 +4550,10 @@ void DynAdjustPrinter::UpdateGNSSNstatsForAlternateUnits(const v_uint32_u32u32_p
             covariance_count = _it_msr->vectorCount2;
 
             // Load precision of adjusted measurements for staged adjustments
-            if (adjust_.projectSettings_.a.stage)
+            const bool loadedPrecAdjMsrs =
+                adjust_.projectSettings_.a.stage &&
+                adjust_.v_precAdjMsrsFull_.at(b_pam.first).getbuffer() == nullptr;
+            if (loadedPrecAdjMsrs)
                 adjust_.DeserialiseBlockFromMappedFile(b_pam.first, 1, sf_prec_adj_msrs);
 
             double lower_mtx_buffer[6];
@@ -4521,7 +4563,7 @@ void DynAdjustPrinter::UpdateGNSSNstatsForAlternateUnits(const v_uint32_u32u32_p
             matrix_2d var_adj_cart(3, 3, lower_mtx_buffer, 6, mtx_lower);
             var_adj_cart.fillupper();
 
-            if (adjust_.projectSettings_.a.stage)
+            if (loadedPrecAdjMsrs)
                 adjust_.UnloadBlock(b_pam.first, 1, sf_prec_adj_msrs);
 
             // Get X component
@@ -4683,7 +4725,10 @@ void DynAdjustPrinter::PrintAdjGNSSAlternateUnits(it_vmsr_t& _it_msr, const uint
     matrix_2d var_adj_local(3, 3), var_adj_polar(3, 3);
 
     // For staged adjustments, load precision of adjusted measurements
-    if (adjust_.projectSettings_.a.stage)
+    const bool loadedPrecAdjMsrs =
+        adjust_.projectSettings_.a.stage &&
+        adjust_.v_precAdjMsrsFull_.at(b_pam.first).getbuffer() == nullptr;
+    if (loadedPrecAdjMsrs)
         adjust_.DeserialiseBlockFromMappedFile(b_pam.first, 1, sf_prec_adj_msrs);
 
     // get precision of adjusted measurements
@@ -4692,7 +4737,7 @@ void DynAdjustPrinter::PrintAdjGNSSAlternateUnits(it_vmsr_t& _it_msr, const uint
     matrix_2d var_adj_cart(3, 3, lower_mtx_buffer, 6, mtx_lower);
     var_adj_cart.fillupper();
 
-    if (adjust_.projectSettings_.a.stage)
+    if (loadedPrecAdjMsrs)
         // For staged adjustments, unload precision of adjusted measurements
         adjust_.UnloadBlock(b_pam.first, 1, sf_prec_adj_msrs);
     
@@ -5212,7 +5257,7 @@ void DynAdjustPrinter::PrintCorStationsUniqueList(std::ostream& cor_file)
     );
 }
 
-void DynAdjustPrinter::PrintAdjStations(std::ostream& os, const UINT32& block,
+void DynAdjustPrinter::PrintAdjStations(ReportKind kind, std::ostream& os, const UINT32& block,
                       const matrix_2d* stationEstimates,
                       matrix_2d* stationVariances, bool printBlockID,
                       bool recomputeGeographicCoords,
@@ -5275,13 +5320,13 @@ void DynAdjustPrinter::PrintAdjStations(std::ostream& os, const UINT32& block,
     {
         stn = v_blockStations.at(i);
         mat_idx = adjust_.v_blockStationsMap_.at(block)[stn] * 3;
-        PrintAdjStation(os, block, stn, mat_idx,
-            stationEstimates, stationVariances, 
+        PrintAdjStation(kind, os, block, stn, mat_idx,
+            stationEstimates, stationVariances,
             recomputeGeographicCoords, updateGeographicCoords,
             reapplyTypeBUncertainties);
     }
     os << std::endl;
-    
+
     // return sort order to alpha-numeric
     if (adjust_.projectSettings_.o._sort_stn_file_order)
         adjust_.SortStationsbyID(v_blockStations);
diff --git a/dynadjust/dynadjust/dnaadjust/dnaadjust_printer.hpp b/dynadjust/dynadjust/dnaadjust/dnaadjust_printer.hpp
index 5bfd658aa..d6f536325 100644
--- a/dynadjust/dynadjust/dnaadjust/dnaadjust_printer.hpp
+++ b/dynadjust/dynadjust/dnaadjust/dnaadjust_printer.hpp
@@ -87,6 +87,16 @@ enum class UncertaintyMode {
     Both
 };
 
+// Identifies which top-level report a station record is being written to.
+// Threaded through PrintAdjStation / PrintAdjStations / PrintAdjStationsUniqueList
+// so the JSONL side-channel can route records to the correct sibling file
+// without comparing ostream addresses (which breaks under staged-mode, where
+// the target is a stringstream flushed to the real file later).
+enum class ReportKind {
+    kAdj,  // adjustment report (.adj)
+    kXyz   // coordinate-only report (.xyz)
+};
+
 // Type traits for measurement classification
 template <typename T> struct IsAngularMeasurement : std::false_type {};
 
@@ -99,6 +109,7 @@ class DNAADJUST_API DynAdjustPrinter {
   public:
     // Constructor taking dna_adjust reference for direct access to members
     explicit DynAdjustPrinter(dna_adjust& adjust_instance);
+    virtual ~DynAdjustPrinter() = default;
 
     // Template-based measurement printing
     template <typename MeasurementType>
@@ -214,7 +225,7 @@ class DNAADJUST_API DynAdjustPrinter {
                                 const std::string& stn_coord_types, const UINT16& printStationCorrections);
                                 
     // Enhanced unique stations list processing
-    void PrintAdjStationsUniqueList(std::ostream& os,
+    void PrintAdjStationsUniqueList(ReportKind kind, std::ostream& os,
                                               const v_mat_2d* stationEstimates, v_mat_2d* stationVariances,
                                               bool recomputeGeographicCoords, bool updateGeographicCoords,
                                               bool reapplyTypeBUncertainties);
@@ -232,7 +243,7 @@ class DNAADJUST_API DynAdjustPrinter {
     bool IgnoredMeasurementContainsInvalidStation(pit_vmsr_t _it_msr);
     
     // Enhanced station formatting
-    void PrintAdjStation(std::ostream& os, const UINT32& block, const UINT32& stn, const UINT32& mat_idx,
+    void PrintAdjStation(ReportKind kind, std::ostream& os, const UINT32& block, const UINT32& stn, const UINT32& mat_idx,
                         const matrix_2d* stationEstimates, matrix_2d* stationVariances,
                         bool recomputeGeographicCoords, bool updateGeographicCoords, bool reapplyTypeBUncertainties);
     
@@ -244,7 +255,7 @@ class DNAADJUST_API DynAdjustPrinter {
                         const matrix_2d* stationEstimates);
     void PrintCorStations(std::ostream& cor_file, const UINT32& block);
     void PrintCorStationsUniqueList(std::ostream& cor_file);
-    void PrintAdjStations(std::ostream& os, const UINT32& block,
+    void PrintAdjStations(ReportKind kind, std::ostream& os, const UINT32& block,
                           const matrix_2d* stationEstimates,
                           matrix_2d* stationVariances, bool printBlockID,
                           bool recomputeGeographicCoords,
@@ -272,9 +283,77 @@ class DNAADJUST_API DynAdjustPrinter {
     void ProcessBlockStaging(_it_u32u32_uint32_pair _it_bsmu, UINT32& block);
     void FinalizeBlockStaging(UINT32 block, v_uint32_string_pair& stationsOutput, std::ostream& os);
 
-  private:
+    // Precomputed values threaded to OnAdjustedStation. Populated by
+    // PrintAdjStation after its own computations so subclass overrides do
+    // not repeat CartToGeo / var_local rotation / geoid application. The
+    // matrix references are to locals in PrintAdjStation and are valid
+    // for the synchronous duration of the hook call.
+    struct AdjustedStationContext {
+      double lat;                  // radians
+      double lon;                  // radians
+      double height;               // metres (ellipsoidal)
+      const matrix_2d& var_cart;   // 3x3
+      const matrix_2d& var_local;  // 3x3, geoid variance already in (2,2)
+    };
+
+    // Precomputed values threaded to OnPositionalUncertainty. These
+    // match the text .apu output exactly: var_local has NOT had the
+    // geoid variance added, and ellipse/PU are computed from that
+    // var_local. Subclasses that want geoid-included values add it
+    // themselves (the JSON override does this to preserve .apu.jsonl
+    // numeric output).
+    struct PositionalUncertaintyContext {
+      double lat;
+      double lon;
+      double height;
+      const matrix_2d& var_cart;
+      const matrix_2d& var_local;  // NO geoid added
+      double semimajor;
+      double semiminor;
+      double azimuth;
+      double hz_pos_u;
+      double vt_pos_u;
+    };
+
+    // Precomputed station-correction values threaded to OnStationCorrection.
+    // Populated only after PrintCorStation's vt/hz threshold gates pass, so
+    // overrides do not need to re-check thresholds.
+    struct StationCorrectionContext {
+      double cor_e;
+      double cor_n;
+      double cor_up;
+    };
+
+  protected:
+    // Virtual hooks for alternate output representations (e.g. JSONL).
+    // Default implementations are no-ops. ReportKind + block are passed
+    // explicitly because the target ostream may be a staging stringstream
+    // rather than the real sibling file.
+
+    virtual void OnAdjustedStation(ReportKind kind,
+                                   const it_vstn_t& stn_it,
+                                   const matrix_2d* estimates,
+                                   const matrix_2d* variances,
+                                   const UINT32& mat_idx,
+                                   const AdjustedStationContext& ctx) {}
+    virtual void OnAdjustedMeasurement(const it_vmsr_t& it_msr) {}
+    virtual void OnPositionalUncertainty(const it_vstn_t& stn_it,
+                                         const matrix_2d* variances,
+                                         const UINT32& mat_idx,
+                                         const PositionalUncertaintyContext& ctx) {}
+    virtual void OnStationCorrection(const UINT32& block,
+                                     const it_vstn_t& stn_it,
+                                     const matrix_2d* estimates,
+                                     const UINT32& mat_idx,
+                                     const StationCorrectionContext& ctx) {}
+    virtual void OnM2SRecord(const it_vstn_t& stn_it,
+                             MsrTally& stn_msr_tally) {}
+    virtual void OnStatistics() {}
+
     dna_adjust& adjust_;
 
+  private:
+
     // Helper functions
     constexpr int GetStationCount(char measurement_type) const;
     constexpr bool IsAngularType(char measurement_type) const;
diff --git a/dynadjust/dynadjust/dnaadjust/network_data_loader.cpp b/dynadjust/dynadjust/dnaadjust/network_data_loader.cpp
index bb23e27c5..03ad745d3 100644
--- a/dynadjust/dynadjust/dnaadjust/network_data_loader.cpp
+++ b/dynadjust/dynadjust/dnaadjust/network_data_loader.cpp
@@ -21,7 +21,9 @@
 
 #include "network_data_loader.hpp"
 
+#include <filesystem>
 #include <sstream>
+#include <system_error>
 #include <include/functions/dnatemplatefuncs.hpp>
 #include <include/functions/dnastrmanipfuncs.hpp>
 #include <include/functions/dnatemplatestnmsrfuncs.hpp>
@@ -30,6 +32,20 @@
 namespace dynadjust {
 namespace networkadjust {
 
+namespace {
+
+bool FileExists(const std::string& filename) {
+    if (filename.empty()) {
+        return false;
+    }
+
+    std::error_code ec;
+    const bool exists = std::filesystem::exists(filename, ec);
+    return !ec && exists;
+}
+
+}  // namespace
+
 NetworkDataLoader::NetworkDataLoader(const project_settings &settings)
     : settings_(settings),
       bst_loader_(std::make_unique<dynadjust::iostreams::BstFile>()),
@@ -117,6 +133,10 @@ bool NetworkDataLoader::LoadForSimultaneous(
 }
 
 bool NetworkDataLoader::LoadStations(vstn_t *bstBinaryRecords, binary_file_meta_t &bst_meta, UINT32 &bstn_count) {
+    if (!FileExists(settings_.a.bst_file)) {
+        throw StationLoadException("Failed to load binary station file: " + settings_.a.bst_file);
+    }
+
     auto result = bst_loader_->LoadWithOptional(settings_.a.bst_file, bstBinaryRecords, bst_meta);
     if (!result) { throw StationLoadException("Failed to load binary station file: " + settings_.a.bst_file); }
     bstn_count = static_cast<UINT32>(*result);
@@ -124,6 +144,10 @@ bool NetworkDataLoader::LoadStations(vstn_t *bstBinaryRecords, binary_file_meta_
 }
 
 bool NetworkDataLoader::LoadAssociatedStations(vASL *vAssocStnList, vUINT32 &v_ISLTemp, UINT32 &asl_count) {
+    if (!FileExists(settings_.s.asl_file)) {
+        throw StationLoadException("Failed to load associated station list file: " + settings_.s.asl_file);
+    }
+
     dynadjust::iostreams::AslFile asl_loader(settings_.s.asl_file);
     auto result = asl_loader.TryLoad();
     if (!result) { throw StationLoadException("Failed to load associated station list file: " + settings_.s.asl_file); }
@@ -136,6 +160,10 @@ bool NetworkDataLoader::LoadAssociatedStations(vASL *vAssocStnList, vUINT32 &v_I
 }
 
 bool NetworkDataLoader::LoadMeasurements(vmsr_t *bmsBinaryRecords, binary_file_meta_t &bms_meta, UINT32 &bmsr_count) {
+    if (!FileExists(settings_.a.bms_file)) {
+        throw MeasurementLoadException("Failed to load binary measurement file: " + settings_.a.bms_file);
+    }
+
     auto result = bms_loader_->LoadWithOptional(settings_.a.bms_file, bmsBinaryRecords, bms_meta);
     if (!result) { throw MeasurementLoadException("Failed to load binary measurement file: " + settings_.a.bms_file); }
     bmsr_count = static_cast<UINT32>(*result);
diff --git a/dynadjust/dynadjust/dnaadjustwrapper/CMakeLists.txt b/dynadjust/dynadjust/dnaadjustwrapper/CMakeLists.txt
index f0d64b45b..0600bcb26 100644
--- a/dynadjust/dynadjust/dnaadjustwrapper/CMakeLists.txt
+++ b/dynadjust/dynadjust/dnaadjustwrapper/CMakeLists.txt
@@ -87,8 +87,8 @@ if(BUILD_STATIC)
         "-framework CoreFoundation")
     else()
       target_link_options(${STATIC_TARGET_NAME} PRIVATE
-        -static)
-
+        -static-libgcc
+        -static-libstdc++)
     endif()
   elseif(WIN32)
     # On Windows with MSVC
diff --git a/dynadjust/dynadjust/dnaadjustwrapper/dnaadjustprogress.cpp b/dynadjust/dynadjust/dnaadjustwrapper/dnaadjustprogress.cpp
index 06361ff25..171b378f3 100644
--- a/dynadjust/dynadjust/dnaadjustwrapper/dnaadjustprogress.cpp
+++ b/dynadjust/dynadjust/dnaadjustwrapper/dnaadjustprogress.cpp
@@ -21,6 +21,7 @@
 
 #include <dynadjust/dnaadjustwrapper/dnaadjustprogress.hpp>
 #include <dynadjust/dnaadjust/dnaadjust.hpp>
+#include <include/math/dnamatrix_contiguous.hpp>
 
 /// \cond
 #include <time.h>
@@ -323,13 +324,14 @@ void dna_adjust_progress_thread::processAdjustment()
 				ss.str("");
 				ss << "  Iteration " << std::right << std::setw(2) << std::fixed << std::setprecision(0) << currentIteration;
 				ss << ", max station corr: " << std::right << std::setw(PROGRESS_ADJ_BLOCK_12) <<
-					_dnaAdj->GetMaxCorrection(currentIteration) << std::endl;
-					
+					_dnaAdj->GetMaxCorrection(currentIteration);
+				ss << ", time: " << _dnaAdj->GetIterationTime(currentIteration) << std::endl;
+
 				coutMessage(ss.str());
 			}
 			std::this_thread::sleep_for(std::chrono::milliseconds(80));
 		}
-		
+
 		break;
 	case Phased_Block_1Mode:
 	case PhasedMode:
@@ -350,12 +352,13 @@ void dna_adjust_progress_thread::processAdjustment()
 						
 				ss.str("");
 				ss << "  Iteration " << std::right << std::setw(2) << std::fixed << std::setprecision(0) << currentIteration;
-				ss << ", max station corr: " << std::right << std::setw(PROGRESS_ADJ_BLOCK_12) << _dnaAdj->GetMaxCorrection(currentIteration) << std::endl;
-				
+				ss << ", max station corr: " << std::right << std::setw(PROGRESS_ADJ_BLOCK_12) << _dnaAdj->GetMaxCorrection(currentIteration);
+				ss << ", time: " << _dnaAdj->GetIterationTime(currentIteration) << std::endl;
+
 				sst.str("");
 				if (first_time)
 					sst << std::setw(PROGRESS_ADJ_BLOCK_28) << std::left << " ";
-				sst << PROGRESS_BACKSPACE_28 << std::setw(PROGRESS_ADJ_BLOCK_28) << std::left << ss.str();
+				sst << PROGRESS_BACKSPACE_28 << std::left << ss.str();
 				coutMessage(sst.str());
 				first_time = true;
 			}
@@ -364,24 +367,33 @@ void dna_adjust_progress_thread::processAdjustment()
 					
 			// print new block to screen when adjusting only
 			if (block != currentBlock && _dnaAdj->IsAdjusting())
-			{						
+			{
 				ss.str("");
 				ss << "  Iteration " << std::right << std::setw(2) << std::fixed << std::setprecision(0) << _dnaAdj->CurrentIteration();
 
 				if (_p->a.multi_thread && !_dnaAdj->processingCombine())
 					ss << std::left << std::setw(13) << ", adjusting...";
 				else
-					ss << ", block " << std::left << std::setw(6) << std::fixed << std::setprecision(0) << _dnaAdj->CurrentBlock() + 1;
-						
-				sst.str("");
-				if (first_time)
 				{
-					sst << std::setw(PROGRESS_ADJ_BLOCK_28) << std::left << " ";
-					first_time = false;
+					ss << ", block " << std::left << std::setw(4) << std::fixed << std::setprecision(0) << _dnaAdj->CurrentBlock() + 1;
+					UINT32 stnCount = _dnaAdj->CurrentBlockStationCount();
+					if (stnCount > 0)
+					{
+						int max_t = dna_adjust::GetMaxBlasThreads();
+						ss << " (" << std::right << std::setw(5) << stnCount << " stns, ";
+						if (max_t > 0)
+							ss << std::setw(2) << max_t << "T";
+						else
+							ss << "auto";
+						ss << ")";
+					}
+					int64_t elapsedMs = _dnaAdj->LastBlockElapsedMs();
+					if (elapsedMs > 0)
+						ss << "  " << std::fixed << std::setprecision(1) << (elapsedMs / 1000.0) << "s";
 				}
-				
-				sst << PROGRESS_BACKSPACE_28 << std::setw(PROGRESS_ADJ_BLOCK_28) << std::left << ss.str();
-				coutMessage(sst.str());
+				ss << std::endl;
+				coutMessage(ss.str());
+				first_time = true;
 
 				currentBlock = block;
 			}
@@ -416,4 +428,3 @@ void dna_adjust_progress_thread::coutMessage(const std::string& message)
 	std::cout.flush();
 	cout_mutex.unlock();
 }
-
diff --git a/dynadjust/dynadjust/dnaadjustwrapper/dnaadjustwrapper.cpp b/dynadjust/dynadjust/dnaadjustwrapper/dnaadjustwrapper.cpp
index d8c3710de..73ecaab71 100644
--- a/dynadjust/dynadjust/dnaadjustwrapper/dnaadjustwrapper.cpp
+++ b/dynadjust/dynadjust/dnaadjustwrapper/dnaadjustwrapper.cpp
@@ -30,6 +30,7 @@
 #include <memory>
 #include <sstream>
 #include <string>
+#include <csignal>
 #include <thread>
 #include <vector>
 #include <boost/program_options/options_description.hpp>
@@ -38,6 +39,7 @@
 /// \endcond
 
 #include <include/config/dnaoptions-interface.hpp>
+#include <include/math/dnamatrix_contiguous.hpp>
 #include <include/config/dnaprojectfile.hpp>
 #include <include/config/dnatypes-gui.hpp>
 #include <include/functions/dnafilepathfuncs.hpp>
@@ -60,6 +62,14 @@ using namespace dynadjust::iostreams;
 extern bool running;
 extern std::mutex cout_mutex;
 
+static dna_adjust* g_netAdjust = nullptr;
+
+void sigint_handler(int)
+{
+	if (g_netAdjust)
+		g_netAdjust->CancelAdjustment();
+}
+
 using namespace dynadjust;
 using namespace dynadjust::epsg;
 
@@ -86,8 +96,9 @@ void PrintSummaryMessage(dna_adjust* netAdjust, const project_settings* p, boost
 			break;
 		std::stringstream ss("");
 		ss << "  Iteration " << std::right << std::setw(2) << std::fixed << std::setprecision(0) << currentIteration;
-		ss << ", max station corr: " << std::right << std::setw(12) << netAdjust->GetMaxCorrection(currentIteration) << std::endl;
-		std::cout << PROGRESS_BACKSPACE_28 << std::setw(28) << std::left << ss.str();
+		ss << ", max station corr: " << std::right << std::setw(12) << netAdjust->GetMaxCorrection(currentIteration);
+		ss << ", time: " << netAdjust->GetIterationTime(currentIteration) << std::endl;
+		std::cout << PROGRESS_BACKSPACE_28 << std::left << ss.str();
 	}
 
 	if (p->a.report_mode)
@@ -198,75 +209,75 @@ void DeserialiseVarianceMatrices(dna_adjust* netAdjust, const project_settings*
 void GenerateStatistics(dna_adjust* netAdjust, const project_settings* p)
 {
 	// Generate statistics
-	// Don't produce statistics only for block 1 only adjustments
-	if (p->a.adjust_mode != Phased_Block_1Mode)
+	if (!p->g.quiet)
 	{
-		if (!p->g.quiet)
+		std::cout << "+ Generating statistics...";
+		std::cout.flush();
+	}
+	netAdjust->GenerateStatistics();
+	if (!p->g.quiet)
+	{
+		std::cout << " done." << std::endl;
+
+		// Don't print detailed statistics for block 1 only adjustments
+		if (p->a.adjust_mode == Phased_Block_1Mode)
+			return;
+
+		std::cout << "+ Adjustment results:" << std::endl << std::endl;
+		std::cout << "+" << OUTPUTLINE << std::endl;
+		std::cout << std::setw(PRINT_VAR_PAD) << std::left << "  Number of unknown parameters" << std::fixed << std::setprecision(0) << netAdjust->GetUnknownsCount();
+		if (netAdjust->GetAllFixed())
+			std::cout << "  (All stations held constrained)";
+		std::cout << std::endl;
+
+		std::cout << std::setw(PRINT_VAR_PAD) << std::left << "  Number of measurements" << std::fixed << std::setprecision(0) << netAdjust->GetMeasurementCount();
+
+		if (netAdjust->GetPotentialOutlierCount() > 0)
 		{
-			std::cout << "+ Generating statistics...";
-			std::cout.flush();
+			std::cout << "  (" << netAdjust->GetPotentialOutlierCount() << " potential outlier";
+			if (netAdjust->GetPotentialOutlierCount() > 1)
+				std::cout << "s";
+			std::cout << ")";
 		}
-		netAdjust->GenerateStatistics();
-		if (!p->g.quiet)
-		{
-			std::cout << " done." << std::endl;
-
-			std::cout << "+ Adjustment results:" << std::endl << std::endl;
-			std::cout << "+" << OUTPUTLINE << std::endl;
-			std::cout << std::setw(PRINT_VAR_PAD) << std::left << "  Number of unknown parameters" << std::fixed << std::setprecision(0) << netAdjust->GetUnknownsCount();
-			if (netAdjust->GetAllFixed())
-				std::cout << "  (All stations held constrained)";
-			std::cout << std::endl;
+		std::cout << std::endl;
+		std::cout << std::setw(PRINT_VAR_PAD) << std::left << "  Degrees of freedom" << std::fixed << std::setprecision(0) << netAdjust->GetDegreesOfFreedom() << std::endl;
+		std::cout << std::setw(PRINT_VAR_PAD) << std::left << "  Chi squared" << std::fixed << std::setprecision(2) << netAdjust->GetChiSquared() << std::endl;
+		std::cout << std::setw(PRINT_VAR_PAD) << std::left << "  Rigorous sigma zero" << std::fixed << std::setprecision(3) << netAdjust->GetSigmaZero() << std::endl;
+		std::cout << std::setw(PRINT_VAR_PAD) << std::left << "  Global (Pelzer) Reliability" << std::fixed << std::setw(8) << std::setprecision(3) << netAdjust->GetGlobalPelzerRel() << "(excludes non redundant measurements)" << std::endl << std::endl;
 
-			std::cout << std::setw(PRINT_VAR_PAD) << std::left << "  Number of measurements" << std::fixed << std::setprecision(0) << netAdjust->GetMeasurementCount();
-			
-			if (netAdjust->GetPotentialOutlierCount() > 0)
-			{
-				std::cout << "  (" << netAdjust->GetPotentialOutlierCount() << " potential outlier";
-				if (netAdjust->GetPotentialOutlierCount() > 1)
-					std::cout << "s";
-				std::cout << ")";
-			}
-			std::cout << std::endl;
-			std::cout << std::setw(PRINT_VAR_PAD) << std::left << "  Degrees of freedom" << std::fixed << std::setprecision(0) << netAdjust->GetDegreesOfFreedom() << std::endl;
-			std::cout << std::setw(PRINT_VAR_PAD) << std::left << "  Chi squared" << std::fixed << std::setprecision(2) << netAdjust->GetChiSquared() << std::endl;
-			std::cout << std::setw(PRINT_VAR_PAD) << std::left << "  Rigorous sigma zero" << std::fixed << std::setprecision(3) << netAdjust->GetSigmaZero() << std::endl;
-			std::cout << std::setw(PRINT_VAR_PAD) << std::left << "  Global (Pelzer) Reliability" << std::fixed << std::setw(8) << std::setprecision(3) << netAdjust->GetGlobalPelzerRel() << "(excludes non redundant measurements)" << std::endl << std::endl;
-		
-			std::stringstream ss("");
-			ss << std::left << "  Chi-Square test (" << std::setprecision(1) << std::fixed << p->a.confidence_interval << "%)";
-			std::cout << std::setw(PRINT_VAR_PAD) << std::left << ss.str();
-			ss.str("");
-			ss << std::fixed << std::setprecision(3) << 
-				netAdjust->GetChiSquaredLowerLimit() << " < " << 
-				netAdjust->GetSigmaZero() << " < " <<
-				netAdjust->GetChiSquaredUpperLimit();
-			std::cout << std::setw(CHISQRLIMITS) << std::left << ss.str();
-			ss.str("");
-
-			if (netAdjust->GetDegreesOfFreedom() < 1)
-				ss << "NO REDUNDANCY";
-			else
+		std::stringstream ss("");
+		ss << std::left << "  Chi-Square test (" << std::setprecision(1) << std::fixed << p->a.confidence_interval << "%)";
+		std::cout << std::setw(PRINT_VAR_PAD) << std::left << ss.str();
+		ss.str("");
+		ss << std::fixed << std::setprecision(3) <<
+			netAdjust->GetChiSquaredLowerLimit() << " < " <<
+			netAdjust->GetSigmaZero() << " < " <<
+			netAdjust->GetChiSquaredUpperLimit();
+		std::cout << std::setw(CHISQRLIMITS) << std::left << ss.str();
+		ss.str("");
+
+		if (netAdjust->GetDegreesOfFreedom() < 1)
+			ss << "NO REDUNDANCY";
+		else
+		{
+			ss << "*** ";
+			switch (netAdjust->GetTestResult())
 			{
-				ss << "*** ";
-				switch (netAdjust->GetTestResult())
-				{
-				case test_stat_pass: 
-					ss << "PASSED";		// within upper and lower
-					break;
-				case test_stat_warning:
-					ss << "WARNING";	// less than lower limit
-					break;
-				case test_stat_fail:
-					ss << "FAILED";		// greater than upper limit
-					break;
-				}
-				ss << " ***";
+			case test_stat_pass:
+				ss << "PASSED";		// within upper and lower
+				break;
+			case test_stat_warning:
+				ss << "WARNING";	// less than lower limit
+				break;
+			case test_stat_fail:
+				ss << "FAILED";		// greater than upper limit
+				break;
 			}
-
-			std::cout << std::setw(PASS_FAIL) << std::right << ss.str() << std::endl;	
-			std::cout << "+" << OUTPUTLINE << std::endl << std::endl;
+			ss << " ***";
 		}
+
+		std::cout << std::setw(PASS_FAIL) << std::right << ss.str() << std::endl;
+		std::cout << "+" << OUTPUTLINE << std::endl << std::endl;
 	}
 	else
 		std::cout << std::endl;
@@ -727,6 +738,19 @@ int ParseCommandLineOptions(const int& argc, char* argv[], const boost::program_
 	if (vm.count(OUTPUT_STN_COR_FILE))
 		p.o._cor_file += ".cor";
 
+	if (vm.count(OUTPUT_JSON))
+	{
+		p.o._output_json = 1;
+		p.o._adj_json_file = p.o._adj_file + ".jsonl";
+		p.o._xyz_json_file = p.o._xyz_file + ".jsonl";
+		if (vm.count(OUTPUT_POS_UNCERTAINTY))
+			p.o._apu_json_file = p.o._apu_file + ".jsonl";
+		if (vm.count(OUTPUT_STN_COR_FILE))
+			p.o._cor_json_file = p.o._cor_file + ".jsonl";
+		if (vm.count(OUTPUT_MSR_TO_STN) && !p.o._m2s_file.empty())
+			p.o._m2s_json_file = p.o._m2s_file + ".jsonl";
+	}
+
 	if (vm.count(OUTPUT_STN_COR_FILE))
 		p.o._init_stn_corrections = 1;
 
@@ -867,6 +891,10 @@ int main(int argc, char* argv[])
 				"Recreate memory mapped files.")
 			(PURGE_STAGE_FILES,
 				"Purge memory mapped files from disk upon adjustment completion.")
+			(STAGE_PATH, boost::program_options::value<std::string>(&p.a.stage_path),
+				"Directory for memory mapped stage files. Default is the output folder.")
+			(MAX_THREADS, boost::program_options::value<int>(&p.a.max_threads),
+				"Maximum number of BLAS threads for linear algebra operations. Default is 0 (auto).")
 			;
 
 		output_options.add_options()
@@ -979,6 +1007,8 @@ int main(int argc, char* argv[])
 				"Export estimated station coordinates and uncertainties to DNA measurement file as a GNSS Y cluster.")
 			(EXPORT_SNX_FILE,
 				"Export estimated station coordinates and full variance matrix to SINEX file. Note: station names will be truncated to four characters as per the SINEX standard.")
+			(OUTPUT_JSON,
+				"Also emit adjustment reports as JSONL files alongside the text reports (one JSON object per line, same schema as JSONL import).")
 			;
 
 		// Declare a group of options that will be 
@@ -1327,7 +1357,12 @@ int main(int argc, char* argv[])
 	try {
 		running = true;
 
-        int nthreads_la = init_linear_algebra_threads();
+		// Install SIGINT handler for graceful cancellation
+		g_netAdjust = &netAdjust;
+		std::signal(SIGINT, sigint_handler);
+
+        int nthreads_la = init_linear_algebra_threads(p.a.max_threads);
+        dna_adjust::SetMaxBlasThreads(nthreads_la);
         std::thread progress(dna_adjust_progress_thread(&netAdjust, &p));
 
         // Do adjustment using linear algebra threads
@@ -1354,7 +1389,10 @@ int main(int argc, char* argv[])
 		PrintSummaryMessage(&netAdjust, &p, &elapsed_time);
 
 		if (netAdjust.GetStatus() > ADJUST_THRESHOLD_EXCEEDED)
+		{
+			netAdjust.PrintOscillationSummary();
 			return ADJUST_SUCCESS;
+		}
 
 		// Generate statistics
 		GenerateStatistics(&netAdjust, &p);
@@ -1401,6 +1439,9 @@ int main(int argc, char* argv[])
 		return EXIT_FAILURE;
 	}
 
+	netAdjust.PrintOscillationSummary();
+	netAdjust.PrintSuspectMeasurementSummary(std::cout);
+
 	if (!p.g.quiet)
 		std::cout << std::endl << "+ Open " << leafStr<std::string>(p.o._adj_file) << " to view the adjustment details." << std::endl << std::endl;
 	
@@ -1424,4 +1465,3 @@ int main(int argc, char* argv[])
 
 	return ADJUST_SUCCESS;
 }
-
diff --git a/dynadjust/dynadjust/dnaadjustwrapper/threading_init.hpp b/dynadjust/dynadjust/dnaadjustwrapper/threading_init.hpp
index 4c42f2cf7..4bf0aa91f 100644
--- a/dynadjust/dynadjust/dnaadjustwrapper/threading_init.hpp
+++ b/dynadjust/dynadjust/dnaadjustwrapper/threading_init.hpp
@@ -36,42 +36,56 @@
 #if defined(USE_MKL) || defined(__MKL__)
 #include <mkl.h>
 
-#elif defined(OPENBLAS_VERSION) || defined(__OPENBLAS_CONFIG_H) || defined(OPENBLAS_LOPT_H)
+#elif !defined(__APPLE__)
+
+#include <cblas.h>
+
+#if defined(OPENBLAS_VERSION) || defined(__OPENBLAS_CONFIG_H) || defined(OPENBLAS_LOPT_H)
 
 #ifndef USE_OPENBLAS
 #define USE_OPENBLAS
 #endif
 
-#include <cblas.h>
+#elif defined(__has_include)
+#if __has_include(<openblas_config.h>)
+#ifndef USE_OPENBLAS
+#define USE_OPENBLAS
+#endif
 #include <openblas_config.h>
+#endif
+#endif
 
+#ifdef USE_OPENBLAS
 extern "C" { void openblas_set_num_threads(int); }
+#endif
 
 #elif defined(__APPLE__)
 #include <Accelerate/Accelerate.h>
 #endif
 /// \endcond
 
+inline int positive_env_int(const char* name) {
+    const char* env = std::getenv(name);
+    if (!env || !*env) return 0;
+    int value = std::atoi(env);
+    return value > 0 ? value : 0;
+}
+
 inline int init_linear_algebra_threads(int requested_threads = 0) {
     int n = requested_threads;
 
-#if defined(_OPENMP)
     if (n <= 0) {
-        if (const char* env = std::getenv("OMP_NUM_THREADS"); env && *env) {
-            int v = std::atoi(env);
-            if (v > 0) n = v;
-        }
-    }
-    if (n <= 0) n = std::max(1, omp_get_max_threads());
+        n = positive_env_int("OMP_NUM_THREADS");
+#if defined(USE_MKL) || defined(__MKL__)
+        if (n <= 0) n = positive_env_int("MKL_NUM_THREADS");
+#elif defined(USE_OPENBLAS)
+        if (n <= 0) n = positive_env_int("OPENBLAS_NUM_THREADS");
 #elif defined(__APPLE__)
-    if (n == 1) {
-        BLASSetThreading(BLAS_THREADING_SINGLE_THREADED);
-    } else {
-        BLASSetThreading(BLAS_THREADING_MULTI_THREADED);
-    }
-#else
-    if (n <= 0) n = 1;
+        if (n <= 0) n = positive_env_int("VECLIB_MAXIMUM_THREADS");
 #endif
+    }
+
+    if (n <= 0) return 0;
 
 #if defined(_OPENMP)
     omp_set_dynamic(0);
@@ -83,7 +97,13 @@ inline int init_linear_algebra_threads(int requested_threads = 0) {
     omp_set_num_threads(n);
 #endif
 
-#ifdef USE_MKL
+#if defined(__APPLE__)
+    if (n == 1) {
+        BLASSetThreading(BLAS_THREADING_SINGLE_THREADED);
+    } else {
+        BLASSetThreading(BLAS_THREADING_MULTI_THREADED);
+    }
+#elif defined(USE_MKL) || defined(__MKL__)
     mkl_set_dynamic(0);
     mkl_set_num_threads(n);
 #if defined(MKL_THREAD_LOCAL)
diff --git a/dynadjust/dynadjust/dnadiff/CMakeLists.txt b/dynadjust/dynadjust/dnadiff/CMakeLists.txt
index 5b48c520b..819588f42 100644
--- a/dynadjust/dynadjust/dnadiff/CMakeLists.txt
+++ b/dynadjust/dynadjust/dnadiff/CMakeLists.txt
@@ -24,8 +24,8 @@ else()
   # Link statically
   if(UNIX)
     if(NOT APPLE)
-      SET_TARGET_PROPERTIES(${STATIC_TARGET_NAME} PROPERTIES LINK_FLAGS "-static")
-      target_link_libraries (${STATIC_TARGET_NAME} pthread)
+      target_link_options(${STATIC_TARGET_NAME} PRIVATE -static-libgcc -static-libstdc++)
+      target_link_libraries(${STATIC_TARGET_NAME} pthread)
     endif()
   endif()
 
diff --git a/dynadjust/dynadjust/dnageoidwrapper/CMakeLists.txt b/dynadjust/dynadjust/dnageoidwrapper/CMakeLists.txt
index 1223d5fdc..24fb8efbf 100644
--- a/dynadjust/dynadjust/dnageoidwrapper/CMakeLists.txt
+++ b/dynadjust/dynadjust/dnageoidwrapper/CMakeLists.txt
@@ -84,8 +84,8 @@ if(BUILD_STATIC)
         "-framework CoreFoundation")
     else()
       target_link_options(${STATIC_TARGET_NAME} PRIVATE
-        -static)
-
+        -static-libgcc
+        -static-libstdc++)
     endif()
   elseif(WIN32)
     # On Windows with MSVC
diff --git a/dynadjust/dynadjust/dnaimport/CMakeLists.txt b/dynadjust/dynadjust/dnaimport/CMakeLists.txt
index f48668c71..72f66d763 100644
--- a/dynadjust/dynadjust/dnaimport/CMakeLists.txt
+++ b/dynadjust/dynadjust/dnaimport/CMakeLists.txt
@@ -38,6 +38,8 @@ add_library (${PROJECT_NAME} SHARED
              ${CMAKE_SOURCE_DIR}/include/measurement_types/dnastntally.cpp
              dnaparser_pskel.cxx
              dnaparser_pimpl.cxx
+             dnaparser_validators.cpp
+             dnaparser_jsonl.cpp
              dnainterop.cpp
              ${CMAKE_SOURCE_DIR}/dynadjust.rc)
 
@@ -48,9 +50,10 @@ set_source_files_properties(
     PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON
 )
 
-# Also exclude the interop file which uses the parsers heavily
+# Also exclude the interop and JSONL parser files from unity builds
 set_source_files_properties(
     dnainterop.cpp
+    dnaparser_jsonl.cpp
     PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON
 )
 
diff --git a/dynadjust/dynadjust/dnaimport/dnainterop.cpp b/dynadjust/dynadjust/dnaimport/dnainterop.cpp
index ee4cd7ee6..9a5242be5 100644
--- a/dynadjust/dynadjust/dnaimport/dnainterop.cpp
+++ b/dynadjust/dynadjust/dnaimport/dnainterop.cpp
@@ -20,8 +20,7 @@
 //============================================================================
 
 #include <dynadjust/dnaimport/dnainterop.hpp>
-
-//#include <include/io/DynaML-schema.hxx>
+#include <dynadjust/dnaimport/dnaparser_jsonl.hpp>
 
 using namespace dynadjust::epsg;
 
@@ -176,7 +175,8 @@ void dna_import::BuildExtractStationsList(const std::string& stnList, pvstring v
 }
 	
 
-void dna_import::InitialiseDatum(const std::string& reference_frame, const std::string epoch)
+void dna_import::InitialiseDatum(const std::string& reference_frame, const std::string epoch,
+	const std::string observation_epoch)
 {
 	try {
 		// Take the default reference frame, set either by the user or
@@ -198,11 +198,13 @@ void dna_import::InitialiseDatum(const std::string& reference_frame, const std::
 	if (datum_.GetEpoch() == timeImmemorial<boost::gregorian::date>())
 		m_strProjectDefaultEpoch = "";
 
+	m_strProjectObservationEpoch = observation_epoch;
+
 	// Update binary file meta
 	// Note: the following rule applies each time a set of files is loaded via import:
 	//	* This method (InitialiseDatum) is called (from dnaimportwrapper) before any files are loaded.
 	//    By default, the bst & bms meta are initialised with the reference frame and reference epoch.
-	//  * The datum and epoch within the first file (if present) is used to set the default project 
+	//  * The datum and epoch within the first file (if present) is used to set the default project
 	//    datum. If a datum isn't provided in the first input file, e.g. SINEX file, the default datum
 	//    (GDA2020) is used. As each subsequent file is loaded, the default frame and epoch are assumed.
 	//  * After all files have been loaded, InitialiseDatum is called again to set the metadata.
@@ -212,6 +214,56 @@ void dna_import::InitialiseDatum(const std::string& reference_frame, const std::
     snprintf(bms_meta_.epsgCode, sizeof(bms_meta_.epsgCode), "%s", m_strProjectDefaultEpsg.substr(0, STN_EPSG_WIDTH).c_str());
     snprintf(bst_meta_.epoch, sizeof(bst_meta_.epoch), "%s", m_strProjectDefaultEpoch.substr(0, STN_EPOCH_WIDTH).c_str());
     snprintf(bms_meta_.epoch, sizeof(bms_meta_.epoch), "%s", m_strProjectDefaultEpoch.substr(0, STN_EPOCH_WIDTH).c_str());
+    // observation_epoch is immutable; record the CLI-supplied project-level value (empty if not supplied).
+    snprintf(bst_meta_.observation_epoch, sizeof(bst_meta_.observation_epoch), "%s", m_strProjectObservationEpoch.substr(0, STN_EPOCH_WIDTH).c_str());
+    snprintf(bms_meta_.observation_epoch, sizeof(bms_meta_.observation_epoch), "%s", m_strProjectObservationEpoch.substr(0, STN_EPOCH_WIDTH).c_str());
+}
+
+
+void dna_import::ApplyProjectObservationEpoch(vdnaMsrPtr* vMeasurements)
+{
+	if (m_strProjectObservationEpoch.empty() || vMeasurements == nullptr)
+		return;
+
+	const std::string& obsEpoch = m_strProjectObservationEpoch;
+
+	// A measurement's observation_epoch is treated as "not explicitly set" when it is
+	// empty or equal to the reference-frame epoch (the auto-default from SetEpoch).
+	auto needs_override = [](const std::string& msrObsEpoch, const std::string& msrEpoch) {
+		return msrObsEpoch.empty() || msrObsEpoch == msrEpoch;
+	};
+
+	for (auto& msr_ptr : *vMeasurements)
+	{
+		if (!msr_ptr)
+			continue;
+
+		if (needs_override(msr_ptr->GetObservationEpoch(), msr_ptr->GetEpoch()))
+			msr_ptr->SetObservationEpoch(obsEpoch);
+
+		// GPS baseline cluster (G/X): propagate to every baseline element
+		if (auto* baselines = msr_ptr->GetBaselines_ptr())
+		{
+			for (auto& bsl : *baselines)
+			{
+				if (needs_override(bsl.GetObservationEpoch(), bsl.GetEpoch()))
+					bsl.SetObservationEpoch(obsEpoch);
+			}
+		}
+
+		// GPS point cluster (Y): propagate to every point element
+		if (auto* points = msr_ptr->GetPoints_ptr())
+		{
+			for (auto& pnt : *points)
+			{
+				if (needs_override(pnt.GetObservationEpoch(), pnt.GetEpoch()))
+					pnt.SetObservationEpoch(obsEpoch);
+			}
+		}
+
+		// Direction set (D): directions inherit from the parent measurement; no per-direction
+		// observation_epoch field exists beyond what the set-level value already carries.
+	}
 }
 	
 
@@ -333,9 +385,30 @@ _PARSE_STATUS_ dna_import::ParseInputFile(const std::string& fileName, vdnaStnPt
 
 		SignalComplete();
 	}
+	// JSONL
+	else if (
+		first_chars[0] == '{' ||				// JSON object on first line
+		icontains(fileName, ".jsonl"))			// .jsonl extension
+	{
+		// Set the file type
+		input_file_meta->filetype = jsonl;
+		m_ift = jsonl;
+
+		// Parse the JSONL file
+		ParseJSONL(fileName, vStations, stnCount, vMeasurements, msrCount, clusterID, fileEpsg, fileEpoch, firstFile, success_msg);
+
+		if (fileEpsg.empty())
+			fileEpsg = m_strProjectDefaultEpsg;
+
+		// record the file's default reference frame
+        snprintf(input_file_meta->epsgCode, sizeof(input_file_meta->epsgCode), "%s", fileEpsg.substr(0, STN_EPSG_WIDTH).c_str());
+        snprintf(input_file_meta->epoch, sizeof(input_file_meta->epoch), "%s", fileEpoch.substr(0, STN_EPOCH_WIDTH).c_str());
+
+		SignalComplete();
+	}
 	// STN or MSR
 	else if (
-		// use boost::algorithm::ifind_first, which is a case insensitive implementation of the find first algorithm. 
+		// use boost::algorithm::ifind_first, which is a case insensitive implementation of the find first algorithm.
 		strncmp(first_chars, "!#=DNA", 6) == 0 ||	// dna file?
 		icontains(fileName, ".stn") ||			// dna station file
 		icontains(fileName, ".msr"))				// dna measurement file
@@ -400,18 +473,6 @@ void dna_import::ParseXML(const std::string& fileName, vdnaStnPtr* vStations, PU
 	_filespecifiedreferenceframe = false;
 	_filespecifiedepoch = false;
 
-	// Check if DynaML.xsd exists in the current directory
-	// This prevents the XML parser from hanging when the schema file is missing
-	if (!std::filesystem::exists("DynaML.xsd"))
-	{
-		import_file_mutex.unlock();
-		std::stringstream ss;
-		ss << "ParseXML(): DynaML.xsd schema file not found in the current directory." << std::endl;
-		ss << "  The XML parser requires this file to validate XML input files." << std::endl;
-		ss << "  Please ensure DynaML.xsd is present in the working directory.";
-		SignalExceptionParse(ss.str(), 0);
-	}
-
 	try
 	{
 		// Instantiate individual parsers.
@@ -450,7 +511,7 @@ void dna_import::ParseXML(const std::string& fileName, vdnaStnPtr* vStations, PU
 		StationCoord_p.parsers (string_p, string_p, string_p, Height_p, string_p, GeoidModel_p);
 
 		DnaMeasurement_p.parsers (string_p, string_p, string_p, string_p, string_p, string_p, string_p, string_p,
-				string_p, string_p, Directions_p, string_p, string_p, string_p, GPSBaseline_p, string_p, string_p,
+				string_p, string_p, Directions_p, string_p, string_p, string_p, string_p, GPSBaseline_p, string_p, string_p,
 				string_p, Clusterpoint_p, string_p, string_p, string_p, string_p,
 				(projectSettings_.i.prefer_single_x_as_g == TRUE ? true : false));
 
@@ -473,7 +534,7 @@ void dna_import::ParseXML(const std::string& fileName, vdnaStnPtr* vStations, PU
 		::xml_schema::document doc_p (DnaXmlFormat_p, "DnaXmlFormat");
 
 		DnaXmlFormat_p.pre();
-		doc_p.parse (*ifsInputFILE_);
+		doc_p.parse (*ifsInputFILE_, ::xml_schema::flags::dont_validate);
 		DnaXmlFormat_p.post_DnaXmlFormat (vStations, vMeasurements);
 
         // unlock after parsing
@@ -553,6 +614,7 @@ void dna_import::ParseXML(const std::string& fileName, vdnaStnPtr* vStations, PU
 		{
 			std::stringstream ss;
 			ss << "The default input file reference frame \"" << referenceframe_p.str() << "\" is not recognised.";
+			import_file_mutex.unlock();
 			SignalExceptionParse(static_cast<std::string>(ss.str()), 0);
 		}
 
@@ -580,6 +642,7 @@ void dna_import::ParseXML(const std::string& fileName, vdnaStnPtr* vStations, PU
 		}
 		std::stringstream ss;
 		ss << "ParseXML(): An std::ios_base failure was encountered while parsing " << fileName << "." << std::endl << "  " << f.what();
+		import_file_mutex.unlock();
 		SignalExceptionParse(static_cast<std::string>(ss.str()), 0);
 	}
 	catch (const std::system_error& e)
@@ -598,12 +661,14 @@ void dna_import::ParseXML(const std::string& fileName, vdnaStnPtr* vStations, PU
 		}
 		std::stringstream ss;
 		ss << "ParseXML(): An std::ios_base failure was encountered while parsing " << fileName << "." << std::endl << "  " << e.what();
+		import_file_mutex.unlock();
 		SignalExceptionParse(static_cast<std::string>(ss.str()), 0);
 	}
-	catch (const XMLInteropException& e) 
+	catch (const XMLInteropException& e)
 	{
 		std::stringstream ss;
 		ss << "ParseXML(): An exception was encountered while parsing " << fileName << "." << std::endl << "  " << e.what();
+		import_file_mutex.unlock();
 		SignalExceptionParse(static_cast<std::string>(ss.str()), 0);
 	}
 	catch (const ::xml_schema::parsing& e)
@@ -611,7 +676,7 @@ void dna_import::ParseXML(const std::string& fileName, vdnaStnPtr* vStations, PU
 		std::stringstream ss("");
 		ss << e.what();
 
-		::xsd::cxx::parser::diagnostics<char>::const_iterator _it;		
+		::xsd::cxx::parser::diagnostics<char>::const_iterator _it;
 		for (_it=e.diagnostics().begin(); _it!=e.diagnostics().end(); _it++)
 		{
 			ss << std::endl;
@@ -620,19 +685,29 @@ void dna_import::ParseXML(const std::string& fileName, vdnaStnPtr* vStations, PU
 			ss << ", severity " <<  _it->severity() << std::endl;
 			ss << "  - " << _it->message();
 		}
+		import_file_mutex.unlock();
 		SignalExceptionParse(ss.str(), 0);
 	}
 	catch (const ::xml_schema::exception& e)
 	{
 		std::stringstream ss;
 		ss << "ParseXML(): An xml_schema exception was encountered while parsing " << fileName << "." << std::endl << "  " << e.what();
+		import_file_mutex.unlock();
 		SignalExceptionParse(static_cast<std::string>(ss.str()), 0);
 	}
+	catch (const std::exception& e)
+	{
+		std::stringstream ss;
+		ss << "ParseXML(): An error was encountered while parsing " << fileName << "." << std::endl << "  " << e.what();
+		import_file_mutex.unlock();
+		SignalExceptionParse(ss.str(), 0);
+	}
 	catch (...)
 	{
 		std::stringstream ss;
 		ss << "ParseXML(): An unknown error was encountered while parsing " << fileName << "." << std::endl;
-		SignalExceptionParse(ss.str(), 0);	
+		import_file_mutex.unlock();
+		SignalExceptionParse(ss.str(), 0);
 	}
 
 	if (parseStatus_ != PARSE_SUCCESS)
@@ -818,12 +893,16 @@ void dna_import::ApplyDiscontinuitiesMeasurements(vdnaMsrPtr* vMeasurements)
 			continue;
 		}
 
-		// Check if an epoch been provided with this measurement
-		if (_it_msr->get()->GetEpoch().empty())
+		// Prefer the observation epoch for discontinuity matching; fall back
+		// to reference-frame epoch if the file did not supply an observation epoch.
+		std::string match_epoch = _it_msr->get()->GetObservationEpoch();
+		if (match_epoch.empty())
+			match_epoch = _it_msr->get()->GetEpoch();
+		if (match_epoch.empty())
 			continue;
 
 		// Capture the epoch of the measurement
-		site_date = dateFromString<boost::gregorian::date>(_it_msr->get()->GetEpoch());
+		site_date = dateFromString<boost::gregorian::date>(match_epoch);
 
 		// 2. Handle 'first' station for every measurement type
 		stn1 = _it_msr->get()->GetFirst();
@@ -930,8 +1009,15 @@ void dna_import::ApplyDiscontinuitiesMeasurements_GX(std::vector<CDnaGpsBaseline
 		_it_msr != vGpsBaselines->end();
 		_it_msr++)
 	{
+		// Prefer observation epoch; fall back to reference-frame epoch.
+		std::string match_epoch = _it_msr->GetObservationEpoch();
+		if (match_epoch.empty())
+			match_epoch = _it_msr->GetEpoch();
+		if (match_epoch.empty())
+			continue;
+
 		// Capture the start date of the site
-		site_date = dateFromString<boost::gregorian::date>(_it_msr->GetEpoch());
+		site_date = dateFromString<boost::gregorian::date>(match_epoch);
 
 		// Station 1
 		stn1 = _it_msr->GetFirst();
@@ -983,8 +1069,15 @@ void dna_import::ApplyDiscontinuitiesMeasurements_Y(std::vector<CDnaGpsPoint>* v
 		_it_msr != vGpsPoints->end();
 		_it_msr++)
 	{
+		// Prefer observation epoch; fall back to reference-frame epoch.
+		std::string match_epoch = _it_msr->GetObservationEpoch();
+		if (match_epoch.empty())
+			match_epoch = _it_msr->GetEpoch();
+		if (match_epoch.empty())
+			continue;
+
 		// Capture the start date of the site
-		site_date = dateFromString<boost::gregorian::date>(_it_msr->GetEpoch());
+		site_date = dateFromString<boost::gregorian::date>(match_epoch);
 
 		// Station 1
 		stn1 = _it_msr->GetFirst();
@@ -1056,8 +1149,104 @@ void dna_import::ApplyDiscontinuitiesMeasurements_D(std::vector<CDnaDirection>*
 }
 	
 
-void dna_import::ParseDNA(const std::string& fileName, vdnaStnPtr* vStations, PUINT32 stnCount, 
-							   vdnaMsrPtr* vMeasurements, PUINT32 msrCount, PUINT32 clusterID, 
+void dna_import::ParseJSONL(const std::string& fileName, vdnaStnPtr* vStations, PUINT32 stnCount,
+							   vdnaMsrPtr* vMeasurements, PUINT32 msrCount, PUINT32 clusterID,
+							   std::string& fileEpsg, std::string& fileEpoch, bool firstFile, std::string* success_msg)
+{
+	parseStatus_ = PARSE_SUCCESS;
+	_filespecifiedreferenceframe = false;
+	_filespecifiedepoch = false;
+
+	try
+	{
+		import::JsonlParseContext ctx;
+		ctx.default_frame = datum_.GetName();
+		ctx.default_epoch = datum_.GetEpoch_s();
+		ctx.first_file = firstFile;
+		ctx.user_supplied_frame = (projectSettings_.i.user_supplied_frame == 1);
+		ctx.user_supplied_epoch = (projectSettings_.i.user_supplied_epoch == 1);
+		ctx.override_input_frame = (projectSettings_.i.override_input_rfame == 1);
+		ctx.prefer_single_x_as_g = (projectSettings_.i.prefer_single_x_as_g == TRUE);
+		ctx.cluster_id = *clusterID;
+
+		import::ParseJsonlFile(fileName, vStations, vMeasurements, ctx);
+
+		*clusterID = ctx.cluster_id;
+		*stnCount = ctx.stn_count;
+		*msrCount = ctx.msr_count;
+		*success_msg = ctx.message + "\n";
+		_filespecifiedreferenceframe = ctx.file_specified_frame;
+		_filespecifiedepoch = ctx.file_specified_epoch;
+
+		// Reference frame / epoch resolution (replicated from ParseXML)
+		try
+		{
+			fileEpsg = ctx.file_epsg;
+			if (fileEpsg.empty())
+				fileEpsg = datum_.GetEpsgCode_s();
+
+			fileEpoch = ctx.file_epoch;
+			if (fileEpoch.empty() || isEpsgDatumStatic(LongFromString<UINT32>(fileEpsg)))
+				fileEpoch = referenceepochFromEpsgString<std::string>(fileEpsg);
+
+			if (projectSettings_.i.user_supplied_frame)
+			{
+				if (!projectSettings_.i.user_supplied_epoch)
+				{
+					if (firstFile)
+					{
+						projectSettings_.i.epoch = fileEpoch;
+						projectSettings_.r.epoch = fileEpoch;
+						m_strProjectDefaultEpoch = fileEpoch;
+						datum_.SetEpoch(fileEpoch);
+					}
+				}
+			}
+			else
+			{
+				if (firstFile)
+				{
+					projectSettings_.i.reference_frame = datumFromEpsgString<std::string>(fileEpsg);
+					projectSettings_.r.reference_frame = projectSettings_.i.reference_frame;
+					m_strProjectDefaultEpsg = fileEpsg;
+
+					projectSettings_.i.epoch = fileEpoch;
+					projectSettings_.r.epoch = fileEpoch;
+					m_strProjectDefaultEpoch = fileEpoch;
+				}
+			}
+		}
+		catch (...)
+		{
+			std::stringstream ss;
+			ss << "The default JSONL input file reference frame is not recognised.";
+			SignalExceptionParse(static_cast<std::string>(ss.str()), 0);
+		}
+
+		if (!vStations->empty() && !vMeasurements->empty())
+			m_idt = stn_msr_data;
+		else if (!vStations->empty())
+			m_idt = stn_data;
+		else if (!vMeasurements->empty())
+			m_idt = msr_data;
+
+	}
+	catch (const XMLInteropException&)
+	{
+		throw;  // re-throw
+	}
+	catch (const std::exception& e)
+	{
+		std::stringstream ss;
+		ss << "ParseJSONL(): An exception was encountered while parsing " << fileName << "." << std::endl;
+		ss << "  " << e.what() << std::endl;
+		SignalExceptionParse(ss.str(), 0);
+	}
+}
+
+
+void dna_import::ParseDNA(const std::string& fileName, vdnaStnPtr* vStations, PUINT32 stnCount,
+							   vdnaMsrPtr* vMeasurements, PUINT32 msrCount, PUINT32 clusterID,
 							   std::string& fileEpsg, std::string& fileEpoch, bool firstFile)
 {
 	parseStatus_ = PARSE_SUCCESS;
@@ -1148,7 +1337,7 @@ void dna_import::ParseDNA(const std::string& fileName, vdnaStnPtr* vStations, PU
 			projectSettings_.r.epoch = fileEpoch;
 			m_strProjectDefaultEpoch = fileEpoch;
 
-			InitialiseDatum(projectSettings_.i.reference_frame, projectSettings_.i.epoch);
+			InitialiseDatum(projectSettings_.i.reference_frame, projectSettings_.i.epoch, projectSettings_.i.observation_epoch);
 		}
 	}
 
@@ -1739,12 +1928,18 @@ void dna_import::ParseDNAMSRLinear(const std::string& sBuf, dnaMsrPtr& msr_ptr)
 
 	// Epoch
 	msr_ptr->SetEpoch(ParseEpochValue(sBuf, "ParseDNAMSRLinear"));
+	// Observation epoch (DNA v3.02 column, optional)
+	{
+		std::string obs_epoch = ParseObsEpochValue(sBuf, "ParseDNAMSRLinear");
+		if (!obs_epoch.empty())
+			msr_ptr->SetObservationEpoch(obs_epoch);
+	}
 
 	// Capture msr_id and cluster_id (for database referencing)
 	ParseDatabaseIds(sBuf, "ParseDNAMSRLinear", msr_ptr->GetTypeC());
 	msr_ptr->SetDatabaseMap(m_msr_db_map);
 
-	// instrument and target heights only make sense for 
+	// instrument and target heights only make sense for
 	// slope distances, vertical angles and zenith distances
 	switch (msr_ptr->GetTypeC())
 	{
@@ -1806,6 +2001,12 @@ void dna_import::ParseDNAMSRCoordinate(const std::string& sBuf, dnaMsrPtr& msr_p
 
 	// Epoch
 	msr_ptr->SetEpoch(ParseEpochValue(sBuf, "ParseDNAMSRLinear"));
+	// Observation epoch (DNA v3.02 column, optional)
+	{
+		std::string obs_epoch = ParseObsEpochValue(sBuf, "ParseDNAMSRCoordinate");
+		if (!obs_epoch.empty())
+			msr_ptr->SetObservationEpoch(obs_epoch);
+	}
 
 	// Capture msr_id and cluster_id (for database referencing), then set
 	// database id info
@@ -1821,6 +2022,7 @@ void dna_import::ParseDNAMSRGPSBaselines(std::string& sBuf, dnaMsrPtr& msr_ptr,
 
 	bslTmp.SetReferenceFrame(msr_ptr->GetReferenceFrame());
 	bslTmp.SetEpoch(msr_ptr->GetEpoch());
+	bslTmp.SetObservationEpoch(msr_ptr->GetObservationEpoch());
 
 	// Measurement type
 	std::string tmp;
@@ -1943,10 +2145,18 @@ void dna_import::ParseDNAMSRGPSBaselines(std::string& sBuf, dnaMsrPtr& msr_ptr,
 				// Set the baseline epoch
 				bslTmp.SetEpoch(tmp);
 			}
+
+			// Observation epoch (DNA v3.02 column, optional; overrides default)
+			std::string obs_epoch = ParseObsEpochValue(sBuf, "ParseDNAMSRGPSBaselines");
+			if (!obs_epoch.empty())
+			{
+				msr_ptr->SetObservationEpoch(obs_epoch);
+				bslTmp.SetObservationEpoch(obs_epoch);
+			}
 		}
 		catch (std::runtime_error& e) {
 			std::stringstream ss;
-			ss << "ParseDNAMSRGPSBaselines(): Error parsing epoch:  " << 
+			ss << "ParseDNAMSRGPSBaselines(): Error parsing epoch:  " <<
 			 	std::endl << "    " << e.what();
 			SignalExceptionParseDNA(ss.str(), "", dml_.msr_gps_epoch);
 		}
@@ -2042,6 +2252,7 @@ void dna_import::ParseDNAMSRGPSPoints(std::string& sBuf, dnaMsrPtr& msr_ptr, boo
 
 	pntTmp.SetReferenceFrame(msr_ptr->GetReferenceFrame());
 	pntTmp.SetEpoch(msr_ptr->GetEpoch());
+	pntTmp.SetObservationEpoch(msr_ptr->GetObservationEpoch());
 
 	// Measurement type
 	std::string tmp;
@@ -2136,6 +2347,7 @@ void dna_import::ParseDNAMSRGPSPoints(std::string& sBuf, dnaMsrPtr& msr_ptr, boo
 		// Set the point frame
 		pntTmp.SetReferenceFrame(projectSettings_.i.reference_frame);
 		pntTmp.SetEpoch(msr_ptr->GetEpoch());
+		pntTmp.SetObservationEpoch(msr_ptr->GetObservationEpoch());
 	}
 	else //if (!projectSettings_.i.override_input_rfame)
 	{
@@ -2153,7 +2365,7 @@ void dna_import::ParseDNAMSRGPSPoints(std::string& sBuf, dnaMsrPtr& msr_ptr, boo
 		}
 		catch (std::runtime_error& e) {
 			std::stringstream ss;
-			ss << "ParseDNAMSRGPSPoints(): Error parsing reference frame:  " << std::endl << 
+			ss << "ParseDNAMSRGPSPoints(): Error parsing reference frame:  " << std::endl <<
 				"    " << e.what();
 			SignalExceptionParseDNA(ss.str(), "", dml_.msr_gps_reframe);
 		}
@@ -2179,10 +2391,18 @@ void dna_import::ParseDNAMSRGPSPoints(std::string& sBuf, dnaMsrPtr& msr_ptr, boo
 				// Set the point epoch
 				pntTmp.SetEpoch(tmp);
 			}
+
+			// Observation epoch (DNA v3.02 column, optional; overrides default)
+			std::string obs_epoch = ParseObsEpochValue(sBuf, "ParseDNAMSRGPSPoints");
+			if (!obs_epoch.empty())
+			{
+				msr_ptr->SetObservationEpoch(obs_epoch);
+				pntTmp.SetObservationEpoch(obs_epoch);
+			}
 		}
 		catch (std::runtime_error& e) {
 			std::stringstream ss;
-			ss << "ParseDNAMSRGPSPoints(): Error parsing epoch:  " << std::endl << 
+			ss << "ParseDNAMSRGPSPoints(): Error parsing epoch:  " << std::endl <<
 				"    " << e.what();
 			SignalExceptionParseDNA(ss.str(), "", dml_.msr_gps_epoch);
 		}
@@ -2691,7 +2911,7 @@ std::string dna_import::ParseEpochValue(const std::string& sBuf, const std::stri
 {
 	if (sBuf.length() <= dml_.msr_gps_epoch)
 		return "";
-	
+
 	std::string epoch;
 	try {
 		if (sBuf.length() > static_cast<std::string::size_type>(dml_.msr_gps_epoch + dmw_.msr_gps_epoch))
@@ -2707,6 +2927,30 @@ std::string dna_import::ParseEpochValue(const std::string& sBuf, const std::stri
 	return epoch;
 }
 
+std::string dna_import::ParseObsEpochValue(const std::string& sBuf, const std::string& calling_function)
+{
+	// DNA v3.01 (and earlier) files don't have an observation-epoch column;
+	// in that case the field layout leaves msr_gps_obs_epoch at 0.
+	if (dml_.msr_gps_obs_epoch == 0 || dmw_.msr_gps_obs_epoch == 0)
+		return "";
+	if (sBuf.length() <= dml_.msr_gps_obs_epoch)
+		return "";
+
+	std::string obs_epoch;
+	try {
+		if (sBuf.length() > static_cast<std::string::size_type>(dml_.msr_gps_obs_epoch + dmw_.msr_gps_obs_epoch))
+			obs_epoch = trimstr(sBuf.substr(dml_.msr_gps_obs_epoch, dmw_.msr_gps_obs_epoch));
+		else
+			obs_epoch = trimstr(sBuf.substr(dml_.msr_gps_obs_epoch));
+	}
+	catch (...) {
+		SignalExceptionParseDNA(calling_function + "(): Could not extract observation epoch from the record:  ",
+			sBuf, dml_.msr_gps_obs_epoch);
+	}
+
+	return obs_epoch;
+}
+
 std::string dna_import::ParseGPSMsrValue(const std::string& sBuf, const std::string& element, const std::string& calling_function)
 {
 	try {
@@ -2770,6 +3014,12 @@ void dna_import::ParseDNAMSRAngular(const std::string& sBuf, dnaMsrPtr& msr_ptr)
 
 	// Epoch
 	msr_ptr->SetEpoch(ParseEpochValue(sBuf, "ParseDNAMSRAngular"));
+	// Observation epoch (DNA v3.02 column, optional)
+	{
+		std::string obs_epoch = ParseObsEpochValue(sBuf, "ParseDNAMSRAngular");
+		if (!obs_epoch.empty())
+			msr_ptr->SetObservationEpoch(obs_epoch);
+	}
 
 	// Capture msr_id and cluster_id (for database referencing), then set
 	// database id info
@@ -2849,6 +3099,12 @@ UINT32 dna_import::ParseDNAMSRDirections(std::string& sBuf, dnaMsrPtr& msr_ptr,
 
 		// Epoch
 		msr_ptr->SetEpoch(ParseEpochValue(sBuf, "ParseDNAMSRDirections"));
+		// Observation epoch (DNA v3.02 column, optional)
+		{
+			std::string obs_epoch = ParseObsEpochValue(sBuf, "ParseDNAMSRDirections");
+			if (!obs_epoch.empty())
+				msr_ptr->SetObservationEpoch(obs_epoch);
+		}
 
 		// Capture msr_id and cluster_id (for database referencing)
 		ParseDatabaseIds(sBuf, "ParseDNAMSRDirections", msr_ptr->GetTypeC());
diff --git a/dynadjust/dynadjust/dnaimport/dnainterop.hpp b/dynadjust/dynadjust/dnaimport/dnainterop.hpp
index 7c4a4f201..0a28ac9f8 100644
--- a/dynadjust/dynadjust/dnaimport/dnainterop.hpp
+++ b/dynadjust/dynadjust/dnaimport/dnainterop.hpp
@@ -180,8 +180,16 @@ class dna_import {
 	inline void ResetFileOrder() const { g_fileOrder = 0; }
 	inline bool filespecifiedReferenceFrame() const { return _filespecifiedreferenceframe; }
 	inline bool filespecifiedEpoch() const { return _filespecifiedepoch; }
-	void InitialiseDatum(const std::string& reference_frame, const std::string epoch="");
-	
+	void InitialiseDatum(const std::string& reference_frame, const std::string epoch="",
+		const std::string observation_epoch="");
+
+	// Applies the project-level observation epoch (from --observation-epoch) to every
+	// measurement whose observation_epoch is empty or equal to its reference-frame epoch
+	// (i.e. was auto-defaulted). Explicit file-level values set via <EpochOfObservation>
+	// or DNA v3.02 column 25 that differ from epoch are preserved. No-op if the CLI flag
+	// was not supplied.
+	void ApplyProjectObservationEpoch(vdnaMsrPtr* vMeasurements);
+
 	void PrintMeasurementsToStations(std::string& m2s_file, MsrTally* parsemsrTally,
 		std::string& bst_file, std::string& bms_file, std::string& aml_file, pvASLPtr vAssocStnList);
 
@@ -199,10 +207,15 @@ class dna_import {
 	void ParseSNX(const std::string& fileName, vdnaStnPtr* vStations, PUINT32 stnCount, 
 							   vdnaMsrPtr* vMeasurements, PUINT32 msrCount, PUINT32 clusterID);
 	
+	// JSONL files
+	void ParseJSONL(const std::string& fileName, vdnaStnPtr* vStations, PUINT32 stnCount,
+							   vdnaMsrPtr* vMeasurements, PUINT32 msrCount, PUINT32 clusterID,
+							   std::string& fileEpsg, std::string& fileEpoch, bool firstFile, std::string* success_msg);
+
 	// DNA Ascii files
 	//void ParseDNAVersion(const INPUT_DATA_TYPE& idt);
-	void ParseDNA(const std::string& fileName, vdnaStnPtr* vStations, PUINT32 stnCount, 
-							   vdnaMsrPtr* vMeasurements, PUINT32 msrCount, PUINT32 clusterID, 
+	void ParseDNA(const std::string& fileName, vdnaStnPtr* vStations, PUINT32 stnCount,
+							   vdnaMsrPtr* vMeasurements, PUINT32 msrCount, PUINT32 clusterID,
 							   std::string& fileEpsg, std::string& fileEpoch, bool firstFile);
 	void ParseDNASTN(vdnaStnPtr* vStations, PUINT32 stnCount,
 								const std::string& fileEpsg, const std::string& fileEpoch);
@@ -236,6 +249,7 @@ class dna_import {
 	std::string ParseScaleHValue(const std::string& sBuf, const std::string& calling_function);
 	std::string ParseRefFrameValue(const std::string& sBuf, const std::string& calling_function);
 	std::string ParseEpochValue(const std::string& sBuf, const std::string& calling_function);
+	std::string ParseObsEpochValue(const std::string& sBuf, const std::string& calling_function);
 
 	void ParseDatabaseIds(const std::string& sBuf, const std::string& calling_function, const char msrType);
 	void ParseDatabaseClusterId(const std::string& sBuf, const std::string& calling_function);
@@ -338,6 +352,7 @@ class dna_import {
 
 	std::string		m_strProjectDefaultEpsg;
 	std::string		m_strProjectDefaultEpoch;
+	std::string		m_strProjectObservationEpoch;	// Project-level observation epoch from --observation-epoch (immutable; may be empty)
 	std::string		m_msrComments;
 
 	vvUINT32	v_ISL_;				// Inner stations
diff --git a/dynadjust/dynadjust/dnaimport/dnaparser_jsonl.cpp b/dynadjust/dynadjust/dnaimport/dnaparser_jsonl.cpp
new file mode 100644
index 000000000..66c133da8
--- /dev/null
+++ b/dynadjust/dynadjust/dnaimport/dnaparser_jsonl.cpp
@@ -0,0 +1,679 @@
+//============================================================================
+// Name         : dnaparser_jsonl.cpp
+// Author       : Dale Roberts <dale.o.roberts@gmail.com>
+// Copyright    : Copyright 2025 Geoscience Australia
+//
+//                Licensed under the Apache License, Version 2.0 (the "License");
+//                you may not use this file except in compliance with the License.
+//                You may obtain a copy of the License at
+//
+//                http ://www.apache.org/licenses/LICENSE-2.0
+//
+//                Unless required by applicable law or agreed to in writing, software
+//                distributed under the License is distributed on an "AS IS" BASIS,
+//                WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//                See the License for the specific language governing permissions and
+//                limitations under the License.
+//
+// Description  : JSONL parser for DynaML-equivalent station and measurement
+//                data.  One JSON object per line, using the same element
+//                names and hierarchy as the DynaML XML schema.
+//============================================================================
+
+#include <fstream>
+#include <exception>
+#include <sstream>
+#include <string>
+
+#include <include/thirdparty/nlohmann/json.hpp>
+
+#include <dynadjust/dnaimport/dnaparser_jsonl.hpp>
+#include <dynadjust/dnaimport/dnaparser_validators.hpp>
+#include <include/exception/dnaexception.hpp>
+#include <include/parameters/dnaepsg.hpp>
+#include <include/measurement_types/dnastntally.hpp>
+
+using json = nlohmann::json;
+using dynadjust::exception::XMLInteropException;
+using dynadjust::measurements::CDnaCovariance;
+using dynadjust::measurements::CDnaDirection;
+using dynadjust::measurements::CDnaGpsBaseline;
+using dynadjust::measurements::CDnaGpsPoint;
+using dynadjust::measurements::CDnaStation;
+using dynadjust::measurements::MsrTally;
+using dynadjust::measurements::StnTally;
+using dynadjust::measurements::dnaMsrPtr;
+using dynadjust::measurements::dnaStnPtr;
+using dynadjust::measurements::vdnaMsrPtr;
+using dynadjust::measurements::vdnaStnPtr;
+
+extern MsrTally g_parsemsr_tally;
+extern StnTally g_parsestn_tally;
+extern UINT32 g_fileOrder;
+
+namespace dynadjust {
+namespace import {
+namespace {
+
+// Helper to get a string value from a JSON object, returning empty string
+// if the key is absent.  Handles both JSON strings ("1.23") and JSON
+// numbers (1.23) so that callers don't need to care about quoting.
+std::string jstr(const json& obj, const char* key) {
+  auto it = obj.find(key);
+  if (it == obj.end() || it->is_null())
+    return "";
+  if (it->is_string())
+    return it->get<std::string>();
+  if (it->is_number()) {
+    // dump() produces a full-precision decimal without quotes.
+    return it->dump();
+  }
+  return it->dump();  // fallback for booleans etc.
+}
+
+bool jignore(const json& obj, const char* key) {
+  auto it = obj.find(key);
+  if (it == obj.end() || it->is_null())
+    return false;
+  if (it->is_boolean())
+    return it->get<bool>();
+  if (it->is_string())
+    return !it->get<std::string>().empty();
+  return !it->dump().empty();
+}
+
+// Throw with line number context.
+[[noreturn]] void throwLine(const std::string& msg, UINT32 line_no) {
+  std::stringstream ss;
+  ss << "JSONL line " << line_no << ": " << msg;
+  throw XMLInteropException(ss.str(), 0);
+}
+
+// -------------------------------------------------------------------
+// Header
+// -------------------------------------------------------------------
+
+void parseHeader(const json& obj, JsonlParseContext& ctx, UINT32 line_no) {
+  const auto& hdr = obj.contains("DnaAdjustmentReport")
+                        ? obj.at("DnaAdjustmentReport")
+                        : obj.at("DnaXmlFormat");
+  ctx.file_epsg = "";
+  ctx.file_epoch = "";
+
+  std::string rf = jstr(hdr, "referenceframe");
+  std::string ep = jstr(hdr, "epoch");
+
+  if (!rf.empty()) {
+    ctx.file_specified_frame = true;
+    try {
+      ctx.file_epsg = epsg::epsgStringFromName<std::string>(rf);
+    } catch (const std::exception& e) {
+      throwLine(e.what(), line_no);
+    }
+  }
+
+  if (!ep.empty()) {
+    ctx.file_specified_epoch = true;
+    ctx.file_epoch = ep;
+  }
+}
+
+// -------------------------------------------------------------------
+// Station
+// -------------------------------------------------------------------
+
+void parseStation(const json& obj, vdnaStnPtr* vStations,
+                  JsonlParseContext& ctx, UINT32 line_no) {
+  const auto& stn = obj.at("DnaStation");
+
+  std::string name = jstr(stn, "Name");
+  ValidateStationName(name);
+
+  std::string frame, epoch;
+  if (ctx.override_input_frame)
+    frame = ctx.default_frame;
+  else if (!ctx.file_epsg.empty())
+    frame = epsg::datumFromEpsgString<std::string>(ctx.file_epsg);
+  else
+    frame = ctx.default_frame;
+
+  if (ctx.override_input_frame)
+    epoch = ctx.default_epoch;
+  else if (!ctx.file_epoch.empty())
+    epoch = ctx.file_epoch;
+  else
+    epoch = ctx.default_epoch;
+
+  dnaStnPtr station(new CDnaStation(frame, epoch));
+  station->SetfileOrder(g_fileOrder++);
+  station->SetName(name);
+
+  std::string constraints = DefaultConstraints(jstr(stn, "Constraints"));
+  station->SetConstraints(constraints);
+  g_parsestn_tally.addstation(constraints);
+
+  station->SetCoordType(jstr(stn, "Type"));
+
+  // StationCoord sub-object
+  auto it_coord = stn.find("StationCoord");
+  if (it_coord != stn.end()) {
+    const auto& coord = *it_coord;
+    // Name inside StationCoord is the same; we already set it.
+    station->SetXAxis(jstr(coord, "XAxis"));
+    station->SetYAxis(jstr(coord, "YAxis"));
+    station->SetHeight(jstr(coord, "Height"));
+
+    std::string hz = jstr(coord, "HemisphereZone");
+    if (!hz.empty())
+      station->SetHemisphereZone(hz);
+  }
+
+  station->SetDescription(SanitiseDescription(jstr(stn, "Description")));
+
+  vStations->push_back(station);
+  ctx.stn_count++;
+}
+
+// -------------------------------------------------------------------
+// GPS Covariance  (shared between X-baselines and Y-points)
+// -------------------------------------------------------------------
+
+void parseGPSCovariance(const json& cov_obj, CDnaGpsBaseline& bsl) {
+  CDnaCovariance cov;
+  cov.SetType("X");
+  cov.SetClusterID(bsl.GetClusterID());
+  cov.SetM11(jstr(cov_obj, "m11"));
+  cov.SetM12(jstr(cov_obj, "m12"));
+  cov.SetM13(jstr(cov_obj, "m13"));
+  cov.SetM21(jstr(cov_obj, "m21"));
+  cov.SetM22(jstr(cov_obj, "m22"));
+  cov.SetM23(jstr(cov_obj, "m23"));
+  cov.SetM31(jstr(cov_obj, "m31"));
+  cov.SetM32(jstr(cov_obj, "m32"));
+  cov.SetM33(jstr(cov_obj, "m33"));
+  bsl.AddGpsCovariance(&cov);
+}
+
+void parsePointCovariance(const json& cov_obj, CDnaGpsPoint& pt) {
+  CDnaCovariance cov;
+  cov.SetType("Y");
+  cov.SetClusterID(pt.GetClusterID());
+  cov.SetM11(jstr(cov_obj, "m11"));
+  cov.SetM12(jstr(cov_obj, "m12"));
+  cov.SetM13(jstr(cov_obj, "m13"));
+  cov.SetM21(jstr(cov_obj, "m21"));
+  cov.SetM22(jstr(cov_obj, "m22"));
+  cov.SetM23(jstr(cov_obj, "m23"));
+  cov.SetM31(jstr(cov_obj, "m31"));
+  cov.SetM32(jstr(cov_obj, "m32"));
+  cov.SetM33(jstr(cov_obj, "m33"));
+  pt.AddPointCovariance(&cov);
+}
+
+// -------------------------------------------------------------------
+// GPS Baselines  (G and X types)
+// -------------------------------------------------------------------
+
+void parseGPSBaselines(const json& msr_obj, dnaMsrPtr& msr,
+                       JsonlParseContext& ctx, UINT32 line_no) {
+  auto it = msr_obj.find("GPSBaseline");
+  if (it == msr_obj.end())
+    throwLine("GPS measurement requires \"GPSBaseline\" array.", line_no);
+
+  const auto& baselines = *it;
+  if (!baselines.is_array())
+    throwLine("\"GPSBaseline\" must be an array.", line_no);
+
+  char type_c = msr->GetTypeC();
+  UINT32 total = static_cast<UINT32>(baselines.size());
+
+  // Reserve space in the cluster
+  msr->ReserveGpsBaselinesCount(total);
+
+  for (UINT32 i = 0; i < total; ++i) {
+    const auto& bsl_obj = baselines[i];
+
+    CDnaGpsBaseline bsl;
+    bsl.SetType(msr->GetType());
+
+    // First and Second: each baseline can override the parent's values
+    // (for X-type clusters, each baseline may connect different stations)
+    std::string first = jstr(bsl_obj, "First");
+    bsl.SetFirst(first.empty() ? msr->GetFirst() : first);
+
+    std::string second = jstr(bsl_obj, "Second");
+    bsl.SetTarget(second.empty() ? msr->GetTarget() : second);
+
+    bsl.SetReferenceFrame(msr->GetReferenceFrame());
+    bsl.SetEpoch(msr->GetEpoch());
+    bsl.SetObservationEpoch(msr->GetObservationEpoch());
+    bsl.SetClusterID(msr->GetClusterID());
+    bsl.SetClusterDBID(msr->GetClusterDBID(), msr->GetClusterDBIDset());
+
+    // For X-type clusters with >1 baselines, reserve covariance space
+    if (type_c == 'X' && total > 1)
+      bsl.ReserveGpsCovariancesCount(total - 1);
+
+    // Set X, Y, Z components — each increments tally 1x
+    bsl.SetX(jstr(bsl_obj, "X"));
+    ctx.msr_count++;
+    if (type_c == 'G')
+      g_parsemsr_tally.G++;
+    else
+      g_parsemsr_tally.X++;
+
+    bsl.SetY(jstr(bsl_obj, "Y"));
+    ctx.msr_count++;
+    if (type_c == 'G')
+      g_parsemsr_tally.G++;
+    else
+      g_parsemsr_tally.X++;
+
+    bsl.SetZ(jstr(bsl_obj, "Z"));
+    ctx.msr_count++;
+    if (type_c == 'G')
+      g_parsemsr_tally.G++;
+    else
+      g_parsemsr_tally.X++;
+
+    // Per-baseline MeasurementID
+    std::string bsl_dbid = jstr(bsl_obj, "MeasurementID");
+    if (!bsl_dbid.empty())
+      bsl.SetMeasurementDBID(bsl_dbid);
+
+    // Sigma values
+    bsl.SetSigmaXX(jstr(bsl_obj, "SigmaXX"));
+    bsl.SetSigmaXY(jstr(bsl_obj, "SigmaXY"));
+    bsl.SetSigmaXZ(jstr(bsl_obj, "SigmaXZ"));
+    bsl.SetSigmaYY(jstr(bsl_obj, "SigmaYY"));
+    bsl.SetSigmaYZ(jstr(bsl_obj, "SigmaYZ"));
+    bsl.SetSigmaZZ(jstr(bsl_obj, "SigmaZZ"));
+
+    // Covariances (only for X-type clusters)
+    auto it_cov = bsl_obj.find("GPSCovariance");
+    if (it_cov != bsl_obj.end() && it_cov->is_array()) {
+      for (const auto& cov_obj : *it_cov) {
+        parseGPSCovariance(cov_obj, bsl);
+      }
+    }
+
+    msr->AddGpsBaseline(&bsl);
+  }
+}
+
+// -------------------------------------------------------------------
+// GPS Points  (Y type)
+// -------------------------------------------------------------------
+
+void parseClusterpoints(const json& msr_obj, dnaMsrPtr& msr,
+                        JsonlParseContext& ctx, UINT32 line_no) {
+  auto it = msr_obj.find("Clusterpoint");
+  if (it == msr_obj.end())
+    throwLine("Y measurement requires \"Clusterpoint\" array.", line_no);
+
+  const auto& points = *it;
+  if (!points.is_array())
+    throwLine("\"Clusterpoint\" must be an array.", line_no);
+
+  UINT32 total = static_cast<UINT32>(points.size());
+
+  // Reserve space in the cluster
+  msr->ReserveGpsPointsCount(total);
+
+  for (UINT32 i = 0; i < total; ++i) {
+    const auto& pt_obj = points[i];
+
+    CDnaGpsPoint pt;
+    pt.SetType(msr->GetType());
+    pt.SetCoordType(msr->GetCoordType());
+
+    // Each clusterpoint can have its own First station
+    std::string first = jstr(pt_obj, "First");
+    pt.SetFirst(first.empty() ? msr->GetFirst() : first);
+
+    pt.SetClusterID(msr->GetClusterID());
+    pt.SetClusterDBID(msr->GetClusterDBID(), msr->GetClusterDBIDset());
+    pt.SetReferenceFrame(msr->GetReferenceFrame());
+    pt.SetEpoch(msr->GetEpoch());
+    pt.SetObservationEpoch(msr->GetObservationEpoch());
+
+    // Set X, Y, Z components — each increments tally 1x
+    pt.SetX(jstr(pt_obj, "X"));
+    ctx.msr_count++;
+    g_parsemsr_tally.Y++;
+
+    pt.SetY(jstr(pt_obj, "Y"));
+    ctx.msr_count++;
+    g_parsemsr_tally.Y++;
+
+    pt.SetZ(jstr(pt_obj, "Z"));
+    ctx.msr_count++;
+    g_parsemsr_tally.Y++;
+
+    // Per-point MeasurementID
+    std::string pt_dbid = jstr(pt_obj, "MeasurementID");
+    if (!pt_dbid.empty())
+      pt.SetMeasurementDBID(pt_dbid);
+
+    // Sigma values
+    pt.SetSigmaXX(jstr(pt_obj, "SigmaXX"));
+    pt.SetSigmaXY(jstr(pt_obj, "SigmaXY"));
+    pt.SetSigmaXZ(jstr(pt_obj, "SigmaXZ"));
+    pt.SetSigmaYY(jstr(pt_obj, "SigmaYY"));
+    pt.SetSigmaYZ(jstr(pt_obj, "SigmaYZ"));
+    pt.SetSigmaZZ(jstr(pt_obj, "SigmaZZ"));
+
+    // Point covariances
+    auto it_cov = pt_obj.find("PointCovariance");
+    if (it_cov != pt_obj.end() && it_cov->is_array()) {
+      for (const auto& cov_obj : *it_cov) {
+        parsePointCovariance(cov_obj, pt);
+      }
+    }
+
+    msr->AddGpsPoint(&pt);
+  }
+}
+
+// -------------------------------------------------------------------
+// Directions  (D type)
+// -------------------------------------------------------------------
+
+void parseDirections(const json& msr_obj, dnaMsrPtr& msr,
+                     JsonlParseContext& ctx, UINT32 line_no) {
+  auto it = msr_obj.find("Directions");
+  if (it == msr_obj.end())
+    throwLine("D measurement requires \"Directions\" array.", line_no);
+
+  const auto& directions = *it;
+  if (!directions.is_array())
+    throwLine("\"Directions\" must be an array.", line_no);
+
+  UINT32 total = msr->GetTotal();
+
+  for (const auto& dir_obj : directions) {
+    CDnaDirection dir;
+    dir.SetClusterID(msr->GetClusterID());
+    dir.SetClusterDBID(msr->GetClusterDBID(), msr->GetClusterDBIDset());
+    dir.SetEpoch(msr->GetEpoch());
+    dir.SetObservationEpoch(msr->GetObservationEpoch());
+
+    // Ignore for individual directions
+    bool dir_ignored = jignore(dir_obj, "Ignore");
+    dir.SetIgnore(dir_ignored);
+
+    dir.SetTarget(jstr(dir_obj, "Target"));
+    dir.SetValue(jstr(dir_obj, "Value"));
+    dir.SetStdDev(jstr(dir_obj, "StdDev"));
+
+    // Direction Value always increments measurement count
+    ctx.msr_count++;
+
+    msr->AddDirection(&dir);
+
+    // Tally counting: only count non-ignored directions
+    // (matching pimpl behaviour in Directions_pimpl::post_Directions)
+    if (msr->GetIgnore())
+      continue;
+
+    if (!dir_ignored) {
+      g_parsemsr_tally.D++;
+    } else {
+      ValidateDirectionInSet(msr, true, total);
+    }
+  }
+}
+
+// -------------------------------------------------------------------
+// Measurement dispatch
+// -------------------------------------------------------------------
+
+void parseMeasurement(const json& obj, vdnaMsrPtr* vMeasurements,
+                      JsonlParseContext& ctx, UINT32 line_no) {
+  const auto& msr_obj = obj.at("DnaMeasurement");
+
+  std::string type_str = jstr(msr_obj, "Type");
+  char type_c = ValidateMeasurementType(type_str);
+
+  // Determine frame and epoch for this measurement
+  std::string frame, epoch;
+  std::string msr_rf = jstr(msr_obj, "ReferenceFrame");
+  std::string msr_ep = jstr(msr_obj, "Epoch");
+  std::string msr_obs_ep = jstr(msr_obj, "EpochOfObservation");
+
+  bool rf_supplied = !msr_rf.empty();
+  bool ep_supplied = !msr_ep.empty();
+  bool obs_ep_supplied = !msr_obs_ep.empty();
+
+  if (rf_supplied || ctx.override_input_frame)
+    frame = ctx.override_input_frame ? ctx.default_frame : msr_rf;
+  else if (!ctx.file_epsg.empty())
+    frame = epsg::datumFromEpsgString<std::string>(ctx.file_epsg);
+  else
+    frame = ctx.default_frame;
+
+  if (ep_supplied || ctx.override_input_frame)
+    epoch = ctx.override_input_frame ? ctx.default_epoch : msr_ep;
+  else if (!ctx.file_epoch.empty())
+    epoch = ctx.file_epoch;
+  else
+    epoch = ctx.default_epoch;
+
+  // Create measurement (increments tally for scalar types)
+  dnaMsrPtr msr = CreateMeasurement(type_c, &ctx.cluster_id,
+      ctx.msr_count, g_parsemsr_tally, frame, epoch);
+  msr->SetType(type_str);
+
+  // Ignore
+  if (jignore(msr_obj, "Ignore")) {
+    msr->SetIgnore(true);
+    g_parsemsr_tally.ignored++;
+  } else {
+    msr->SetIgnore(false);
+  }
+
+  // Source, MeasurementID, ClusterID
+  msr->SetSource(jstr(msr_obj, "Source"));
+
+  std::string msr_dbid = jstr(msr_obj, "MeasurementID");
+  if (!msr_dbid.empty())
+    msr->SetMeasurementDBID(msr_dbid);
+
+  std::string cluster_dbid = jstr(msr_obj, "ClusterID");
+  if (!cluster_dbid.empty())
+    msr->SetClusterDBID(cluster_dbid);
+
+  // First station
+  std::string first = jstr(msr_obj, "First");
+  ValidateFirst(first);
+  msr->SetFirst(first);
+
+  // Second station
+  std::string second = jstr(msr_obj, "Second");
+  ValidateSecond(second, type_c, first);
+  if (TypeRequiresSecond(type_c))
+    msr->SetTarget(second);
+
+  // Third station (only for angles)
+  std::string third = jstr(msr_obj, "Third");
+  ValidateThird(third, type_c, first);
+  if (!third.empty())
+    msr->SetTarget2(third);
+
+  // Value and StdDev (scalar types)
+  std::string value = jstr(msr_obj, "Value");
+  ValidateValue(value, type_c, first);
+  if (!value.empty())
+    msr->SetValue(value);
+
+  std::string stddev = jstr(msr_obj, "StdDev");
+  ValidateStdDev(stddev, type_c, first);
+  if (!stddev.empty())
+    msr->SetStdDev(stddev);
+
+  // Instrument and target heights (S, V, Z types)
+  switch (type_c) {
+  case 'S': case 'V': case 'Z': {
+    std::string ih = jstr(msr_obj, "InstHeight");
+    if (!ih.empty())
+      msr->SetInstrumentHeight(ih);
+    std::string th = jstr(msr_obj, "TargHeight");
+    if (!th.empty())
+      msr->SetTargetHeight(th);
+    break;
+  }
+  }
+
+  // Reference frame and epoch (for GPS types, already set via
+  // CreateMeasurement but may need per-measurement override)
+  if (rf_supplied && !ctx.override_input_frame)
+    msr->SetReferenceFrame(msr_rf);
+
+  if (ep_supplied && !ctx.override_input_frame)
+    msr->SetEpoch(msr_ep);
+
+  if (obs_ep_supplied)
+    msr->SetObservationEpoch(msr_obs_ep);
+
+  // Scales
+  std::string vscale = jstr(msr_obj, "Vscale");
+  if (!vscale.empty())
+    msr->SetVscale(DefaultScale(vscale));
+
+  std::string pscale = jstr(msr_obj, "Pscale");
+  if (!pscale.empty())
+    msr->SetPscale(DefaultScale(pscale));
+
+  std::string lscale = jstr(msr_obj, "Lscale");
+  if (!lscale.empty())
+    msr->SetLscale(DefaultScale(lscale));
+
+  std::string hscale = jstr(msr_obj, "Hscale");
+  if (!hscale.empty())
+    msr->SetHscale(DefaultScale(hscale));
+
+  // Total (for cluster/set types D, X, Y; G auto-sets from baseline count)
+  std::string total = jstr(msr_obj, "Total");
+  if (type_c != 'G') {
+    ValidateTotal(total, type_c);
+    if (!total.empty())
+      msr->SetTotal(total);
+  }
+
+  // Coords (for Y type)
+  std::string coords = jstr(msr_obj, "Coords");
+  if (!coords.empty())
+    msr->SetCoordType(coords);
+
+  // Dispatch to sub-parsers for complex types
+  switch (type_c) {
+  case 'G':
+  case 'X':
+    parseGPSBaselines(msr_obj, msr, ctx, line_no);
+    // For G type, set Total from actual baseline count
+    if (type_c == 'G')
+      msr->SetTotal(static_cast<UINT32>(msr->GetBaselines_ptr()->size()));
+    break;
+  case 'Y':
+    parseClusterpoints(msr_obj, msr, ctx, line_no);
+    break;
+  case 'D':
+    parseDirections(msr_obj, msr, ctx, line_no);
+    break;
+  }
+
+  // Ignored empty direction set — skip silently (matching pimpl)
+  if (type_c == 'D' && msr->GetTotal() == 0 && msr->GetIgnore())
+    return;
+
+  // Finalise and add
+  vMeasurements->push_back(msr);
+  FinaliseMeasurement(msr, ctx.prefer_single_x_as_g);
+}
+
+}  // anonymous namespace
+
+// -------------------------------------------------------------------
+// Public entry point
+// -------------------------------------------------------------------
+
+void ParseJsonlFile(const std::string& filename,
+                    vdnaStnPtr* vStations,
+                    vdnaMsrPtr* vMeasurements,
+                    JsonlParseContext& ctx) {
+  std::ifstream ifs(filename);
+  if (!ifs.is_open()) {
+    std::stringstream ss;
+    ss << "ParseJsonlFile(): Could not open " << filename;
+    throw XMLInteropException(ss.str(), 0);
+  }
+
+  // Initialise tallies
+  g_parsemsr_tally.initialise();
+  g_parsestn_tally.initialise();
+
+  ctx.stn_count = 0;
+  ctx.msr_count = 0;
+  ctx.file_specified_frame = false;
+  ctx.file_specified_epoch = false;
+  ctx.file_epsg = "";
+  ctx.file_epoch = "";
+
+  std::string line;
+  UINT32 line_no = 0;
+  while (std::getline(ifs, line)) {
+    ++line_no;
+
+    // Skip empty lines
+    if (line.empty() || line.find_first_not_of(" \t\r\n") == std::string::npos)
+      continue;
+
+    json obj;
+    try {
+      obj = json::parse(line);
+    } catch (const json::parse_error& e) {
+      throwLine(std::string("JSON parse error: ") + e.what(), line_no);
+    }
+
+    if (!obj.is_object() || obj.empty())
+      throwLine("Expected a JSON object.", line_no);
+
+    try {
+      // Accept both header wrappers: DnaXmlFormat is the original name shared
+      // with the XML schema; DnaAdjustmentReport is the adjustment-output
+      // header emitted by the JSONL side-channel printer.
+      if (obj.contains("DnaXmlFormat") ||
+          obj.contains("DnaAdjustmentReport")) {
+        parseHeader(obj, ctx, line_no);
+      } else if (obj.contains("DnaStatistics")) {
+        // Adjustment-report JSONL includes statistics records that are useful
+        // to consumers but have no station/measurement input equivalent.
+        // Treat them as metadata so .adj.jsonl streams remain re-ingestible.
+      } else if (obj.contains("DnaStation")) {
+        parseStation(obj, vStations, ctx, line_no);
+      } else if (obj.contains("DnaMeasurement")) {
+        parseMeasurement(obj, vMeasurements, ctx, line_no);
+      } else {
+        throwLine("Unrecognised top-level key.", line_no);
+      }
+    } catch (const XMLInteropException&) {
+      throw;  // re-throw as-is
+    } catch (const std::exception& e) {
+      throwLine(e.what(), line_no);
+    }
+  }
+
+  // Build success message
+  std::ostringstream ss;
+  if (ctx.stn_count > 0)
+    ss << "Loaded " << ctx.stn_count << " stations";
+  if (ctx.msr_count > 0) {
+    if (ctx.stn_count > 0)
+      ss << ", ";
+    ss << "Loaded " << ctx.msr_count << " measurements";
+  }
+  ctx.message = ss.str();
+}
+
+}  // namespace import
+}  // namespace dynadjust
diff --git a/dynadjust/dynadjust/dnaimport/dnaparser_jsonl.hpp b/dynadjust/dynadjust/dnaimport/dnaparser_jsonl.hpp
new file mode 100644
index 000000000..61dcd1831
--- /dev/null
+++ b/dynadjust/dynadjust/dnaimport/dnaparser_jsonl.hpp
@@ -0,0 +1,65 @@
+//============================================================================
+// Name         : dnaparser_jsonl.hpp
+// Author       : Dale Roberts <dale.o.roberts@gmail.com>
+// Copyright    : Copyright 2025 Geoscience Australia
+//
+//                Licensed under the Apache License, Version 2.0 (the "License");
+//                you may not use this file except in compliance with the License.
+//                You may obtain a copy of the License at
+//
+//                http ://www.apache.org/licenses/LICENSE-2.0
+//
+//                Unless required by applicable law or agreed to in writing, software
+//                distributed under the License is distributed on an "AS IS" BASIS,
+//                WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//                See the License for the specific language governing permissions and
+//                limitations under the License.
+//
+// Description  : JSONL parser for DynaML-equivalent station and measurement
+//                data.  One JSON object per line, using the same element names
+//                and hierarchy as the DynaML XML schema.
+//============================================================================
+
+#ifndef DYNADJUST_DNAIMPORT_DNAPARSER_JSONL_HPP_
+#define DYNADJUST_DNAIMPORT_DNAPARSER_JSONL_HPP_
+
+#include <string>
+
+#include <include/measurement_types/dnameasurement_types.hpp>
+
+namespace dynadjust {
+namespace import {
+
+struct JsonlParseContext {
+  // Inputs
+  std::string default_frame;
+  std::string default_epoch;
+  bool first_file;
+  bool user_supplied_frame;
+  bool user_supplied_epoch;
+  bool override_input_frame;
+  bool prefer_single_x_as_g;
+
+  // Outputs
+  UINT32 stn_count;
+  UINT32 msr_count;
+  UINT32 cluster_id;
+  std::string file_epsg;
+  std::string file_epoch;
+  std::string message;
+  bool file_specified_frame;
+  bool file_specified_epoch;
+};
+
+// Parse a JSONL file containing DynaML-equivalent station and measurement
+// data.  Populates vStations and vMeasurements; updates context tallies,
+// counts and metadata.
+void ParseJsonlFile(const std::string& filename,
+                    measurements::vdnaStnPtr* vStations,
+                    measurements::vdnaMsrPtr* vMeasurements,
+                    JsonlParseContext& ctx);
+
+}  // namespace import
+}  // namespace dynadjust
+
+#endif  // DYNADJUST_DNAIMPORT_DNAPARSER_JSONL_HPP_
diff --git a/dynadjust/dynadjust/dnaimport/dnaparser_pimpl.cxx b/dynadjust/dynadjust/dnaimport/dnaparser_pimpl.cxx
index a861f3941..335a6650a 100644
--- a/dynadjust/dynadjust/dnaimport/dnaparser_pimpl.cxx
+++ b/dynadjust/dynadjust/dnaimport/dnaparser_pimpl.cxx
@@ -8,13 +8,13 @@
 #include <include/exception/dnaexception.hpp>
 #include <include/parameters/dnaepsg.hpp>
 #include <dynadjust/dnaimport/dnaparser_pimpl.hxx>
+#include <dynadjust/dnaimport/dnaparser_validators.hpp>
 #include <include/measurement_types/dnastntally.hpp>
 
-#include <include/io/DynaML-schema.hxx>
-
 using namespace dynadjust::measurements;
 using namespace dynadjust::epsg;
 using namespace dynadjust::exception;
+using namespace dynadjust::import;
 
 extern MsrTally g_parsemsr_tally;
 extern StnTally g_parsestn_tally;
@@ -169,39 +169,24 @@ void Directions_pimpl::post_Directions(const UINT32& total)
 {
 	if (!_parent_dnaDirectionSet)
 		return;
-	
-	// Is the parent ignored? Add it to the ignored set
+
+	// Always add the direction to the set
+	_parent_dnaDirectionSet->AddDirection(_dnaDirection.get());
+
+	// If the parent is ignored, nothing more to check
 	if (_parent_dnaDirectionSet->GetIgnore())
-	{
-		_parent_dnaDirectionSet->AddDirection(_dnaDirection.get());
 		return;
-	}
 
-	// Is the parent not ignored, and the direction not ignored? Add it to the set
+	// Count non-ignored directions for the tally
 	if (_dnaDirection->NotIgnored())
 	{
-		_parent_dnaDirectionSet->AddDirection(_dnaDirection.get());
-        g_parsemsr_tally.D++;
+		g_parsemsr_tally.D++;
 		return;
 	}
 
-	// At this point, the parent is not ignored, but a sub direction is.
-	// Test if this ignored sub direction will lead to a false direction
-	UINT32 t = _parent_dnaDirectionSet->GetTotal() - 1;
-
-	if (t == 0)
-	{
-		std::stringstream ss, ss2;
-		ss << 
-			"<Directions>...</Directions>',  total of " << total << " element(s)" << std::endl <<
-			"  - found 0 <Directions>, or there aren't any non-ignored directions in the set. '";
-		ss2 << " ~ <Total>" << total << "</Total>";
-		throw ::xsd::cxx::parser::expected_element< char >(
-			ss.str(), ss2.str());
-	}
-
-	_parent_dnaDirectionSet->AddDirection(_dnaDirection.get());
-	
+	// Direction is ignored — validate this doesn't leave the set empty
+	ValidateDirectionInSet(_parent_dnaDirectionSet,
+		true, total);
 }
 
 // DnaMeasurement_pimpl
@@ -219,8 +204,7 @@ void DnaMeasurement_pimpl::pre()
 
 void DnaMeasurement_pimpl::Type(const ::std::string& Type)
 {
-	if (Type.empty())
-		throw XMLInteropException("\"Type\" element cannot be empty.", 0);
+	char cType = ValidateMeasurementType(Type);
 
 	std::string frame, epoch;
 
@@ -234,104 +218,8 @@ void DnaMeasurement_pimpl::Type(const ::std::string& Type)
 	else
 		epoch = _fileEpoch;
 
-	char cType = (Type.c_str())[0];
-	switch (cType) {
-	case 'A': // Horizontal angle
-		g_parsemsr_tally.A++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaAngle);
-		break;
-	case 'B': // Geodetic azimuth
-		g_parsemsr_tally.B++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaAzimuth);
-		break;
-	case 'C': // Chord dist
-		g_parsemsr_tally.C++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaDistance);
-		break;
-	case 'D': // Direction set
-		//g_parsemsr_tally.D++;  See post_Directions()
-		_dnaCurrentMsr.reset(new CDnaDirectionSet(++(*(_pclusterID))));
-		break;
-	case 'E': // Ellipsoid arc
-		g_parsemsr_tally.E++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaDistance);
-		break;
-	case 'G': // GPS Baseline (treat as single-baseline cluster)
-	case 'X': // GPS Baseline cluster
-		_dnaCurrentMsr.reset(new CDnaGpsBaselineCluster(++(*(_pclusterID)), frame, epoch));
-		break;
-	case 'H': // Orthometric height
-		g_parsemsr_tally.H++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaHeight);
-		break;
-	case 'I': // Astronomic latitude
-		g_parsemsr_tally.I++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaCoordinate);
-		break;
-	case 'J': // Astronomic longitude
-		g_parsemsr_tally.J++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaCoordinate);
-		break;
-	case 'K': // Astronomic azimuth
-		g_parsemsr_tally.K++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaAzimuth);
-		break;
-	case 'L': // Level difference
-		g_parsemsr_tally.L++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaHeightDifference);
-		break;
-	case 'M': // MSL arc
-		g_parsemsr_tally.M++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaDistance);
-		break;
-	case 'P': // Geodetic latitude
-		g_parsemsr_tally.P++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaCoordinate);
-		break;
-	case 'Q': // Geodetic longitude
-		g_parsemsr_tally.Q++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaCoordinate);
-		break;
-	case 'R': // Ellipsoidal height
-		g_parsemsr_tally.R++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaHeight);
-		break;
-	case 'S': // Slope distance
-		g_parsemsr_tally.S++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaDistance);
-		break;
-	case 'V': // Zenith distance
-		g_parsemsr_tally.V++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaDirection);
-		break;
-	case 'Y': // GPS point cluster
-		_dnaCurrentMsr.reset(new CDnaGpsPointCluster(++(*(_pclusterID)), _referenceframe, _epoch));
-		break;
-	case 'Z': // Vertical angle
-		g_parsemsr_tally.Z++;
-		*(_pMeasurementCount) += 1;
-		_dnaCurrentMsr.reset(new CDnaDirection);
-		break;
-	default:
-		std::stringstream ss;
-		ss << "Unknown measurement type: " << Type;
-		throw XMLInteropException(ss.str(), 0);
-	}
+	_dnaCurrentMsr = CreateMeasurement(cType, _pclusterID,
+		*(_pMeasurementCount), g_parsemsr_tally, frame, epoch);
 	_dnaCurrentMsr->SetType(Type);
 }
 
@@ -354,39 +242,18 @@ void DnaMeasurement_pimpl::First(const ::std::string& First)
 	if (!_dnaCurrentMsr)
 		throw XMLInteropException("\"Type\" element must be the first element within \"DnaMeasurement\".", 0);
 
-	if (First.empty())
-		throw XMLInteropException("\"First\" element cannot be empty.", 0);
+	ValidateFirst(First);
 	_dnaCurrentMsr->SetFirst(First);
 }
 
-void DnaMeasurement_pimpl::Second(const ::std::string& Second) 
+void DnaMeasurement_pimpl::Second(const ::std::string& Second)
 {
 	if (!_dnaCurrentMsr)
 		throw XMLInteropException("\"Type\" element must be the first element within \"DnaMeasurement\".", 0);
 
-	switch (_dnaCurrentMsr->GetTypeC()) {
-	case 'A': // Horizontal angle
-	case 'B': // Geodetic azimuth
-	case 'K': // Astronomic azimuth
-	case 'C': // Chord dist
-	case 'E': // Ellipsoid arc
-	case 'M': // MSL arc
-	case 'S': // Slope distance
-	case 'D': // Direction set
-	case 'G': // GPS Baseline
-	case 'L': // Level difference
-	case 'V': // Zenith distance
-	case 'Z': // Vertical angle
-	case 'X': // GPS Baseline cluster
-		if (Second.empty())
-		{
-			std::stringstream ss;
-			ss << "\"Second\" element cannot be empty for measurement type " << _dnaCurrentMsr->GetTypeC() << 
-				" (first station: " << _dnaCurrentMsr->GetFirst() << ").";
-			throw XMLInteropException(ss.str(), 0);
-		}
+	ValidateSecond(Second, _dnaCurrentMsr->GetTypeC(), _dnaCurrentMsr->GetFirst());
+	if (TypeRequiresSecond(_dnaCurrentMsr->GetTypeC()))
 		_dnaCurrentMsr->SetTarget(Second);
-	}
 }
 
 void DnaMeasurement_pimpl::Third(const ::std::string& Third)
@@ -394,17 +261,7 @@ void DnaMeasurement_pimpl::Third(const ::std::string& Third)
 	if (!_dnaCurrentMsr)
 		throw XMLInteropException("\"Type\" element must be the first element within \"DnaMeasurement\".", 0);
 
-	switch (_dnaCurrentMsr->GetTypeC()) {
-	case 'A': // Horizontal angle
-		if (Third.empty())
-		{
-			std::stringstream ss;
-			ss << "\"Third\" element cannot be empty for measurement type " << _dnaCurrentMsr->GetTypeC() << 
-				" (first station: " << _dnaCurrentMsr->GetFirst() << ").";
-			throw XMLInteropException(ss.str(), 0);
-		}
-	}
-
+	ValidateThird(Third, _dnaCurrentMsr->GetTypeC(), _dnaCurrentMsr->GetFirst());
 	_dnaCurrentMsr->SetTarget2(Third);
 }
 
@@ -413,33 +270,7 @@ void DnaMeasurement_pimpl::Value(const ::std::string& Value)
 	if (!_dnaCurrentMsr)
 		throw XMLInteropException("\"Type\" element must be the first element within \"DnaMeasurement\".", 0);
 
-	switch (_dnaCurrentMsr->GetTypeC()) {
-	case 'A': // Horizontal angle
-	case 'B': // Geodetic azimuth
-	case 'K': // Astronomic azimuth
-	case 'C': // Chord dist
-	case 'E': // Ellipsoid arc
-	case 'M': // MSL arc
-	case 'S': // Slope distance
-	case 'D': // Direction set
-	case 'H': // Orthometric height
-	case 'R': // Ellipsoidal height
-	case 'I': // Astronomic latitude
-	case 'J': // Astronomic longitude
-	case 'P': // Geodetic latitude
-	case 'Q': // Geodetic longitude
-	case 'L': // Level difference
-	case 'V': // Zenith distance
-	case 'Z': // Vertical angle
-		if (Value.empty())
-		{
-			std::stringstream ss;
-			ss << "\"Value\" element cannot be empty for measurement type " << _dnaCurrentMsr->GetTypeC() << 
-				" (first station: " << _dnaCurrentMsr->GetFirst() << ").";
-			throw XMLInteropException(ss.str(), 0);
-		}
-	}
-
+	ValidateValue(Value, _dnaCurrentMsr->GetTypeC(), _dnaCurrentMsr->GetFirst());
 	_dnaCurrentMsr->SetValue(Value);
 }
 
@@ -448,41 +279,8 @@ void DnaMeasurement_pimpl::StdDev(const ::std::string& StdDev)
 	if (!_dnaCurrentMsr)
 		throw XMLInteropException("\"Type\" element must be the first element within \"DnaMeasurement\".", 0);
 
-	switch (_dnaCurrentMsr->GetTypeC()) {
-	case 'A': // Horizontal angle
-	case 'B': // Geodetic azimuth
-	case 'K': // Astronomic azimuth
-	case 'C': // Chord dist
-	case 'E': // Ellipsoid arc
-	case 'M': // MSL arc
-	case 'S': // Slope distance
-	case 'D': // Direction set
-	case 'H': // Orthometric height
-	case 'R': // Ellipsoidal height
-	case 'I': // Astronomic latitude
-	case 'J': // Astronomic longitude
-	case 'P': // Geodetic latitude
-	case 'Q': // Geodetic longitude
-	case 'L': // Level difference
-	case 'V': // Zenith distance
-	case 'Z': // Vertical angle
-		if (StdDev.empty())
-		{
-			std::stringstream ss;
-			ss << "\"StdDev\" element cannot be empty for " << _dnaCurrentMsr->GetTypeC() << " measurements (first station: " << _dnaCurrentMsr->GetFirst() << ").";
-			throw XMLInteropException(ss.str(), 0);
-		}
-
-		if (DoubleFromString<double>(StdDev) < PRECISION_1E25)
-		{
-			std::stringstream ss;
-			ss << "\"StdDev\" element cannot contain a zero or negative value for " << _dnaCurrentMsr->GetTypeC() << " measurements (first station: " << _dnaCurrentMsr->GetFirst() << ").";
-			throw XMLInteropException(ss.str(), 0);
-		}
-	}
-
+	ValidateStdDev(StdDev, _dnaCurrentMsr->GetTypeC(), _dnaCurrentMsr->GetFirst());
 	_dnaCurrentMsr->SetStdDev(StdDev);
-
 }
 
 void DnaMeasurement_pimpl::InstHeight(const ::std::string& InstHeight)
@@ -524,27 +322,9 @@ void DnaMeasurement_pimpl::Total(const ::std::string& Total)
 	if (!_dnaCurrentMsr)
 		throw XMLInteropException("\"Type\" element must be the first element within \"DnaMeasurement\".", 0);
 
-	switch (_dnaCurrentMsr->GetTypeC()) {
-	case 'D': // Direction set
-	case 'G': // Single Baseline (treat as a single-baseline cluster)
-	case 'X': // GPS Baseline cluster
-	case 'Y': // GPS point cluster
-		if (Total.empty())
-			throw XMLInteropException("\"Total\" element cannot be empty.", 0);
-	}
-
+	ValidateTotal(Total, _dnaCurrentMsr->GetTypeC());
 	_dnaCurrentMsr->SetTotal(Total);
-
-	const UINT32 measCount(LongFromString<UINT32>(Total));
-	_total = measCount;
-
-	switch (_dnaCurrentMsr->GetTypeC()) 
-	{
-	case 'X': // GPS Baseline cluster
-		if (measCount < 2)
-			if (_preferSingleXasG)
-				_dnaCurrentMsr->SetType("G");
-	}
+	_total = LongFromString<UINT32>(Total);
 }
 
 void DnaMeasurement_pimpl::Directions()
@@ -556,10 +336,7 @@ void DnaMeasurement_pimpl::Vscale(const ::std::string& Vscale)
 	if (!_dnaCurrentMsr)
 		throw XMLInteropException("\"Type\" element must be the first element within \"DnaMeasurement\".", 0);
 
-	if (Vscale.empty())
-		_dnaCurrentMsr->SetVscale("1");
-	else
-		_dnaCurrentMsr->SetVscale(Vscale);
+	_dnaCurrentMsr->SetVscale(DefaultScale(Vscale));
 }
 
 void DnaMeasurement_pimpl::Epoch(const ::std::string& Epoch)
@@ -595,6 +372,30 @@ void DnaMeasurement_pimpl::Epoch(const ::std::string& Epoch)
 	}
 }
 
+void DnaMeasurement_pimpl::EpochOfObservation(const ::std::string& EpochOfObservation)
+{
+	if (!_dnaCurrentMsr)
+		throw XMLInteropException("\"Type\" element must be the first element within \"DnaMeasurement\".", 0);
+
+	try
+	{
+		if (EpochOfObservation.empty())
+			return;
+
+		_dnaCurrentMsr->SetObservationEpoch(EpochOfObservation);
+	}
+	catch (const std::runtime_error& e) {
+		std::stringstream ss("");
+		ss << e.what();
+		ss << "    - Measurement type:    " << _dnaCurrentMsr->GetType() << std::endl <<
+			"    - From:                " << _dnaCurrentMsr->GetFirst() << std::endl <<
+			"    - To:                  " << _dnaCurrentMsr->GetTarget() << std::endl <<
+			"    - Reference frame:     " << _dnaCurrentMsr->GetReferenceFrame() << std::endl <<
+			"    - Epoch of observation: " << EpochOfObservation << std::endl;
+		throw XMLInteropException(ss.str(), 0);
+	}
+}
+
 void DnaMeasurement_pimpl::ReferenceFrame(const ::std::string& ReferenceFrame)
 {
 	if (!_dnaCurrentMsr)
@@ -644,10 +445,7 @@ void DnaMeasurement_pimpl::Hscale(const ::std::string& Hscale)
 	if (!_dnaCurrentMsr)
 		throw XMLInteropException("\"Type\" element must be the first element within \"DnaMeasurement\".", 0);
 
-	if (Hscale.empty())
-		_dnaCurrentMsr->SetHscale("1");
-	else
-		_dnaCurrentMsr->SetHscale(Hscale);
+	_dnaCurrentMsr->SetHscale(DefaultScale(Hscale));
 }
 
 
@@ -656,10 +454,7 @@ void DnaMeasurement_pimpl::Lscale(const ::std::string& Lscale)
 	if (!_dnaCurrentMsr)
 		throw XMLInteropException("\"Type\" element must be the first element within \"DnaMeasurement\".", 0);
 
-	if (Lscale.empty())
-		_dnaCurrentMsr->SetLscale("1");
-	else
-		_dnaCurrentMsr->SetLscale(Lscale);
+	_dnaCurrentMsr->SetLscale(DefaultScale(Lscale));
 }
 
 
@@ -668,10 +463,7 @@ void DnaMeasurement_pimpl::Pscale(const ::std::string& Pscale)
 	if (!_dnaCurrentMsr)
 		throw XMLInteropException("\"Type\" element must be the first element within \"DnaMeasurement\".", 0);
 
-	if (Pscale.empty())
-		_dnaCurrentMsr->SetPscale("1");
-	else
-		_dnaCurrentMsr->SetPscale(Pscale);
+	_dnaCurrentMsr->SetPscale(DefaultScale(Pscale));
 }
 
 
@@ -729,140 +521,13 @@ void DnaMeasurement_pimpl::post_DnaMeasurement()
 	if (!_dnaCurrentMsr)
 		throw XMLInteropException("\"Type\" element must be the first element within \"DnaMeasurement\".", 0);
 
-	UINT32 total, found;
-
-	// Is the direction set empty and ignored?
-	// If so, do nothing (an invalid measurement).
-	switch (_dnaCurrentMsr->GetTypeC())
-	{
-	case 'D':
-		total = _dnaCurrentMsr->GetTotal();
-		if (total == 0 && _dnaCurrentMsr->GetIgnore())
-			return;
-		break;
-	}
+	// Ignored empty direction set — skip silently
+	if (_dnaCurrentMsr->GetTypeC() == 'D' &&
+		_dnaCurrentMsr->GetTotal() == 0 && _dnaCurrentMsr->GetIgnore())
+		return;
 
-	// Now that the measurement has completed, capture all essential elements
 	_vParentMsrs->push_back(_dnaCurrentMsr);
-
-	// set "First" to be that of the first in the set
-	switch (_dnaCurrentMsr->GetTypeC())
-	{
-	case 'D':
-	
-		total = _dnaCurrentMsr->GetTotal();
-		found = static_cast<UINT32>(_dnaCurrentMsr->GetDirections_ptr()->size());
-		if (total != found)
-		{
-			std::stringstream ss, ss2;
-			ss <<
-				"<Directions>...</Directions>',  total of " << total << " element(s)" << std::endl <<
-				"  - found " << found << " <Directions> in the set. '";
-			ss2 << " ~ <Total>" << total << "</Total>";
-			throw ::xsd::cxx::parser::expected_element< char >(
-				ss.str(), ss2.str());
-		}
-
-		found = 0;
-
-		// Test for non-ignored measurements
-		for_each(_dnaCurrentMsr->GetDirections_ptr()->begin(),
-			_dnaCurrentMsr->GetDirections_ptr()->end(),
-			[this, &found](CDnaDirection& d) {
-				if (d.NotIgnored())
-					found++;
-			});
-
-		if (found == 0 && _dnaCurrentMsr->NotIgnored())
-		{
-			std::stringstream ss, ss2;
-			ss <<
-				"<Directions>...</Directions>',  total of " << total << " element(s)" << std::endl <<
-				"  - There aren't any non-ignored directions in the set. ";
-			ss2 << " ~ <Total>" << total << "</Total>";
-			throw ::xsd::cxx::parser::expected_element< char >(
-				ss.str(), ss2.str());
-		}
-
-		_dnaCurrentMsr->SetNonIgnoredDirns(found);
-		
-		// Okay, capture all the elements for this direction set
-		for_each(_dnaCurrentMsr->GetDirections_ptr()->begin(),
-			_dnaCurrentMsr->GetDirections_ptr()->end(),
-			[this](CDnaDirection& d) {
-				d.SetType(_dnaCurrentMsr->GetType());
-				d.SetFirst(_dnaCurrentMsr->GetFirst());
-				// This is a target direction, so set zero recorded total so as to
-				// distinguish this direction from the RO, for which the recorded
-				// total will be the number of target directions
-				d.SetRecordedTotal(0);
-			});
-
-		break;
-	
-	case 'G':
-	case 'X':
-	
-		total = _dnaCurrentMsr->GetTotal();
-		found = static_cast<UINT32>(_dnaCurrentMsr->GetBaselines_ptr()->size());
-		if (total != found)
-		{
-			std::stringstream ss, ss2;
-			ss <<
-				"<GPSBaseline>...</GPSBaseline>',  total of " << total << " element(s)" << std::endl <<
-				"  - found " << found << " <GPSBaseline> in the set. '";
-			ss2 << " ~ <Total>" << total << "</Total>";
-			throw ::xsd::cxx::parser::expected_element< char >(
-				ss.str(), ss2.str());
-		}
-
-		// Okay, capture all the elements for this baseline (cluster)
-		for_each(_dnaCurrentMsr->GetBaselines_ptr()->begin(),
-			_dnaCurrentMsr->GetBaselines_ptr()->end(),
-			[this](CDnaGpsBaseline& b) {
-				b.SetIgnore(_dnaCurrentMsr->GetIgnore());
-				b.SetRecordedTotal(_dnaCurrentMsr->GetTotal());
-
-				b.SetPscale(_dnaCurrentMsr->GetPscale());
-				b.SetLscale(_dnaCurrentMsr->GetLscale());
-				b.SetHscale(_dnaCurrentMsr->GetHscale());
-				b.SetVscale(_dnaCurrentMsr->GetVscale());
-			});
-
-		break;
-	
-	case 'Y':
-	
-		total = _dnaCurrentMsr->GetTotal();
-		found = static_cast<UINT32>(_dnaCurrentMsr->GetPoints_ptr()->size());
-		if (total != found)
-		{
-			std::stringstream ss, ss2;
-			ss <<
-				"<Clusterpoint>...</Clusterpoint>',  total of " << total << " element(s)" << std::endl <<
-				"  - found " << found << " <Clusterpoint> in the set. '";
-			ss2 << " ~ <Total>" << total << "</Total>";
-			throw ::xsd::cxx::parser::expected_element< char >(
-				ss.str(), ss2.str());
-		}
-
-		// Okay, capture all the elements for this point cluster
-		for_each(_dnaCurrentMsr->GetPoints_ptr()->begin(),
-			_dnaCurrentMsr->GetPoints_ptr()->end(),
-			[this](CDnaGpsPoint& p) {
-				p.SetIgnore(_dnaCurrentMsr->GetIgnore());
-				p.SetCoordType(_dnaCurrentMsr->GetCoordType());
-				p.SetRecordedTotal(_dnaCurrentMsr->GetTotal());
-
-				p.SetPscale(_dnaCurrentMsr->GetPscale());
-				p.SetLscale(_dnaCurrentMsr->GetLscale());
-				p.SetHscale(_dnaCurrentMsr->GetHscale());
-				p.SetVscale(_dnaCurrentMsr->GetVscale());
-			});
-		break;
-	
-	}
-
+	FinaliseMeasurement(_dnaCurrentMsr, _preferSingleXasG);
 }
 
 // DnaStation_pimpl
@@ -888,19 +553,16 @@ void DnaStation_pimpl::pre()
 
 void DnaStation_pimpl::Name(const ::std::string& Name)
 {
-	if (Name.empty())
-		throw XMLInteropException("DnaStation \"Name\" element cannot be empty.", 0);
+	ValidateStationName(Name);
 	_dnaCurrentStn->SetName(Name);
 }
 
 
 void DnaStation_pimpl::Constraints(const ::std::string& Constraints)
 {
-	if (Constraints.empty())	
-		_dnaCurrentStn->SetConstraints("FFF");
-	else
-		_dnaCurrentStn->SetConstraints(Constraints);
-	g_parsestn_tally.addstation(Constraints);
+	std::string c = DefaultConstraints(Constraints);
+	_dnaCurrentStn->SetConstraints(c);
+	g_parsestn_tally.addstation(c);
 }
 
 
@@ -915,8 +577,7 @@ void DnaStation_pimpl::StationCoord()
 
 void DnaStation_pimpl::Description(const ::std::string& Description)
 {
-	_dnaCurrentStn->SetDescription(
-		findandreplace((const ::std::string&)Description, (const ::std::string&)"&", (const ::std::string&)"and"));
+	_dnaCurrentStn->SetDescription(SanitiseDescription(Description));
 }
 
 void DnaStation_pimpl::post_DnaStation()
@@ -942,6 +603,19 @@ DnaXmlFormat_pimpl::DnaXmlFormat_pimpl(std::ifstream* is, PUINT32 clusterID, con
 	_referenceframe = referenceframe;
 	_epoch = epoch;
 
+	// Initialise file EPSG and epoch from the default reference frame.
+	// Previously these were set by the XSD attribute defaults during
+	// validation.  With dont_validate, the attribute parsers are only
+	// called when the attributes are present in the XML, so we need
+	// sensible fallbacks.
+	try {
+		_fileEpsg = epsgStringFromName<std::string>(_referenceframe);
+	}
+	catch (...) {
+		_fileEpsg.clear();
+	}
+	_fileEpoch = epoch;
+
 	// capture first file flag
 	_firstFile = firstFile;
 
diff --git a/dynadjust/dynadjust/dnaimport/dnaparser_pimpl.hxx b/dynadjust/dynadjust/dnaimport/dnaparser_pimpl.hxx
index 7f66ecd63..58d1e8213 100644
--- a/dynadjust/dynadjust/dnaimport/dnaparser_pimpl.hxx
+++ b/dynadjust/dynadjust/dnaimport/dnaparser_pimpl.hxx
@@ -91,6 +91,7 @@ public:
 	virtual void Directions ();
 	virtual void Vscale (const ::std::string&);
 	virtual void Epoch (const ::std::string&);
+	virtual void EpochOfObservation (const ::std::string&);
 	virtual void ReferenceFrame (const ::std::string&);
 	virtual void GPSBaseline ();
 	virtual void Hscale (const ::std::string&);
diff --git a/dynadjust/dynadjust/dnaimport/dnaparser_pskel.cxx b/dynadjust/dynadjust/dnaimport/dnaparser_pskel.cxx
index 27cdc8667..b56389d46 100644
--- a/dynadjust/dynadjust/dnaimport/dnaparser_pskel.cxx
+++ b/dynadjust/dynadjust/dnaimport/dnaparser_pskel.cxx
@@ -38,8 +38,6 @@
 
 #include <dynadjust/dnaimport/dnaparser_pskel.hxx>
 
-#include <include/io/DynaML-schema.hxx>
-
 using namespace dynadjust::measurements;
 
 // Clusterpoint_pskel
@@ -260,6 +258,11 @@ void DnaMeasurement_pskel::Epoch_parser (::xml_schema::string_pskel& p)
 	this->Epoch_parser_ = &p;
 }
 
+void DnaMeasurement_pskel::EpochOfObservation_parser (::xml_schema::string_pskel& p)
+{
+	this->EpochOfObservation_parser_ = &p;
+}
+
 void DnaMeasurement_pskel::GPSBaseline_parser (::GPSBaseline_pskel& p)
 {
 	this->GPSBaseline_parser_ = &p;
@@ -320,6 +323,7 @@ void DnaMeasurement_pskel::parsers (
 	::Directions_pskel& Directions,
 	::xml_schema::string_pskel& Vscale,
 	::xml_schema::string_pskel& Epoch,
+	::xml_schema::string_pskel& EpochOfObservation,
 	::xml_schema::string_pskel& ReferenceFrame,
 	::GPSBaseline_pskel& GPSBaseline,
 	::xml_schema::string_pskel& Hscale,
@@ -345,6 +349,7 @@ void DnaMeasurement_pskel::parsers (
 	this->Directions_parser_ = &Directions;
 	this->Vscale_parser_ = &Vscale;
 	this->Epoch_parser_ = &Epoch;
+	this->EpochOfObservation_parser_ = &EpochOfObservation;
 	this->ReferenceFrame_parser_ = &ReferenceFrame;
 	this->GPSBaseline_parser_ = &GPSBaseline;
 	this->Hscale_parser_ = &Hscale;
@@ -372,6 +377,7 @@ DnaMeasurement_pskel::DnaMeasurement_pskel ()
 	Directions_parser_ (0),
 	Vscale_parser_ (0),
 	Epoch_parser_ (0),
+	EpochOfObservation_parser_ (0),
 	ReferenceFrame_parser_ (0),
 	GPSBaseline_parser_ (0),
 	Hscale_parser_ (0),
@@ -1328,6 +1334,10 @@ void DnaMeasurement_pskel::Epoch (const ::std::string&)
 {
 }
 
+void DnaMeasurement_pskel::EpochOfObservation (const ::std::string&)
+{
+}
+
 void DnaMeasurement_pskel::ReferenceFrame (const ::std::string&)
 {
 }
@@ -1515,6 +1525,16 @@ bool DnaMeasurement_pskel::_start_element_impl (const ::xml_schema::ro_string& n
 		return true;
 	}
 
+	if (n == "EpochOfObservation" && ns.empty ())
+	{
+		this->::xml_schema::complex_content::context_.top ().parser_ = this->EpochOfObservation_parser_;
+
+		if (this->EpochOfObservation_parser_)
+			this->EpochOfObservation_parser_->pre ();
+
+		return true;
+	}
+
 	if (n == "ReferenceFrame" && ns.empty ())
 	{
 		this->::xml_schema::complex_content::context_.top ().parser_ = this->ReferenceFrame_parser_;
@@ -1739,6 +1759,14 @@ bool DnaMeasurement_pskel::_end_element_impl (const ::xml_schema::ro_string& ns,
 		return true;
 	}
 
+	if (n == "EpochOfObservation" && ns.empty ())
+	{
+		if (this->EpochOfObservation_parser_)
+			this->EpochOfObservation (this->EpochOfObservation_parser_->post_string ());
+
+		return true;
+	}
+
 	if (n == "ReferenceFrame" && ns.empty ())
 	{
 		if (this->ReferenceFrame_parser_)
diff --git a/dynadjust/dynadjust/dnaimport/dnaparser_pskel.hxx b/dynadjust/dynadjust/dnaimport/dnaparser_pskel.hxx
index 79911766b..30fdd8643 100644
--- a/dynadjust/dynadjust/dnaimport/dnaparser_pskel.hxx
+++ b/dynadjust/dynadjust/dnaimport/dnaparser_pskel.hxx
@@ -467,6 +467,7 @@ public:
 	virtual void Directions ();
 	virtual void Vscale (const ::std::string&);
 	virtual void Epoch (const ::std::string&);
+	virtual void EpochOfObservation (const ::std::string&);
 	virtual void ReferenceFrame (const ::std::string&);
 	virtual void GPSBaseline ();
 	virtual void Hscale (const ::std::string&);
@@ -558,6 +559,7 @@ public:
 	void Directions_parser (::Directions_pskel&);
 	void Vscale_parser (::xml_schema::string_pskel&);
 	void Epoch_parser (::xml_schema::string_pskel&);
+	void EpochOfObservation_parser (::xml_schema::string_pskel&);
 	void ReferenceFrame_parser (::xml_schema::string_pskel&);
 	void GPSBaseline_parser (::GPSBaseline_pskel&);
 	void Hscale_parser (::xml_schema::string_pskel&);
@@ -583,6 +585,7 @@ public:
 			::Directions_pskel& /* Directions */,
 			::xml_schema::string_pskel& /* Vscale */,
 			::xml_schema::string_pskel& /* Epoch */,
+			::xml_schema::string_pskel& /* EpochOfObservation */,
 			::xml_schema::string_pskel& /* ReferenceFrame */,
 			::GPSBaseline_pskel& /* GPSBaseline */,
 			::xml_schema::string_pskel& /* Hscale */,
@@ -630,6 +633,7 @@ protected:
 	::Directions_pskel* Directions_parser_;
 	::xml_schema::string_pskel* Vscale_parser_;
 	::xml_schema::string_pskel* Epoch_parser_;
+	::xml_schema::string_pskel* EpochOfObservation_parser_;
 	::xml_schema::string_pskel* ReferenceFrame_parser_;
 	::GPSBaseline_pskel* GPSBaseline_parser_;
 	::xml_schema::string_pskel* Hscale_parser_;
diff --git a/dynadjust/dynadjust/dnaimport/dnaparser_validators.cpp b/dynadjust/dynadjust/dnaimport/dnaparser_validators.cpp
new file mode 100644
index 000000000..4850c17e8
--- /dev/null
+++ b/dynadjust/dynadjust/dnaimport/dnaparser_validators.cpp
@@ -0,0 +1,403 @@
+//============================================================================
+// Name         : dnaparser_validators.cpp
+// Author       : Dale Roberts <dale.o.roberts@gmail.com>
+// Copyright    : Copyright 2025 Geoscience Australia
+//
+//                Licensed under the Apache License, Version 2.0 (the "License");
+//                you may not use this file except in compliance with the License.
+//                You may obtain a copy of the License at
+//
+//                http ://www.apache.org/licenses/LICENSE-2.0
+//
+//                Unless required by applicable law or agreed to in writing, software
+//                distributed under the License is distributed on an "AS IS" BASIS,
+//                WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//                See the License for the specific language governing permissions and
+//                limitations under the License.
+//
+// Description  : Shared validation, factory and finalisation functions for
+//                DynaML parsing.
+//============================================================================
+
+#include <sstream>
+#include <string>
+
+#include <dynadjust/dnaimport/dnaparser_validators.hpp>
+#include <include/exception/dnaexception.hpp>
+#include <include/functions/dnastringfuncs.hpp>
+
+using dynadjust::exception::XMLInteropException;
+using dynadjust::measurements::CDnaAngle;
+using dynadjust::measurements::CDnaAzimuth;
+using dynadjust::measurements::CDnaCoordinate;
+using dynadjust::measurements::CDnaDirection;
+using dynadjust::measurements::CDnaDirectionSet;
+using dynadjust::measurements::CDnaDistance;
+using dynadjust::measurements::CDnaGpsBaselineCluster;
+using dynadjust::measurements::CDnaGpsPointCluster;
+using dynadjust::measurements::CDnaGpsBaseline;
+using dynadjust::measurements::CDnaGpsPoint;
+using dynadjust::measurements::CDnaHeight;
+using dynadjust::measurements::CDnaHeightDifference;
+
+namespace dynadjust {
+namespace import {
+
+bool TypeRequiresSecond(char type_c) {
+  switch (type_c) {
+  case 'A': case 'B': case 'K':
+  case 'C': case 'E': case 'M': case 'S':
+  case 'D': case 'G': case 'L':
+  case 'V': case 'Z': case 'X':
+    return true;
+  default:
+    return false;
+  }
+}
+
+bool TypeRequiresValueStdDev(char type_c) {
+  switch (type_c) {
+  case 'A': case 'B': case 'K':
+  case 'C': case 'E': case 'M': case 'S':
+  case 'D':
+  case 'H': case 'R':
+  case 'I': case 'J': case 'P': case 'Q':
+  case 'L': case 'V': case 'Z':
+    return true;
+  default:
+    return false;
+  }
+}
+
+char ValidateMeasurementType(const std::string& type) {
+  if (type.empty()) {
+    throw XMLInteropException("\"Type\" element cannot be empty.", 0);
+  }
+  char c = type[0];
+  switch (c) {
+  case 'A': case 'B': case 'C': case 'D': case 'E':
+  case 'G': case 'H': case 'I': case 'J': case 'K':
+  case 'L': case 'M': case 'P': case 'Q': case 'R':
+  case 'S': case 'V': case 'X': case 'Y': case 'Z':
+    return c;
+  default:
+    std::stringstream ss;
+    ss << "Unknown measurement type: " << type;
+    throw XMLInteropException(ss.str(), 0);
+  }
+}
+
+void ValidateFirst(const std::string& first) {
+  if (first.empty()) {
+    throw XMLInteropException("\"First\" element cannot be empty.", 0);
+  }
+}
+
+void ValidateSecond(const std::string& second, char type_c,
+                    const std::string& first) {
+  if (TypeRequiresSecond(type_c) && second.empty()) {
+    std::stringstream ss;
+    ss << "\"Second\" element cannot be empty for measurement type "
+       << type_c << " (first station: " << first << ").";
+    throw XMLInteropException(ss.str(), 0);
+  }
+}
+
+void ValidateThird(const std::string& third, char type_c,
+                   const std::string& first) {
+  if (type_c == 'A' && third.empty()) {
+    std::stringstream ss;
+    ss << "\"Third\" element cannot be empty for measurement type "
+       << type_c << " (first station: " << first << ").";
+    throw XMLInteropException(ss.str(), 0);
+  }
+}
+
+void ValidateValue(const std::string& value, char type_c,
+                   const std::string& first) {
+  if (TypeRequiresValueStdDev(type_c) && value.empty()) {
+    std::stringstream ss;
+    ss << "\"Value\" element cannot be empty for measurement type "
+       << type_c << " (first station: " << first << ").";
+    throw XMLInteropException(ss.str(), 0);
+  }
+}
+
+void ValidateStdDev(const std::string& stddev, char type_c,
+                    const std::string& first) {
+  if (!TypeRequiresValueStdDev(type_c)) {
+    return;
+  }
+  if (stddev.empty()) {
+    std::stringstream ss;
+    ss << "\"StdDev\" element cannot be empty for " << type_c
+       << " measurements (first station: " << first << ").";
+    throw XMLInteropException(ss.str(), 0);
+  }
+  if (DoubleFromString<double>(stddev) < PRECISION_1E25) {
+    std::stringstream ss;
+    ss << "\"StdDev\" element cannot contain a zero or negative value for "
+       << type_c << " measurements (first station: " << first << ").";
+    throw XMLInteropException(ss.str(), 0);
+  }
+}
+
+void ValidateTotal(const std::string& total, char type_c) {
+  switch (type_c) {
+  case 'D': case 'G': case 'X': case 'Y':
+    if (total.empty()) {
+      throw XMLInteropException("\"Total\" element cannot be empty.", 0);
+    }
+  }
+}
+
+void ValidateStationName(const std::string& name) {
+  if (name.empty()) {
+    throw XMLInteropException(
+        "DnaStation \"Name\" element cannot be empty.", 0);
+  }
+}
+
+measurements::dnaMsrPtr CreateMeasurement(
+    char type_c, PUINT32 cluster_id, UINT32& msr_count,
+    measurements::MsrTally& tally, const std::string& frame,
+    const std::string& epoch) {
+  measurements::dnaMsrPtr msr;
+
+  switch (type_c) {
+  case 'A':
+    tally.A++;
+    msr_count++;
+    msr.reset(new CDnaAngle);
+    break;
+  case 'B':
+    tally.B++;
+    msr_count++;
+    msr.reset(new CDnaAzimuth);
+    break;
+  case 'C':
+    tally.C++;
+    msr_count++;
+    msr.reset(new CDnaDistance);
+    break;
+  case 'D':
+    // D tallies are incremented per-direction in post_Directions.
+    msr.reset(new CDnaDirectionSet(++(*cluster_id)));
+    break;
+  case 'E':
+    tally.E++;
+    msr_count++;
+    msr.reset(new CDnaDistance);
+    break;
+  case 'G':
+  case 'X':
+    // G/X tallies are incremented per-component in GPSBaseline X/Y/Z.
+    msr.reset(new CDnaGpsBaselineCluster(++(*cluster_id), frame, epoch));
+    break;
+  case 'H':
+    tally.H++;
+    msr_count++;
+    msr.reset(new CDnaHeight);
+    break;
+  case 'I':
+    tally.I++;
+    msr_count++;
+    msr.reset(new CDnaCoordinate);
+    break;
+  case 'J':
+    tally.J++;
+    msr_count++;
+    msr.reset(new CDnaCoordinate);
+    break;
+  case 'K':
+    tally.K++;
+    msr_count++;
+    msr.reset(new CDnaAzimuth);
+    break;
+  case 'L':
+    tally.L++;
+    msr_count++;
+    msr.reset(new CDnaHeightDifference);
+    break;
+  case 'M':
+    tally.M++;
+    msr_count++;
+    msr.reset(new CDnaDistance);
+    break;
+  case 'P':
+    tally.P++;
+    msr_count++;
+    msr.reset(new CDnaCoordinate);
+    break;
+  case 'Q':
+    tally.Q++;
+    msr_count++;
+    msr.reset(new CDnaCoordinate);
+    break;
+  case 'R':
+    tally.R++;
+    msr_count++;
+    msr.reset(new CDnaHeight);
+    break;
+  case 'S':
+    tally.S++;
+    msr_count++;
+    msr.reset(new CDnaDistance);
+    break;
+  case 'V':
+    tally.V++;
+    msr_count++;
+    msr.reset(new CDnaDirection);
+    break;
+  case 'Y':
+    // Y tallies are incremented per-component in Clusterpoint X/Y/Z.
+    msr.reset(new CDnaGpsPointCluster(++(*cluster_id), frame, epoch));
+    break;
+  case 'Z':
+    tally.Z++;
+    msr_count++;
+    msr.reset(new CDnaDirection);
+    break;
+  }
+
+  return msr;
+}
+
+void FinaliseMeasurement(measurements::dnaMsrPtr& msr,
+                         bool prefer_single_x_as_g) {
+  UINT32 total = 0;
+  UINT32 found = 0;
+
+  switch (msr->GetTypeC()) {
+  case 'D': {
+    total = msr->GetTotal();
+
+    // Ignored empty direction set — skip silently.
+    if (total == 0 && msr->GetIgnore()) {
+      return;
+    }
+
+    found = static_cast<UINT32>(msr->GetDirections_ptr()->size());
+    if (total != found) {
+      std::stringstream ss;
+      ss << "Direction set declares total of " << total
+         << " but found " << found << " directions.";
+      throw XMLInteropException(ss.str(), 0);
+    }
+
+    // Count non-ignored directions.
+    found = 0;
+    for (CDnaDirection& d : *msr->GetDirections_ptr()) {
+      if (d.NotIgnored()) {
+        found++;
+      }
+    }
+
+    if (found == 0 && msr->NotIgnored()) {
+      std::stringstream ss;
+      ss << "Direction set declares total of " << total
+         << " but there aren't any non-ignored directions in the set.";
+      throw XMLInteropException(ss.str(), 0);
+    }
+
+    msr->SetNonIgnoredDirns(found);
+
+    // Propagate parent properties to child directions.
+    for (CDnaDirection& d : *msr->GetDirections_ptr()) {
+      d.SetType(msr->GetType());
+      d.SetFirst(msr->GetFirst());
+      d.SetRecordedTotal(0);
+    }
+    break;
+  }
+
+  case 'G':
+  case 'X': {
+    total = msr->GetTotal();
+    found = static_cast<UINT32>(msr->GetBaselines_ptr()->size());
+    if (total != found) {
+      std::stringstream ss;
+      ss << "GPS baseline cluster declares total of " << total
+         << " but found " << found << " baselines.";
+      throw XMLInteropException(ss.str(), 0);
+    }
+
+    // Promote single-baseline X to G if preferred.
+    if (msr->GetTypeC() == 'X' && total < 2 && prefer_single_x_as_g) {
+      msr->SetType("G");
+    }
+
+    // Propagate parent properties to child baselines.
+    for (CDnaGpsBaseline& b : *msr->GetBaselines_ptr()) {
+      b.SetIgnore(msr->GetIgnore());
+      b.SetRecordedTotal(msr->GetTotal());
+      b.SetPscale(msr->GetPscale());
+      b.SetLscale(msr->GetLscale());
+      b.SetHscale(msr->GetHscale());
+      b.SetVscale(msr->GetVscale());
+    }
+    break;
+  }
+
+  case 'Y': {
+    total = msr->GetTotal();
+    found = static_cast<UINT32>(msr->GetPoints_ptr()->size());
+    if (total != found) {
+      std::stringstream ss;
+      ss << "GPS point cluster declares total of " << total
+         << " but found " << found << " clusterpoints.";
+      throw XMLInteropException(ss.str(), 0);
+    }
+
+    // Propagate parent properties to child points.
+    for (CDnaGpsPoint& p : *msr->GetPoints_ptr()) {
+      p.SetIgnore(msr->GetIgnore());
+      p.SetCoordType(msr->GetCoordType());
+      p.SetRecordedTotal(msr->GetTotal());
+      p.SetPscale(msr->GetPscale());
+      p.SetLscale(msr->GetLscale());
+      p.SetHscale(msr->GetHscale());
+      p.SetVscale(msr->GetVscale());
+    }
+    break;
+  }
+  }
+}
+
+void ValidateDirectionInSet(const measurements::dnaMsrPtr& direction_set,
+                            bool direction_ignored,
+                            UINT32 declared_total) {
+  // If the parent set is ignored, no further checks.
+  if (direction_set->GetIgnore()) {
+    return;
+  }
+
+  // If the direction itself is not ignored, no problem.
+  if (!direction_ignored) {
+    return;
+  }
+
+  // Ignoring this direction — check it doesn't leave the set empty.
+  UINT32 remaining = direction_set->GetTotal() - 1;
+  if (remaining == 0) {
+    std::stringstream ss;
+    ss << "Direction set declares total of " << declared_total
+       << " but there aren't any non-ignored directions in the set.";
+    throw XMLInteropException(ss.str(), 0);
+  }
+}
+
+std::string DefaultConstraints(const std::string& constraints) {
+  return constraints.empty() ? "FFF" : constraints;
+}
+
+std::string DefaultScale(const std::string& scale) {
+  return scale.empty() ? "1" : scale;
+}
+
+std::string SanitiseDescription(const std::string& desc) {
+  return findandreplace(desc, std::string("&"), std::string("and"));
+}
+
+}  // namespace import
+}  // namespace dynadjust
diff --git a/dynadjust/dynadjust/dnaimport/dnaparser_validators.hpp b/dynadjust/dynadjust/dnaimport/dnaparser_validators.hpp
new file mode 100644
index 000000000..05c3cd24f
--- /dev/null
+++ b/dynadjust/dynadjust/dnaimport/dnaparser_validators.hpp
@@ -0,0 +1,104 @@
+//============================================================================
+// Name         : dnaparser_validators.hpp
+// Author       : Dale Roberts <dale.o.roberts@gmail.com>
+// Copyright    : Copyright 2025 Geoscience Australia
+//
+//                Licensed under the Apache License, Version 2.0 (the "License");
+//                you may not use this file except in compliance with the License.
+//                You may obtain a copy of the License at
+//
+//                http ://www.apache.org/licenses/LICENSE-2.0
+//
+//                Unless required by applicable law or agreed to in writing, software
+//                distributed under the License is distributed on an "AS IS" BASIS,
+//                WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//                See the License for the specific language governing permissions and
+//                limitations under the License.
+//
+// Description  : Shared validation, factory and finalisation functions for
+//                DynaML parsing.  These are used by the XML (pimpl) parser
+//                and can be reused by any future parser (e.g. JSON).
+//============================================================================
+
+#ifndef DYNADJUST_DNAIMPORT_DNAPARSER_VALIDATORS_HPP_
+#define DYNADJUST_DNAIMPORT_DNAPARSER_VALIDATORS_HPP_
+
+#include <string>
+
+#include <include/measurement_types/dnameasurement_types.hpp>
+
+namespace dynadjust {
+namespace import {
+
+// Validates type is non-empty and a recognised measurement letter.
+// Returns the type character.
+char ValidateMeasurementType(const std::string& type);
+
+// First station must be non-empty.
+void ValidateFirst(const std::string& first);
+
+// Second station must be non-empty for types that require it.
+void ValidateSecond(const std::string& second, char type_c,
+                    const std::string& first);
+
+// Third station must be non-empty for horizontal angles.
+void ValidateThird(const std::string& third, char type_c,
+                   const std::string& first);
+
+// Value must be non-empty for scalar measurement types.
+void ValidateValue(const std::string& value, char type_c,
+                   const std::string& first);
+
+// StdDev must be non-empty and positive for scalar measurement types.
+void ValidateStdDev(const std::string& stddev, char type_c,
+                    const std::string& first);
+
+// Total must be non-empty for cluster/set measurement types (D, G, X, Y).
+void ValidateTotal(const std::string& total, char type_c);
+
+// Station name must be non-empty.
+void ValidateStationName(const std::string& name);
+
+// Returns true if the measurement type requires a Second station.
+bool TypeRequiresSecond(char type_c);
+
+// Returns true if the measurement type is a scalar type that
+// requires Value and StdDev fields.
+bool TypeRequiresValueStdDev(char type_c);
+
+// Measurement factory — creates the correct subclass from a type
+// character.  Increments tallies and measurement count for scalar
+// types.  Cluster types (G, X, D, Y) have their tallies updated
+// per-component by the caller.
+measurements::dnaMsrPtr CreateMeasurement(
+    char type_c, PUINT32 cluster_id, UINT32& msr_count,
+    measurements::MsrTally& tally, const std::string& frame,
+    const std::string& epoch);
+
+// Post-parse finalisation — validates child counts match declared
+// totals, propagates parent properties (ignore, scales, type) to
+// child elements.  Call after all children (directions / baselines /
+// clusterpoints) have been added.
+void FinaliseMeasurement(measurements::dnaMsrPtr& msr,
+                         bool prefer_single_x_as_g);
+
+// Direction-in-set post-validation.  Called after parsing each
+// Directions sub-element to check that ignoring a direction doesn't
+// leave the set empty.
+void ValidateDirectionInSet(const measurements::dnaMsrPtr& direction_set,
+                            bool direction_ignored,
+                            UINT32 declared_total);
+
+// Returns "FFF" if empty, otherwise returns input unchanged.
+std::string DefaultConstraints(const std::string& constraints);
+
+// Returns "1" if empty, otherwise returns input unchanged.
+std::string DefaultScale(const std::string& scale);
+
+// Replaces "&" with "and" in station descriptions.
+std::string SanitiseDescription(const std::string& description);
+
+}  // namespace import
+}  // namespace dynadjust
+
+#endif  // DYNADJUST_DNAIMPORT_DNAPARSER_VALIDATORS_HPP_
diff --git a/dynadjust/dynadjust/dnaimportwrapper/dnaimportwrapper.cpp b/dynadjust/dynadjust/dnaimportwrapper/dnaimportwrapper.cpp
index cb5b6c1c8..ffd48a39c 100644
--- a/dynadjust/dynadjust/dnaimportwrapper/dnaimportwrapper.cpp
+++ b/dynadjust/dynadjust/dnaimportwrapper/dnaimportwrapper.cpp
@@ -318,6 +318,29 @@ int ParseCommandLineOptions(const int& argc, char* argv[], const boost::program_
         p.i.user_supplied_epoch = 1;
     }
 
+    if (vm.count(OBSERVATION_EPOCH)) {
+        // Get today's date?
+        if (iequals(p.i.observation_epoch, "today"))
+            p.i.observation_epoch = stringFromToday<boost::gregorian::date>();
+        // Has the user supplied the year only?
+        else if (p.i.observation_epoch.rfind(".") == std::string::npos)
+            p.i.observation_epoch.insert(0, "01.01.");
+
+        if (p.i.observation_epoch.length() < 10) {
+            std::string dateStr = FormatDateString(p.i.observation_epoch);
+            if (dateStr.empty()) {
+                std::cout << std::endl
+                          << "- Error: Cannot parse observation epoch '" << p.i.observation_epoch << "'." << std::endl
+                          << "  Please supply date in the format dd.mm.yyyy" << std::endl
+                          << std::endl;
+                return EXIT_FAILURE;
+            }
+            p.i.observation_epoch = dateStr;
+        }
+
+        p.i.user_supplied_observation_epoch = 1;
+    }
+
     //////////////////////////////////////////////////////////////////////////////
     // Data screening options
     if (vm.count(GET_MSRS_TRANSCENDING_BOX)) p.i.include_transcending_msrs = 1;
@@ -1029,7 +1052,7 @@ int ImportDataFiles(dna_import& parserDynaML, vdnaStnPtr* vStations, vdnaMsrPtr*
                     // Initialise the 'default' datum (frame and epoch) for the project, from the first file, unless the
                     // frame and epoch have been set by the user, in which case InitialiseDatum has already initialised
                     // the datum.
-                    parserDynaML.InitialiseDatum(p.i.reference_frame, p.i.epoch);
+                    parserDynaML.InitialiseDatum(p.i.reference_frame, p.i.epoch, p.i.observation_epoch);
                 } catch (const XMLInteropException& e) {
                     std::stringstream ss;
                     ss << "- Error: ";
@@ -1280,11 +1303,15 @@ int main(int argc, char* argv[]) {
                           (std::string("Project epoch for all stations and measurements when input files do not "
                                        "specify an epoch. Default is ") +
                            p.i.epoch + ".")
-                              .c_str())(OVERRIDE_INPUT_FRAME,
-                                        (std::string("Replace the reference frame specified in the input files with "
-                                                     "the reference frame specified by arg in --") +
-                                         std::string(REFERENCE_FRAME))
-                                            .c_str());
+                              .c_str())(OBSERVATION_EPOCH, boost::program_options::value<std::string>(&p.i.observation_epoch),
+                                        "Default observation epoch (immutable under dnareftran) for "
+                                        "measurements that do not supply one. Format dd.mm.yyyy. "
+                                        "Use special value \"today\" to capture the current date.")(
+                                            OVERRIDE_INPUT_FRAME,
+                                            (std::string("Replace the reference frame specified in the input files with "
+                                                         "the reference frame specified by arg in --") +
+                                             std::string(REFERENCE_FRAME))
+                                                .c_str());
 
         data_screening_options.add_options()(
             BOUNDING_BOX, boost::program_options::value<std::string>(&p.i.bounding_box),
@@ -1511,7 +1538,7 @@ int main(int argc, char* argv[]) {
     // See comments in InitialiseDatum()
     try {
         // Initialise the 'default' datum for the project.
-        parserDynaML.InitialiseDatum(p.i.reference_frame, p.i.epoch);
+        parserDynaML.InitialiseDatum(p.i.reference_frame, p.i.epoch, p.i.observation_epoch);
     } catch (const XMLInteropException& e) {
         std::cout << std::endl << cmd_line_banner;
         imp_file << std::endl << cmd_line_banner;
@@ -1678,6 +1705,25 @@ int main(int argc, char* argv[]) {
     if (vm.count(STATION_DISCONTINUITY_FILE)) {
         p.i.apply_discontinuities = true;
 
+        // Static datums have no meaningful reference-frame epoch, so the discontinuity
+        // matcher will fall back to that (possibly incorrect) value unless the user
+        // supplies an observation epoch per-measurement or via --observation-epoch.
+        // See issue #325.
+        if (isEpsgDatumStatic(epsgCode) && !p.i.user_supplied_observation_epoch) {
+            std::stringstream wss;
+            wss << std::endl
+                << "- Warning: --discontinuity-file is in use with static datum " << p.i.reference_frame
+                << "." << std::endl
+                << "  Station-instance allocation relies on 'Epoch of Observation'. Supply it per-measurement" << std::endl
+                << "  via <EpochOfObservation> / DNA column 25, or set a project default via --observation-epoch." << std::endl
+                << "  Without it, the reference-frame epoch will be used as a fallback, which may be incorrect" << std::endl
+                << "  for a static datum." << std::endl
+                << std::endl;
+            if (!p.g.quiet)
+                std::cout << wss.str();
+            imp_file << wss.str();
+        }
+
         // Does it exist?
         if (!std::filesystem::exists(p.i.stn_discontinuityfile)) {
             std::filesystem::path discontPath(p.i.stn_discontinuityfile);
@@ -1739,20 +1785,11 @@ int main(int argc, char* argv[]) {
     }
     // Import data as normal
     else {
-        // Change current directory to the import folder
-        // A hack to circumvent the problem caused by importing DynaML files in
-        // different directories to where import is run from, causing errors
-        // because DynaML.xsd cannot be found.
-        std::filesystem::path currentPath(std::filesystem::current_path());
-        std::filesystem::current_path(std::filesystem::path(p.g.input_folder));
-
         // Import all data as-is.
         // All filtering is performed later below
         if (ImportDataFiles(parserDynaML, &vStations, &vMeasurements, &vstationsTotal, &vmeasurementsTotal, &imp_file,
                             &vinput_file_meta, &parsestnTally, &parsemsrTally, errorCount, p) != EXIT_SUCCESS)
             return EXIT_FAILURE;
-
-        current_path(currentPath);
     }
 
     epsgCode = epsgCodeFromName<UINT32>(p.i.reference_frame);
@@ -2544,6 +2581,12 @@ int main(int argc, char* argv[]) {
         }
     }
 
+    // Apply the project-level observation_epoch (from --observation-epoch) to measurements
+    // whose observation_epoch is empty or auto-defaulted from the reference-frame epoch.
+    // No-op when --observation-epoch was not supplied.
+    if (p.i.user_supplied_observation_epoch)
+        parserDynaML.ApplyProjectObservationEpoch((vdnaMsrPtr*)&vmeasurementsTotal);
+
     // Create binary measurement file.
     // Binary measurement file can be serialised without stations
     if (msrCount > 0) {
diff --git a/dynadjust/dynadjust/dnaplotwrapper/CMakeLists.txt b/dynadjust/dynadjust/dnaplotwrapper/CMakeLists.txt
index 4cc3bf6c3..bd5d6697b 100644
--- a/dynadjust/dynadjust/dnaplotwrapper/CMakeLists.txt
+++ b/dynadjust/dynadjust/dnaplotwrapper/CMakeLists.txt
@@ -83,8 +83,8 @@ if(BUILD_STATIC)
         "-framework CoreFoundation")
     else()
       target_link_options(${STATIC_TARGET_NAME} PRIVATE
-        -static)
-
+        -static-libgcc
+        -static-libstdc++)
     endif()
   elseif(WIN32)
     # On Windows with MSVC
diff --git a/dynadjust/dynadjust/dnareftran/dnareftran.cpp b/dynadjust/dynadjust/dnareftran/dnareftran.cpp
index 03ddaa838..c21a1ec28 100644
--- a/dynadjust/dynadjust/dnareftran/dnareftran.cpp
+++ b/dynadjust/dynadjust/dnareftran/dnareftran.cpp
@@ -82,8 +82,6 @@ void dna_reftran::TransformBinaryFiles(const std::string& bstFile, const std::st
 	// Identify and apply any substitutions for WGS84 in the list of measurements
 	ApplyMeasurementFrameSubstitutions();
 
-	datumTo_.SetDatumFromName(newFrame, newEpoch);
-
 	// 2. Transform measurements first (because pre-transformed station 
 	// coordinates are required)
 	TransformMeasurementRecords(newFrame, newEpoch);
@@ -312,6 +310,14 @@ void dna_reftran::LoadWGS84FrameSubstitutions()
 	frameSubstitution.reset(new WGS84_ITRF2014<std::string, UINT32, double>);
 	_frameSubstitutions.push_back(frameSubstitution);
 
+	// SIRGAS95 to ITRF94
+    frameSubstitution.reset(new SIRGAS95_ITRF94<std::string, UINT32, double>);
+    _frameSubstitutions.push_back(frameSubstitution);
+
+	// SIRGAS2000 to ITRF2000
+    frameSubstitution.reset(new SIRGAS2000_ITRF2000<std::string, UINT32, double>);
+    _frameSubstitutions.push_back(frameSubstitution);
+
 	std::sort(_frameSubstitutions.begin(), _frameSubstitutions.end(), 
 		CompareSubstituteOnFrameName< frame_substitutions_t<std::string, UINT32, double>, std::string>());
 
@@ -382,6 +388,49 @@ void dna_reftran::LogFrameSubstitutions(std::vector<string_string_pair>& substit
 	
 }
 
+void dna_reftran::ApplyToFrameSubstitution()
+{
+	std::string epsgSubstitute;
+
+	std::string strEpsgTo(datumTo_.GetEpsgCode_s());
+    std::string strEpochTo(datumTo_.GetEpoch_s());
+
+	_v_frame_substitutions.clear();
+
+	try {
+        if (IsolateandApplySubstitute(strEpsgTo, strEpochTo, epsgSubstitute)) 
+		{
+            _v_frame_substitutions.push_back(string_string_pair(
+				datumFromEpsgString(std::string(strEpsgTo)),
+                datumFromEpsgString(epsgSubstitute)));
+            datumTo_.SetDatum(epsgSubstitute);
+            datumTo_.SetEpoch(strEpochTo);
+        }
+    } catch (const RefTranException& e) {
+        std::stringstream error_msg;
+        error_msg << std::endl
+                  << "    - Target frame:  " << datumFromEpsgString<std::string>(strEpsgTo) << " doesn't exist."
+                  << std::endl;
+
+        switch (e.exception_type()) {
+        case REFTRAN_WGS84_TRANS_UNSUPPORTED: {
+            std::stringstream throw_msg;
+            throw_msg << e.what() << error_msg.str() << std::endl;
+            throw RefTranException(throw_msg.str(), REFTRAN_WGS84_TRANS_UNSUPPORTED);
+            break;
+        }
+        default: throw RefTranException(e.what()); break;
+        }
+    }
+
+	if (_v_frame_substitutions.empty()) 
+		return;
+    if (projectSettings_.g.verbose < 2) 
+		return;
+
+    LogFrameSubstitutions(_v_frame_substitutions, "Frame");
+}
+
 	
 void dna_reftran::ApplyStationFrameSubstitutions()
 {
@@ -572,6 +621,7 @@ void dna_reftran::WriteBinaryStationFile(const std::string& bstfileName)
 	snprintf(bst_meta_.modifiedBy, sizeof(bst_meta_.modifiedBy), "%s", __BINARY_NAME__);
 	snprintf(bst_meta_.epsgCode, sizeof(bst_meta_.epsgCode), "%s", strEpsg.substr(0, STN_EPSG_WIDTH).c_str());
 	snprintf(bst_meta_.epoch, sizeof(bst_meta_.epoch), "%s", strEpoch.substr(0, STN_EPOCH_WIDTH).c_str());
+	// observation_epoch is immutable across transformations - intentionally not overwritten.
 	bst_meta_.reftran = true;
 
 	try {
@@ -606,6 +656,7 @@ void dna_reftran::WriteBinaryMeasurementFile(const std::string& bmsfileName)
 	snprintf(bms_meta_.modifiedBy, sizeof(bms_meta_.modifiedBy), "%s", __BINARY_NAME__);
 	snprintf(bms_meta_.epsgCode, sizeof(bms_meta_.epsgCode), "%s", strEpsg.substr(0, STN_EPSG_WIDTH).c_str());
 	snprintf(bms_meta_.epoch, sizeof(bms_meta_.epoch), "%s", strEpoch.substr(0, STN_EPOCH_WIDTH).c_str());
+	// observation_epoch is immutable across transformations - intentionally not overwritten.
 	bms_meta_.reftran = true;
 
 	try {
@@ -1455,8 +1506,10 @@ void dna_reftran::TransformStationRecords(const std::string& newFrame, const std
 #endif
 
 	try {
-		// 1. Get the datum (and epoch) of the desired system
-		datumTo_.SetDatumFromName(newFrame, newEpoch);
+		// 1. Get the datum (and epoch) of the desired system and apply the
+        // appropriate substitution (required to determine the transformation parameters)
+        datumTo_.SetDatumFromName(newFrame, newEpoch);
+        ApplyToFrameSubstitution();
 		
 		// 2. For every station, get the datum, then transform
 		//    TransformStation takes
@@ -1481,6 +1534,7 @@ void dna_reftran::TransformStationRecords(const std::string& newFrame, const std
 			// d. Update meta
 			snprintf(stn_it->epsgCode, sizeof(stn_it->epsgCode), "%s", datumTo_.GetEpsgCode_s().c_str());
 			snprintf(stn_it->epoch, sizeof(stn_it->epoch), "%s", datumTo_.GetEpoch_s().c_str());
+			// observation_epoch is immutable across transformations - intentionally not overwritten.
 			transformationPerformed_ = true;
 			m_stnsTransformed++;
 		}
@@ -1556,15 +1610,15 @@ void dna_reftran::TransformStation(it_vstn_t& stn_it, const CDnaDatum& datumFrom
 
 void dna_reftran::TransformMeasurementRecords(const std::string& newFrame, const std::string& newEpoch)
 {
-	it_vmsr_t msr_it;
+	it_vmsr_t msr_it = bmsBinaryRecords_.end();
 	CDnaDatum datumFrom;
 	data_type_ = msr_data;
-	
+
 	// Create the transformation parameters to be used for the
 	// entire set of measurement records.  If a measurement is in a different
 	// frame, obtain new parameters
 	transformation_parameter_set transformationParameters;
-	
+
 	transformationPerformed_ = false;
 	m_msrsTransformed = m_msrsNotTransformed = 0;
 
@@ -1572,11 +1626,12 @@ void dna_reftran::TransformMeasurementRecords(const std::string& newFrame, const
 	TRACE("\nTransforming measurements...\n\n");
 #endif
 
+	// Setup before the measurement loop - errors here cannot reference a specific measurement
+	datumTo_.SetDatumFromName(newFrame, newEpoch);
+	ApplyToFrameSubstitution();
+
 	try {
-		// 1. Get the datum (and epoch) of the desired system
-		datumTo_.SetDatumFromName(newFrame, newEpoch);
-	
-		// 2. For every measurement, get the datum, determine parameters, then transform
+		// For every measurement, get the datum, determine parameters, then transform
 		for (msr_it=bmsBinaryRecords_.begin(); msr_it!=bmsBinaryRecords_.end(); ++msr_it)
 		{
 			// a. ignore measurements not subject to geodetic datum
@@ -1741,6 +1796,8 @@ void dna_reftran::TransformMeasurement_GX(it_vmsr_t& msr_it, const CDnaDatum& da
 		msr_it->term1 = coordinates2_mod.get(0, 0) - coordinates1_mod.get(0, 0);
 		//TRACE("\nTransformed baseline\n");
 		//TRACE("%.4f\n", msr_it->term1);
+		// observation_epoch is immutable across transformations - the three X/Y/Z
+		// component writes below intentionally overwrite only epsgCode and epoch.
 		snprintf(msr_it->epsgCode, sizeof(msr_it->epsgCode), "%s", datumTo_.GetEpsgCode_s().c_str());
 		snprintf(msr_it->epoch, sizeof(msr_it->epoch), "%s", datumTo_.GetEpoch_s().c_str());
 		msr_it++;
@@ -1831,6 +1888,8 @@ void dna_reftran::TransformMeasurement_Y(it_vmsr_t& msr_it, const CDnaDatum& dat
 		}
 		
 		// Assign 'transformed' elements
+		// observation_epoch is immutable across transformations - the three X/Y/Z
+		// component writes below intentionally overwrite only epsgCode and epoch.
 		msr_it->term1 = coordinates_mod.get(0, 0);
 		snprintf(msr_it->epsgCode, sizeof(msr_it->epsgCode), "%s", datumTo_.GetEpsgCode_s().c_str());
 		snprintf(msr_it->epoch, sizeof(msr_it->epoch), "%s", datumTo_.GetEpoch_s().c_str());
diff --git a/dynadjust/dynadjust/dnareftran/dnareftran.hpp b/dynadjust/dynadjust/dnareftran/dnareftran.hpp
index 1f629e0ba..9cc9d224f 100644
--- a/dynadjust/dynadjust/dnareftran/dnareftran.hpp
+++ b/dynadjust/dynadjust/dnareftran/dnareftran.hpp
@@ -197,6 +197,7 @@ class dna_reftran {
 	void LogFrameSubstitutions(std::vector<string_string_pair>& substitutions, const std::string& type);
 	void ApplyStationFrameSubstitutions();
 	void ApplyMeasurementFrameSubstitutions();
+    void ApplyToFrameSubstitution();
 
 	bool IsolateandApplySubstitute(const std::string& epsgCode, const std::string& epoch, std::string& epsgSubstitute);
 
@@ -224,8 +225,9 @@ class dna_reftran {
 	v_plate_motion_cartesians		plate_motion_cartesians_;	// Helmert parameters computed from Euler parameters
 
 	vframeSubsPtr					_frameSubstitutions;		// Reference frame substitutions
-	std::vector<string_string_pair>		_v_stn_substitutions;		// station substitutions made
-	std::vector<string_string_pair>		_v_msr_substitutions;		// station substitutions made
+	std::vector<string_string_pair>	_v_stn_substitutions;		// station substitutions made
+	std::vector<string_string_pair>	_v_msr_substitutions;		// station substitutions made
+    std::vector<string_string_pair> _v_frame_substitutions;     // frameTo substitution made
 
 	v_string_uint32_pair 			vplateMap_;					// Plate Map index sorted on plate ID
 
diff --git a/dynadjust/dynadjust/dnareftranwrapper/CMakeLists.txt b/dynadjust/dynadjust/dnareftranwrapper/CMakeLists.txt
index 97b495d0e..e16d5d20a 100644
--- a/dynadjust/dynadjust/dnareftranwrapper/CMakeLists.txt
+++ b/dynadjust/dynadjust/dnareftranwrapper/CMakeLists.txt
@@ -85,8 +85,8 @@ if(BUILD_STATIC)
         "-framework CoreFoundation")
     else()
       target_link_options(${STATIC_TARGET_NAME} PRIVATE
-        -static)
-
+        -static-libgcc
+        -static-libstdc++)
     endif()
   elseif(WIN32)
     # On Windows with MSVC
diff --git a/dynadjust/dynadjust/dnasegmentwrapper/CMakeLists.txt b/dynadjust/dynadjust/dnasegmentwrapper/CMakeLists.txt
index 77d527bb1..c7cfe7657 100644
--- a/dynadjust/dynadjust/dnasegmentwrapper/CMakeLists.txt
+++ b/dynadjust/dynadjust/dnasegmentwrapper/CMakeLists.txt
@@ -90,8 +90,8 @@ if(BUILD_STATIC)
         "-framework CoreFoundation")
     else()
       target_link_options(${STATIC_TARGET_NAME} PRIVATE
-        -static)
-
+        -static-libgcc
+        -static-libstdc++)
     endif()
   elseif(WIN32)
     # On Windows with MSVC
diff --git a/dynadjust/dynadjust/dynadjust/CMakeLists.txt b/dynadjust/dynadjust/dynadjust/CMakeLists.txt
index 569b3c903..7ee9a8ad7 100644
--- a/dynadjust/dynadjust/dynadjust/CMakeLists.txt
+++ b/dynadjust/dynadjust/dynadjust/CMakeLists.txt
@@ -70,14 +70,9 @@ if(BUILD_STATIC)
         #CURL::libcurl
         "-framework CoreFoundation")
     else()
-      # On Linux/Unix, we can use full static linking
       target_link_options(${STATIC_TARGET_NAME} PRIVATE
-        -Wl,-Bstatic
-        -fno-builtin
         -static-libgcc
-        -static-libstdc++
-        -static)
-
+        -static-libstdc++)
     endif()
   elseif(WIN32)
     # On Windows with MSVC
diff --git a/dynadjust/include/config/dnaoptions-interface.hpp b/dynadjust/include/config/dnaoptions-interface.hpp
index d80b81615..8fd7c843f 100644
--- a/dynadjust/include/config/dnaoptions-interface.hpp
+++ b/dynadjust/include/config/dnaoptions-interface.hpp
@@ -151,8 +151,12 @@ const char* const LSQ_INVERSE_METHOD = "inversion-method";
 const char* const SCALE_NORMAL_UNITY = "scale-normals-to-unity";
 const char* const PURGE_STAGE_FILES = "purge-stage-files";
 const char* const RECREATE_STAGE_FILES = "create-stage-files";
+const char* const STAGE_PATH = "stage-path";
 const char* const UPDATE_ORIGINAL_STN_FILE = "update-orig-stn-file";
 
+// Threading options
+const char* const MAX_THREADS = "max-threads";
+
 const char* const SEG_MIN_INNER_STNS = "min-inner-stns";
 const char* const SEG_THRESHOLD_STNS = "max-block-stns";
 const char* const SEG_STARTING_STN = "starting-stns";
@@ -171,6 +175,7 @@ const char* const REFERENCE_FRAME = "reference-frame";
 const char* const REFERENCE_FRAME_R = "reference-frame,r";
 const char* const EPOCH = "epoch";
 const char* const EPOCH_E = "epoch,e";
+const char* const OBSERVATION_EPOCH = "observation-epoch";
 const char* const OVERRIDE_INPUT_FRAME = "override-input-ref-frame";
 const char* const TECTONIC_PLATE_BDY_FILE = "plate-boundary-file";
 const char* const TECTONIC_PLATE_BDY_FILE_B = "plate-boundary-file,b";
@@ -211,6 +216,7 @@ const char* const EXPORT_GEO_FILE = "export-dna-geo-file";
 const char* const EXPORT_NTV2_ASCII_FILE = "export-ntv2-asc-file";
 const char* const EXPORT_NTV2_BINARY_FILE = "export-ntv2-gsb-file";
 const char* const EXPORT_SNX_FILE = "export-sinex-file";
+const char* const OUTPUT_JSON = "output-json";
 const char* const IMPORT_GEO_FILE = "geo-file";
 const char* const IMPORT_GEO_FILE_G = "geo-file,g";
 const char* const EXPORT_ASL_FILE = "export-asl-file";
diff --git a/dynadjust/include/config/dnaoptions.hpp b/dynadjust/include/config/dnaoptions.hpp
index 77e21eeae..60d854ec9 100644
--- a/dynadjust/include/config/dnaoptions.hpp
+++ b/dynadjust/include/config/dnaoptions.hpp
@@ -185,7 +185,7 @@ struct general_settings : private boost::equality_comparable<general_settings> {
 struct import_settings : private boost::equality_comparable<import_settings> {
 public:
 	import_settings()
-		: reference_frame(DEFAULT_DATUM), epoch(DEFAULT_EPOCH), user_supplied_frame(0), user_supplied_epoch(0), override_input_rfame(0)
+		: reference_frame(DEFAULT_DATUM), epoch(DEFAULT_EPOCH), observation_epoch(""), user_supplied_frame(0), user_supplied_epoch(0), user_supplied_observation_epoch(0), override_input_rfame(0)
 		, test_integrity(0), verify_coordinates(0), export_dynaml(0), export_from_bfiles(0)
 		, export_single_xml_file(0), prefer_single_x_as_g(0), export_asl_file(0), export_aml_file(0), export_map_file(0)
 		, export_dna_files(0), export_discont_file(0), import_geo_file(0), simulate_measurements(0), split_clusters(0), include_transcending_msrs(0)
@@ -232,9 +232,11 @@ struct import_settings : private boost::equality_comparable<import_settings> {
 
 public:
 	std::string		reference_frame;			// Project reference frame - used primarily for reductions on the ellipsoid.
-	std::string		epoch;						// Project epoch
+	std::string		epoch;						// Project epoch (of reference frame)
+	std::string		observation_epoch;			// Default observation epoch applied to measurements with no file-level value
 	UINT16		user_supplied_frame;		// User has supplied a frame - use this to change the default frame
 	UINT16		user_supplied_epoch;		// User has supplied a epoch - use this to change the default epoch
+	UINT16		user_supplied_observation_epoch;	// User has supplied an observation epoch via --observation-epoch
 	UINT16		override_input_rfame;		// Override reference frame specified in input files using the default or user supplied frame.
 	UINT16		test_integrity;				// Test integrity of network
 	UINT16		verify_coordinates;			// Test integrity of coordinates
@@ -430,7 +432,8 @@ struct adjust_settings : private boost::equality_comparable<adjust_settings> {
 		, iteration_threshold((float)0.0005), free_std_dev(10.0), fixed_std_dev(PRECISION_1E6), station_constraints("")
 		, map_file(""), bst_file(""), bms_file(""), seg_file(""), comments("") 
 		, command_line_arguments("")
-		, type_b_global (""), type_b_file ("") {}
+		, type_b_global (""), type_b_file ("")
+		, max_threads(0) {}
 
 private:
 	// Disallow use of compiler generated equality operator.
@@ -471,6 +474,7 @@ struct adjust_settings : private boost::equality_comparable<adjust_settings> {
 	UINT16		scale_normals_to_unity;	// Scale normals to unity prior to inversion
 	bool		purge_stage_files;		// Purge memory mapped files from disk upon adjustment completion.
 	UINT16		recreate_stage_files;	// Recreate memory mapped files.
+	std::string	stage_path;				// Directory for memory mapped stage files (default: output_folder).
 	float		iteration_threshold;	// Convergence limit
 	double		free_std_dev;			// SD for free stations
 	double		fixed_std_dev;			// SD for fixed stations
@@ -483,6 +487,9 @@ struct adjust_settings : private boost::equality_comparable<adjust_settings> {
 	std::string		command_line_arguments;
 	std::string      type_b_global;          // Comma delimited string containing Type b uncertainties to be applied to all uncertainties computed from an adjustment
 	std::string      type_b_file;            // File path to Type b uncertainties to be applied to specific site uncertainties computed from an adjustment
+
+	// Threading
+	int			max_threads;			// Maximum BLAS threads (0 = auto)
 };
 
 // datum and geoid settings
@@ -491,13 +498,15 @@ struct output_settings : private boost::equality_comparable<output_settings> {
 	output_settings()
 		: _m2s_file(""), _adj_file(""), _xyz_file("")
 		, _snx_file(""), _xml_file(""), _cor_file(""), _apu_file("")
+		, _adj_json_file(""), _xyz_json_file(""), _apu_json_file("")
+		, _cor_json_file(""), _m2s_json_file("")
 		, _adj_stn_iteration(0), _adj_msr_iteration(0), _cmp_msr_iteration(0), _adj_stat_iteration(0)
 		, _adj_msr_final(0), _adj_msr_tstat(0), _database_ids(0), _print_ignored_msrs(0), _adj_gnss_units(0)
 		, _output_stn_blocks(0), _output_msr_blocks(0), _sort_stn_file_order(0), _sort_adj_msr(0), _sort_msr_to_stn(0)
 		, _init_stn_corrections(0), _msr_to_stn(0), _stn_corr(0), _positional_uncertainty(0)
 		, _apu_vcv_units(0), _output_pu_covariances(0)
 		, _export_xml_stn_file(0), _export_xml_msr_file(0), _export_dna_stn_file(0), _export_dna_msr_file(0)
-		, _export_snx_file(0)
+		, _export_snx_file(0), _output_json(0)
 		, _hz_corr_threshold(0.0), _vt_corr_threshold(0.0)
 		, _stn_coord_types("PLHhXYZ"), _angular_type_stn(DMS)
 		, _precision_seconds_stn(5), _precision_metres_stn(4), _precision_seconds_msr(4), _precision_metres_msr(4)
@@ -547,6 +556,11 @@ struct output_settings : private boost::equality_comparable<output_settings> {
 	std::string			_xml_file;				// Estimated station coordinates and full variance matrix in DynaML (DynAdjust XML) format. Uses Y cluster.
 	std::string			_cor_file;				// Corrections to intial stations output
 	std::string			_apu_file;				// Adjusted positional uncertainty output
+	std::string			_adj_json_file;			// Optional JSONL sibling of _adj_file
+	std::string			_xyz_json_file;			// Optional JSONL sibling of _xyz_file
+	std::string			_apu_json_file;			// Optional JSONL sibling of _apu_file
+	std::string			_cor_json_file;			// Optional JSONL sibling of _cor_file
+	std::string			_m2s_json_file;			// Optional JSONL sibling of _m2s_file
 	UINT16			_adj_stn_iteration;		// Outputs adjusted stations for each block within each iteration
 	UINT16			_adj_msr_iteration;		// Outputs adjusted measurements for each block within each iteration
 	UINT16			_cmp_msr_iteration;		// Outputs computed measurements for each block within each iteration
@@ -572,6 +586,7 @@ struct output_settings : private boost::equality_comparable<output_settings> {
 	UINT16			_export_dna_stn_file;	// Create a DNA stn file
 	UINT16			_export_dna_msr_file;	// Create a DNA msr file
 	UINT16			_export_snx_file;		// Create a sinex file from the adjustment
+	UINT16			_output_json;			// Also emit adjustment reports as JSONL alongside text reports
 	double			_hz_corr_threshold;		// Minimum horizontal threshold for station corrections
 	double			_vt_corr_threshold;		// Minimum vertical threshold for station corrections
 	std::string			_stn_coord_types;		// String defining the cooridnate types to be printed for each station
diff --git a/dynadjust/include/config/dnatypes-basic.hpp b/dynadjust/include/config/dnatypes-basic.hpp
index 8ff9c9551..18336ae6b 100644
--- a/dynadjust/include/config/dnatypes-basic.hpp
+++ b/dynadjust/include/config/dnatypes-basic.hpp
@@ -89,7 +89,8 @@ typedef enum _INPUT_FILE_TYPE_
 	dynaml = 1,
 	dna = 2,
 	csv = 3,
-	sinex = 4
+	sinex = 4,
+	jsonl = 5
 } INPUT_FILE_TYPE;
 
 typedef enum _INPUT_DATA_TYPE_
diff --git a/dynadjust/include/config/dnatypes-structs.hpp b/dynadjust/include/config/dnatypes-structs.hpp
index 1e91dfe1c..4ddc68ee2 100644
--- a/dynadjust/include/config/dnatypes-structs.hpp
+++ b/dynadjust/include/config/dnatypes-structs.hpp
@@ -283,6 +283,7 @@ typedef struct stn_t {
 		memset(epsgCode, '\0', sizeof(epsgCode));
 		snprintf(epsgCode, sizeof(epsgCode), "7843");
 		memset(epoch, '\0', sizeof(epoch));
+		memset(observation_epoch, '\0', sizeof(observation_epoch));
 		memset(plate, '\0', sizeof(plate));
 	}
 
@@ -311,9 +312,13 @@ typedef struct stn_t {
 	UINT32	clusterID;						// cluster ID (which cluster this station belongs to)
 	UINT16	unusedStation;					// is this station unused?
 	char	epsgCode[STN_EPSG_WIDTH];		// epsg ID, i.e. NNNNN (where NNNNN is in the range 0-32767)
-	char	epoch[STN_EPOCH_WIDTH];			// date, i.e. "DD.MM.YYYY" (10 chars)
-											// if datum is dynamic, Epoch is YYYY MM DD
-											// if datum is static, Epoch is ignored
+	char	epoch[STN_EPOCH_WIDTH];			// Epoch of Reference Frame, i.e. "DD.MM.YYYY" (10 chars)
+											// Mutable via dnareftran; reflects the reference frame's epoch.
+											// If datum is static, Epoch is ignored.
+	char	observation_epoch[STN_EPOCH_WIDTH];	// Epoch of Observation, i.e. "DD.MM.YYYY" (10 chars)
+											// Immutable under reftran. Timestamp at which the station
+											// coordinates were observed/measured. Used for discontinuity
+											// station-instance allocation. Empty if not supplied.
 	char	plate[STN_PLATE_WIDTH];			// Tectonic plate identifier. Typically two characters.
 } station_t;
 
@@ -330,7 +335,8 @@ typedef v_stn_string::iterator it_stn_string;
 typedef struct input_file_meta {
 	char	filename[FILE_NAME_WIDTH+1];	// Input file path
 	char	epsgCode[STN_EPSG_WIDTH+1];		// Input file epsg ID, i.e. NNNNN (where NNNNN is in the range 0-32767). "Mixed" if stations are on different reference frames
-	char	epoch[STN_EPOCH_WIDTH+1];		// Input file epoch
+	char	epoch[STN_EPOCH_WIDTH+1];		// Input file reference frame epoch (mutable)
+	char	observation_epoch[STN_EPOCH_WIDTH+1];	// Input file observation epoch (immutable)
 	UINT16	filetype;						// Input file type (geodesyml, dynaml, dna, csv, sinex)
 	UINT16	datatype;						// Input data type (station, measurement, both)
 } input_file_meta_t;
@@ -371,6 +377,7 @@ typedef struct binary_file_meta {
 		memcpy(modifiedBy, rhs.modifiedBy, sizeof(modifiedBy));
 		memcpy(epsgCode, rhs.epsgCode, sizeof(epsgCode));
 		memcpy(epoch, rhs.epoch, sizeof(epoch));
+		memcpy(observation_epoch, rhs.observation_epoch, sizeof(observation_epoch));
 		rhs.inputFileMeta = nullptr;
 		rhs.sourceFileMeta = nullptr;
 	}
@@ -388,6 +395,7 @@ typedef struct binary_file_meta {
 			memcpy(modifiedBy, rhs.modifiedBy, sizeof(modifiedBy));
 			memcpy(epsgCode, rhs.epsgCode, sizeof(epsgCode));
 			memcpy(epoch, rhs.epoch, sizeof(epoch));
+			memcpy(observation_epoch, rhs.observation_epoch, sizeof(observation_epoch));
 			inputFileCount = rhs.inputFileCount;
 			inputFileMeta = rhs.inputFileMeta;
 			sourceFileCount = rhs.sourceFileCount;
@@ -401,7 +409,8 @@ typedef struct binary_file_meta {
 	bool				reduced;						// indicates whether the data is reduced(true) or raw(false)
 	char				modifiedBy[MOD_NAME_WIDTH+1];	// the program that modified this file
 	char				epsgCode[STN_EPSG_WIDTH+1];		// epsg ID, i.e. NNNNN (where NNNNN is in the range 0-32767). "Mixed" if stations are on different reference frames
-	char				epoch[STN_EPOCH_WIDTH+1];		// date, i.e. "DD.MM.YYYY" (10 chars)
+	char				epoch[STN_EPOCH_WIDTH+1];		// Epoch of Reference Frame (mutable)
+	char				observation_epoch[STN_EPOCH_WIDTH+1];	// Epoch of Observation (immutable; preserved across reftran)
 	bool				reftran;						// the data has been transformed to another frame and/or epoch
 	bool				geoid;							// geoid separation values have been obtained
     std::uint64_t		inputFileCount;					// Number of source file metadata elements
diff --git a/dynadjust/include/config/dnaversion.hpp b/dynadjust/include/config/dnaversion.hpp
index 15d54874b..2216669e4 100644
--- a/dynadjust/include/config/dnaversion.hpp
+++ b/dynadjust/include/config/dnaversion.hpp
@@ -204,8 +204,8 @@ const char* const __plot_dll_name__ = "libdnaplot.so";
 // 2.2.0.a1    02020001		Alpha release 
 // 2.2.0.b2    02020002		Beta release
 // 2.2.0.rc2   02020003		Release candidate 1 (unless bug notification is received, this is taken to be the final release)
-#define __BINARY_VERSION__ "1.3.0"
-#define __SHORT_VERSION__ "10300"	// used to record DynAdjust version in binary file header
+#define __BINARY_VERSION__ "1.4.0"
+#define __SHORT_VERSION__ "10400"	// used to record DynAdjust version in binary file header
 
 // define executable name
 #define __GLOBAL_BINARY_NAME__ __dynadjust_app_name__
@@ -310,7 +310,7 @@ const char* const __plot_dll_name__ = "libdnaplot.so";
 
 #if defined(__clang__)                                   // Clang compiler
   #define __COMPILER__ "Clang"
-  #define __COMPILER_VERSION__ __VERSION__
+  #define __COMPILER_VERSION__ __clang_version__
 #elif defined(__GNUC__) || defined(__GNUG__)				// GNU GCC
   #define __COMPILER__ "GNU GCC"
   #define __COMPILER_VERSION__ __VERSION__
diff --git a/dynadjust/include/functions/dnaiostreamfuncs.hpp b/dynadjust/include/functions/dnaiostreamfuncs.hpp
index 75a011ed4..71d0b38ea 100644
--- a/dynadjust/include/functions/dnaiostreamfuncs.hpp
+++ b/dynadjust/include/functions/dnaiostreamfuncs.hpp
@@ -132,7 +132,7 @@ void print_file_header(
 	stream << std::setw(PRINT_VAR_PAD) << std::left << "File created:";
 	std::ostringstream datetime_ss;
 	boost::posix_time::time_facet* p_time_output = new boost::posix_time::time_facet;
-	std::locale special_locale (std::locale(""), p_time_output);
+	std::locale special_locale (std::locale::classic(), p_time_output);
 	// special_locale takes ownership of the p_time_output facet
 	datetime_ss.imbue (special_locale);
 	(*p_time_output).format("%A, %d %B %Y, %X");
diff --git a/dynadjust/include/functions/dnatemplatedatetimefuncs.hpp b/dynadjust/include/functions/dnatemplatedatetimefuncs.hpp
index 789507910..10c9a97e6 100644
--- a/dynadjust/include/functions/dnatemplatedatetimefuncs.hpp
+++ b/dynadjust/include/functions/dnatemplatedatetimefuncs.hpp
@@ -37,6 +37,7 @@
 
 #include <include/functions/dnastrmanipfuncs.hpp>
 #include <include/functions/dnastrutils.hpp>
+#include <include/functions/dnatimer.hpp>
 
 const UINT32 TIME_IMMEMORIAL = 1900;
 
@@ -548,7 +549,7 @@ T formattedDateTimeString()
 {
 	std::stringstream datetime_ss, stream;
 	boost::posix_time::time_facet* p_time_output = new boost::posix_time::time_facet;
-	std::locale special_locale (std::locale(""), p_time_output);
+	std::locale special_locale (std::locale::classic(), p_time_output);
 	
 	// special_locale takes ownership of the p_time_output facet
 	datetime_ss.imbue (special_locale);
@@ -562,39 +563,8 @@ T formattedDateTimeString()
 template <typename S>
 S formatedElapsedTime(boost::posix_time::milliseconds* elapsed_time, S app_message)
 {
-	std::ostringstream ss_time;
-	boost::posix_time::ptime pt(boost::posix_time::ptime(boost::gregorian::day_clock::local_day(), *elapsed_time));
-
-	if (*elapsed_time < boost::posix_time::seconds(3))
-	{
-		boost::posix_time::time_facet* facet(new boost::posix_time::time_facet("%s"));
-		ss_time.imbue(std::locale(ss_time.getloc(), facet));
-		ss_time.str("");
-		ss_time << pt << "s";			
-	}
-	else if (*elapsed_time < boost::posix_time::seconds(61))
-	{		
-		boost::posix_time::time_facet* facet(new boost::posix_time::time_facet("%S"));
-		ss_time.imbue(std::locale(ss_time.getloc(), facet));
-		ss_time.str("");
-		ss_time << pt << "s";
-	}
-	else
-		ss_time << boost::posix_time::seconds(static_cast<long>(elapsed_time->total_seconds()));
-
-	size_t pos = std::string::npos;
-	std::string time_message = ss_time.str();
-	while ((pos = time_message.find("0s")) != std::string::npos)
-		time_message = time_message.substr(0, pos) + "s";
-
-	time_message = app_message + time_message + "."; 
-
-	if ((pos = time_message.find(" 00.")) != std::string::npos)
-		time_message = time_message.replace(pos, 4, " 0.");
-	if ((pos = time_message.find(" 0.s")) != std::string::npos)
-		time_message = time_message.replace(pos, 4, " 0s");
-
-	return time_message;
+	double seconds = static_cast<double>(elapsed_time->total_milliseconds()) / 1000.0;
+	return app_message + dynadjust::FormatElapsedTime(seconds) + ".";
 }
 
 
diff --git a/dynadjust/include/functions/dnatemplatematrixfuncs.hpp b/dynadjust/include/functions/dnatemplatematrixfuncs.hpp
index 05e0df853..092c7d896 100644
--- a/dynadjust/include/functions/dnatemplatematrixfuncs.hpp
+++ b/dynadjust/include/functions/dnatemplatematrixfuncs.hpp
@@ -56,7 +56,6 @@ void GetDirectionsVarianceMatrix(msr_t_Iterator begin, matrix_2d* vmat)
 	UINT32 a, angle_count(bmsRecord->vectorCount2 - 1);		// number of directions excluding the RO
 	UINT32 skip(0), ignored(bmsRecord->vectorCount1 - bmsRecord->vectorCount2);
 
-	vmat->zero();
 	vmat->redim(angle_count, angle_count);
 
 	bmsRecord++;
@@ -90,8 +89,7 @@ void GetGPSVarianceMatrix(const msr_t_Iterator begin, matrix_2d* vmat)
 {
 	msr_t_Iterator bmsRecord(begin);
 	UINT32 variance_dim(bmsRecord->vectorCount1 * 3), covariance_dim, cov;
-	vmat->zero();
-	vmat->redim(variance_dim, variance_dim);	
+	vmat->redim(variance_dim, variance_dim);
 
 	for (UINT32 var(0), cov_elem; var<variance_dim; var+=3)
 	{
diff --git a/dynadjust/include/functions/dnatimer.hpp b/dynadjust/include/functions/dnatimer.hpp
index ecb77c72f..48af83303 100644
--- a/dynadjust/include/functions/dnatimer.hpp
+++ b/dynadjust/include/functions/dnatimer.hpp
@@ -7,9 +7,9 @@
 //                Licensed under the Apache License, Version 2.0 (the "License");
 //                you may not use this file except in compliance with the License.
 //                You may obtain a copy of the License at
-//               
+//
 //                http ://www.apache.org/licenses/LICENSE-2.0
-//               
+//
 //                Unless required by applicable law or agreed to in writing, software
 //                distributed under the License is distributed on an "AS IS" BASIS,
 //                WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -23,15 +23,15 @@
 #define DNATIMER_H_
 
 #include <chrono>
-#include <string>
-#include <sstream>
 #include <iomanip>
+#include <sstream>
+#include <string>
 
 namespace dynadjust {
 
 // High-precision timer class to replace boost::timer::cpu_timer
 class cpu_timer {
-public:
+   public:
     struct cpu_times {
         std::chrono::nanoseconds wall;
         std::chrono::nanoseconds user;
@@ -39,39 +39,56 @@ class cpu_timer {
     };
 
     cpu_timer() { start(); }
-    
-    void start() {
-        start_time_ = std::chrono::high_resolution_clock::now();
-    }
-    
-    void resume() {
-        start();
-    }
-    
+
+    void start() { start_time_ = std::chrono::high_resolution_clock::now(); }
+
+    void resume() { start(); }
+
     void stop() {
         // For compatibility, but no-op since we calculate elapsed on demand
     }
-    
+
     cpu_times elapsed() const {
         auto end_time = std::chrono::high_resolution_clock::now();
         auto wall_duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time_);
-        return {wall_duration, wall_duration, wall_duration}; // For simplicity, user and system = wall
+        return {wall_duration, wall_duration, wall_duration};  // For simplicity, user and system = wall
     }
-    
+
     std::string format(int places = 6) const {
         auto times = elapsed();
         double wall_seconds = times.wall.count() / 1e9;
-        
+
         std::ostringstream oss;
         oss << std::fixed << std::setprecision(places);
         oss << wall_seconds << "s wall";
         return oss.str();
     }
 
-private:
+   private:
     std::chrono::high_resolution_clock::time_point start_time_;
 };
 
+// Format an elapsed duration (in seconds) for display.
+//   < 1 second   -> "X.XXXms"
+//   1..60 second -> "X.XXXs"
+//   >= 60 second -> "hh:mm:ss"
+inline std::string FormatElapsedTime(double seconds) {
+    std::ostringstream oss;
+    if (seconds >= 60.0) {
+        long total_seconds = static_cast<long>(seconds);
+        long hours = total_seconds / 3600;
+        long minutes = (total_seconds % 3600) / 60;
+        long secs = total_seconds % 60;
+        oss << std::setfill('0') << std::setw(2) << hours << ':' << std::setw(2) << minutes << ':' << std::setw(2)
+            << secs;
+    } else if (seconds >= 1.0) {
+        oss << std::fixed << std::setprecision(3) << seconds << 's';
+    } else {
+        oss << std::fixed << std::setprecision(3) << (seconds * 1000.0) << "ms";
+    }
+    return oss.str();
+}
+
 }  // namespace dynadjust
 
-#endif  // DNATIMER_H_
\ No newline at end of file
+#endif  // DNATIMER_H_
diff --git a/dynadjust/include/io/DynaML-schema.cxx b/dynadjust/include/io/DynaML-schema.cxx
deleted file mode 100644
index 8f1fa74c7..000000000
--- a/dynadjust/include/io/DynaML-schema.cxx
+++ /dev/null
@@ -1,969 +0,0 @@
-// Automatically generated. Do not edit.
-//
-
-/// \cond
-#include <xercesc/util/XercesDefs.hpp>
-#include <xercesc/util/XercesVersion.hpp>
-/// \endcond
-
-#if XERCES_GRAMMAR_SERIALIZATION_LEVEL != 7
-#  error incompatible Xerces-C++ version detected
-#endif
-
-extern const XMLByte DynaML_schema[11430UL] =
-{
-  0x07, 0x00, 0x06, 0x86, 0x00, 0x06, 0x1e, 0x00, 0x02, 0x68, 0x00, 0xff,
-  0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x61, 0x70, 0x61, 0x63, 0x68, 0x65,
-  0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x78, 0x6d, 0x6c, 0x2f, 0x55, 0x6b, 0x6e,
-  0x6f, 0x77, 0x6e, 0x4e, 0x53, 0x24, 0x00, 0x68, 0x74, 0x74, 0x70, 0x3a,
-  0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x77, 0x33, 0x2e, 0x6f, 0x72, 0x67,
-  0x2f, 0x58, 0x4d, 0x4c, 0x2f, 0x31, 0x39, 0x39, 0x38, 0x2f, 0x6e, 0x61,
-  0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x1d, 0x00, 0x68, 0x74, 0x74,
-  0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x77, 0x33, 0x2e, 0x6f,
-  0x72, 0x67, 0x2f, 0x32, 0x30, 0x30, 0x30, 0x2f, 0x78, 0x6d, 0x6c, 0x6e,
-  0x73, 0x2f, 0x00, 0x20, 0x00, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f,
-  0x77, 0x77, 0x77, 0x2e, 0x77, 0x33, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x32,
-  0x30, 0x30, 0x31, 0x2f, 0x58, 0x4d, 0x4c, 0x53, 0x00, 0xff, 0x63, 0x68,
-  0x65, 0x6d, 0x61, 0x0d, 0x00, 0x2c, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65,
-  0x72, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x00, 0x08, 0x00, 0x5f, 0x5f, 0x41,
-  0x6e, 0x6f, 0x6e, 0x43, 0x30, 0x09, 0x00, 0x2c, 0x5f, 0x5f, 0x41, 0x6e,
-  0x6f, 0x6e, 0x43, 0x30, 0x00, 0x30, 0x00, 0x43, 0x3a, 0x5c, 0x44, 0x61,
-  0x74, 0x61, 0x5c, 0x76, 0x73, 0x31, 0x30, 0x5c, 0x70, 0x72, 0x6f, 0x6a,
-  0x65, 0x63, 0x74, 0x73, 0x5c, 0x64, 0x79, 0x6e, 0x61, 0x6e, 0x65, 0x74,
-  0x5f, 0x33, 0x5f, 0x30, 0x33, 0x5f, 0x30, 0x30, 0x2f, 0x44, 0x79, 0x6e,
-  0x61, 0x4d, 0x4c, 0x2e, 0x78, 0x73, 0x64, 0x01, 0x00, 0x58, 0x00, 0x06,
-  0x00, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x02, 0x00, 0x78, 0x73, 0x01,
-  0x00, 0x59, 0x00, 0x01, 0x00, 0x5a, 0x00, 0x07, 0x00, 0x53, 0x69, 0x67,
-  0x6d, 0x61, 0x58, 0x58, 0x00, 0x07, 0x00, 0x02, 0x53, 0x00, 0xff, 0x69,
-  0x67, 0x6d, 0x61, 0x58, 0x59, 0x00, 0x07, 0x00, 0x53, 0x69, 0x67, 0x6d,
-  0x61, 0x58, 0x5a, 0x00, 0x07, 0x00, 0x53, 0x69, 0x67, 0x6d, 0x61, 0x59,
-  0x59, 0x00, 0x07, 0x00, 0x53, 0x69, 0x67, 0x6d, 0x61, 0x59, 0x5a, 0x00,
-  0x07, 0x00, 0x53, 0x69, 0x67, 0x6d, 0x61, 0x5a, 0x5a, 0x00, 0x0f, 0x00,
-  0x50, 0x6f, 0x69, 0x6e, 0x74, 0x43, 0x6f, 0x76, 0x61, 0x72, 0x69, 0x61,
-  0x6e, 0x63, 0x65, 0x00, 0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e,
-  0x43, 0x31, 0x09, 0x00, 0x2c, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x43,
-  0x31, 0x00, 0x03, 0x00, 0x6d, 0x31, 0x31, 0x00, 0x03, 0x00, 0x6d, 0x31,
-  0x32, 0x00, 0x03, 0x00, 0x6d, 0x31, 0x33, 0x00, 0x03, 0x00, 0x6d, 0x32,
-  0x31, 0x00, 0x03, 0x00, 0x6d, 0x32, 0x32, 0x00, 0x03, 0x00, 0x6d, 0x32,
-  0x33, 0x00, 0x03, 0x00, 0x6d, 0x33, 0x31, 0x00, 0x02, 0x03, 0x00, 0x02,
-  0x6d, 0x00, 0xff, 0x33, 0x32, 0x00, 0x03, 0x00, 0x6d, 0x33, 0x33, 0x00,
-  0x0c, 0x00, 0x2c, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e,
-  0x74, 0x73, 0x07, 0x00, 0x2c, 0x43, 0x6f, 0x6f, 0x72, 0x64, 0x73, 0x00,
-  0x0c, 0x00, 0x2c, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69,
-  0x6f, 0x6e, 0x0b, 0x00, 0x2c, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69,
-  0x6f, 0x6e, 0x73, 0x00, 0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e,
-  0x43, 0x32, 0x09, 0x00, 0x2c, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x43,
-  0x32, 0x00, 0x06, 0x00, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x06, 0x00,
-  0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x05, 0x00, 0x56, 0x61, 0x6c, 0x75,
-  0x65, 0x00, 0x06, 0x00, 0x53, 0x74, 0x64, 0x44, 0x65, 0x76, 0x0f, 0x00,
-  0x2c, 0x44, 0x6e, 0x61, 0x4d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x00,
-  0xff, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e,
-  0x6f, 0x6e, 0x43, 0x33, 0x09, 0x00, 0x2c, 0x5f, 0x5f, 0x41, 0x6e, 0x6f,
-  0x6e, 0x43, 0x33, 0x00, 0x04, 0x00, 0x54, 0x79, 0x70, 0x65, 0x0e, 0x00,
-  0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x46, 0x72, 0x61,
-  0x6d, 0x65, 0x05, 0x00, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x00, 0x05, 0x00,
-  0x46, 0x69, 0x72, 0x73, 0x74, 0x00, 0x06, 0x00, 0x53, 0x65, 0x63, 0x6f,
-  0x6e, 0x64, 0x05, 0x00, 0x54, 0x68, 0x69, 0x72, 0x64, 0x00, 0x0a, 0x00,
-  0x49, 0x6e, 0x73, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x0a, 0x00,
-  0x54, 0x61, 0x72, 0x67, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x05, 0x00,
-  0x54, 0x6f, 0x74, 0x61, 0x6c, 0x00, 0x0a, 0x00, 0x44, 0x69, 0x72, 0x65,
-  0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x06, 0x00, 0x56, 0x00, 0xff, 0x73,
-  0x63, 0x61, 0x6c, 0x65, 0x0b, 0x00, 0x47, 0x50, 0x53, 0x42, 0x61, 0x73,
-  0x65, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e,
-  0x6f, 0x6e, 0x43, 0x34, 0x09, 0x00, 0x2c, 0x5f, 0x5f, 0x41, 0x6e, 0x6f,
-  0x6e, 0x43, 0x34, 0x00, 0x0d, 0x00, 0x47, 0x50, 0x53, 0x43, 0x6f, 0x76,
-  0x61, 0x72, 0x69, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x08, 0x00, 0x5f, 0x5f,
-  0x41, 0x6e, 0x6f, 0x6e, 0x43, 0x35, 0x09, 0x00, 0x2c, 0x5f, 0x5f, 0x41,
-  0x6e, 0x6f, 0x6e, 0x43, 0x35, 0x00, 0x06, 0x00, 0x48, 0x73, 0x63, 0x61,
-  0x6c, 0x65, 0x06, 0x00, 0x4c, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x06, 0x00,
-  0x50, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x0c, 0x00, 0x43, 0x6c, 0x75, 0x73,
-  0x74, 0x65, 0x72, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x06, 0x00, 0x43, 0x6f,
-  0x6f, 0x72, 0x64, 0x73, 0x06, 0x00, 0x53, 0x00, 0xff, 0x6f, 0x75, 0x72,
-  0x63, 0x65, 0x0b, 0x00, 0x2c, 0x44, 0x6e, 0x61, 0x53, 0x74, 0x61, 0x74,
-  0x69, 0x6f, 0x6e, 0x00, 0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e,
-  0x43, 0x36, 0x09, 0x00, 0x2c, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x43,
-  0x36, 0x00, 0x04, 0x00, 0x4e, 0x61, 0x6d, 0x65, 0x0b, 0x00, 0x43, 0x6f,
-  0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x00, 0x0c, 0x00,
-  0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6f, 0x72, 0x64,
-  0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x43, 0x37, 0x09, 0x00,
-  0x2c, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x43, 0x37, 0x00, 0x05, 0x00,
-  0x58, 0x41, 0x78, 0x69, 0x73, 0x00, 0x05, 0x00, 0x59, 0x41, 0x78, 0x69,
-  0x73, 0x00, 0x06, 0x00, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x0e, 0x00,
-  0x48, 0x65, 0x6d, 0x69, 0x73, 0x00, 0xff, 0x70, 0x68, 0x65, 0x72, 0x65,
-  0x5a, 0x6f, 0x6e, 0x65, 0x0b, 0x00, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69,
-  0x70, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x0d, 0x00, 0x2c, 0x44, 0x6e, 0x61,
-  0x58, 0x6d, 0x6c, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x00, 0x08, 0x00,
-  0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x43, 0x38, 0x09, 0x00, 0x2c, 0x5f,
-  0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x43, 0x38, 0x00, 0x0a, 0x00, 0x44, 0x6e,
-  0x61, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0e, 0x00, 0x44, 0x6e,
-  0x61, 0x4d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74,
-  0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x53, 0x39, 0x09, 0x00,
-  0x2c, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x53, 0x39, 0x00, 0x06, 0x00,
-  0x2c, 0x46, 0x69, 0x72, 0x73, 0x74, 0x0c, 0x00, 0x2c, 0x47, 0x50, 0x53,
-  0x42, 0x61, 0x73, 0x00, 0xff, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x0e, 0x00,
-  0x2c, 0x47, 0x50, 0x53, 0x43, 0x6f, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e,
-  0x63, 0x65, 0x07, 0x00, 0x2c, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x00,
-  0x0f, 0x00, 0x2c, 0x48, 0x65, 0x6d, 0x69, 0x73, 0x70, 0x68, 0x65, 0x72,
-  0x65, 0x5a, 0x6f, 0x6e, 0x65, 0x00, 0x07, 0x00, 0x2c, 0x48, 0x73, 0x63,
-  0x61, 0x6c, 0x65, 0x00, 0x07, 0x00, 0x2c, 0x49, 0x67, 0x6e, 0x6f, 0x72,
-  0x65, 0x00, 0x0b, 0x00, 0x2c, 0x49, 0x6e, 0x73, 0x74, 0x48, 0x65, 0x69,
-  0x67, 0x68, 0x74, 0x00, 0x07, 0x00, 0x2c, 0x4c, 0x73, 0x63, 0x61, 0x6c,
-  0x65, 0x00, 0x05, 0x00, 0x2c, 0x4e, 0x61, 0x6d, 0x65, 0x00, 0x10, 0x00,
-  0x2c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x43, 0x6f, 0x76, 0x61, 0x72, 0x69,
-  0x61, 0x6e, 0x63, 0x65, 0x07, 0x00, 0x2c, 0x50, 0x73, 0x63, 0x61, 0x6c,
-  0x65, 0x00, 0x02, 0x07, 0x00, 0x02, 0x2c, 0x00, 0xff, 0x53, 0x65, 0x63,
-  0x6f, 0x6e, 0x64, 0x00, 0x08, 0x00, 0x2c, 0x53, 0x69, 0x67, 0x6d, 0x61,
-  0x58, 0x58, 0x08, 0x00, 0x2c, 0x53, 0x69, 0x67, 0x6d, 0x61, 0x58, 0x59,
-  0x08, 0x00, 0x2c, 0x53, 0x69, 0x67, 0x6d, 0x61, 0x58, 0x5a, 0x08, 0x00,
-  0x2c, 0x53, 0x69, 0x67, 0x6d, 0x61, 0x59, 0x59, 0x08, 0x00, 0x2c, 0x53,
-  0x69, 0x67, 0x6d, 0x61, 0x59, 0x5a, 0x08, 0x00, 0x2c, 0x53, 0x69, 0x67,
-  0x6d, 0x61, 0x5a, 0x5a, 0x0d, 0x00, 0x2c, 0x53, 0x74, 0x61, 0x74, 0x69,
-  0x6f, 0x6e, 0x43, 0x6f, 0x6f, 0x72, 0x64, 0x00, 0x07, 0x00, 0x2c, 0x53,
-  0x74, 0x64, 0x44, 0x65, 0x76, 0x00, 0x0b, 0x00, 0x2c, 0x54, 0x61, 0x72,
-  0x67, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x00, 0x07, 0x00, 0x2c, 0x54,
-  0x61, 0x72, 0x67, 0x65, 0x74, 0x00, 0x06, 0x00, 0x2c, 0x54, 0x68, 0x69,
-  0x72, 0x64, 0x06, 0x00, 0x2c, 0x00, 0xff, 0x54, 0x6f, 0x74, 0x61, 0x6c,
-  0x05, 0x00, 0x2c, 0x54, 0x79, 0x70, 0x65, 0x00, 0x06, 0x00, 0x2c, 0x56,
-  0x61, 0x6c, 0x75, 0x65, 0x07, 0x00, 0x2c, 0x56, 0x73, 0x63, 0x61, 0x6c,
-  0x65, 0x00, 0x02, 0x00, 0x2c, 0x58, 0x06, 0x00, 0x2c, 0x58, 0x41, 0x78,
-  0x69, 0x73, 0x02, 0x00, 0x2c, 0x59, 0x06, 0x00, 0x2c, 0x59, 0x41, 0x78,
-  0x69, 0x73, 0x02, 0x00, 0x2c, 0x5a, 0x04, 0x00, 0x2c, 0x6d, 0x31, 0x31,
-  0x04, 0x00, 0x2c, 0x6d, 0x31, 0x32, 0x04, 0x00, 0x2c, 0x6d, 0x31, 0x33,
-  0x04, 0x00, 0x2c, 0x6d, 0x32, 0x31, 0x04, 0x00, 0x2c, 0x6d, 0x32, 0x32,
-  0x04, 0x00, 0x2c, 0x6d, 0x32, 0x33, 0x04, 0x00, 0x2c, 0x6d, 0x33, 0x31,
-  0x04, 0x00, 0x2c, 0x6d, 0x33, 0x32, 0x04, 0x00, 0x2c, 0x6d, 0x33, 0x33,
-  0x07, 0x00, 0x2c, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x00, 0x0f, 0x00,
-  0x2c, 0x52, 0x65, 0x00, 0x95, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-  0x46, 0x72, 0x61, 0x6d, 0x65, 0x00, 0x06, 0x00, 0x2c, 0x45, 0x70, 0x6f,
-  0x63, 0x68, 0xfe, 0xff, 0xff, 0xff, 0x1d, 0x00, 0x06, 0x01, 0x00, 0x06,
-  0x01, 0x00, 0x02, 0xff, 0xff, 0xff, 0xff, 0x0d, 0x00, 0x02, 0x53, 0x63,
-  0x68, 0x65, 0x6d, 0x61, 0x47, 0x72, 0x61, 0x6d, 0x6d, 0x61, 0x72, 0x00,
-  0x02, 0xfe, 0xff, 0xff, 0xff, 0x1d, 0x00, 0x06, 0x01, 0x00, 0x06, 0xfe,
-  0xff, 0xff, 0xff, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0x17, 0x00, 0x02,
-  0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x74, 0x79,
-  0x70, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x01,
-  0x00, 0x0b, 0x10, 0x00, 0x0e, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02,
-  0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0xfe, 0xff, 0xff, 0xff,
-  0x1d, 0x00, 0x0e, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0x08,
-  0x00, 0x02, 0x5f, 0x00, 0x87, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x53, 0x39,
-  0x00, 0x0b, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x0f, 0xfe, 0xff, 0xff, 0xff,
-  0x02, 0x00, 0x06, 0x10, 0x00, 0x02, 0x4d, 0x00, 0x9d, 0x65, 0x61, 0x73,
-  0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x46, 0x69, 0x6c, 0x65,
-  0x0c, 0x00, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x46, 0x69,
-  0x6c, 0x65, 0xfe, 0xff, 0xff, 0xff, 0x6d, 0x00, 0x06, 0x35, 0x00, 0x06,
-  0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x11, 0x00, 0x02, 0x53,
-  0x63, 0x68, 0x65, 0x6d, 0x61, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74,
-  0x44, 0x65, 0x63, 0x6c, 0x00, 0x02, 0xff, 0xff, 0xff, 0xff, 0x05, 0x00,
-  0x02, 0x51, 0x4e, 0x61, 0x6d, 0x65, 0x00, 0x02, 0x08, 0x00, 0x06, 0x0e,
-  0x00, 0x02, 0x06, 0x00, 0x02, 0x54, 0x00, 0x8a, 0x61, 0x72, 0x67, 0x65,
-  0x74, 0x01, 0x00, 0x01, 0x00, 0x1a, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff,
-  0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85,
-  0x74, 0x72, 0x69, 0x6e, 0x67, 0xfe, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x01,
-  0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x14, 0x00, 0x02, 0x0c,
-  0x00, 0x02, 0x43, 0x00, 0x90, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x70,
-  0x6f, 0x69, 0x6e, 0x74, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x09, 0x04,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x02, 0x43, 0x6f,
-  0x6d, 0x70, 0x6c, 0x65, 0x78, 0x54, 0x79, 0x70, 0x65, 0x49, 0x6e, 0x66,
-  0x6f, 0x01, 0x00, 0x81, 0x01, 0x00, 0x10, 0x04, 0x00, 0x02, 0xfe, 0xff,
-  0xff, 0xff, 0x09, 0x00, 0x02, 0x2c, 0x00, 0x95, 0x5f, 0x5f, 0x41, 0x6e,
-  0x6f, 0x6e, 0x43, 0x30, 0x00, 0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e, 0x6f,
-  0x6e, 0x43, 0x30, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff,
-  0xff, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x02, 0x43, 0x6f,
-  0x6e, 0x74, 0x65, 0x6e, 0x74, 0x53, 0x70, 0x65, 0x63, 0x4e, 0x6f, 0x64,
-  0x65, 0x00, 0x04, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03,
-  0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01,
-  0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03,
-  0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01,
-  0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x09, 0x00, 0x02, 0x01, 0x00, 0x02, 0x58,
-  0x00, 0x02, 0x01, 0x00, 0x06, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01,
-  0x80, 0x08, 0x00, 0x06, 0x09, 0x00, 0x02, 0x01, 0x00, 0x02, 0x58, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x02, 0x00, 0x0a, 0x05, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff,
-  0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73,
-  0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00,
-  0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c,
-  0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x09, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0x59, 0x00, 0x02, 0x01, 0x00, 0x06, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x09, 0x00, 0x02, 0x01, 0x00, 0x02, 0x59,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x03, 0x00, 0x0a, 0x05,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff,
-  0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02,
-  0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01,
-  0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01,
-  0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01,
-  0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x09, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0x5a, 0x00, 0x02, 0x01, 0x00, 0x06, 0x0a, 0x00, 0x01, 0x80,
-  0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x09, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x5a, 0x00, 0x02, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x04, 0x00,
-  0x0a, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00,
-  0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06,
-  0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b,
-  0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00,
-  0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12,
-  0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0f, 0x00,
-  0x02, 0x07, 0x00, 0x02, 0x53, 0x00, 0x88, 0x69, 0x67, 0x6d, 0x61, 0x58,
-  0x58, 0x00, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01,
-  0x80, 0x08, 0x00, 0x06, 0x0f, 0x00, 0x02, 0x07, 0x00, 0x02, 0x53, 0x00,
-  0x8c, 0x69, 0x67, 0x6d, 0x61, 0x58, 0x58, 0x00, 0x01, 0x00, 0x01, 0x00,
-  0x05, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff,
-  0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff,
-  0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67,
-  0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06,
-  0x0f, 0x00, 0x02, 0x07, 0x00, 0x02, 0x53, 0x00, 0x88, 0x69, 0x67, 0x6d,
-  0x61, 0x58, 0x59, 0x00, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c,
-  0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0f, 0x00, 0x02, 0x07, 0x00, 0x02,
-  0x53, 0x00, 0x8c, 0x69, 0x67, 0x6d, 0x61, 0x58, 0x59, 0x00, 0x01, 0x00,
-  0x01, 0x00, 0x06, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe,
-  0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff,
-  0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69,
-  0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02,
-  0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08,
-  0x00, 0x06, 0x0f, 0x00, 0x02, 0x07, 0x00, 0x02, 0x53, 0x00, 0x88, 0x69,
-  0x67, 0x6d, 0x61, 0x58, 0x5a, 0x00, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01,
-  0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0f, 0x00, 0x02, 0x07,
-  0x00, 0x02, 0x53, 0x00, 0x8c, 0x69, 0x67, 0x6d, 0x61, 0x58, 0x5a, 0x00,
-  0x01, 0x00, 0x01, 0x00, 0x07, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00,
-  0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74,
-  0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01,
-  0x80, 0x08, 0x00, 0x06, 0x0f, 0x00, 0x02, 0x07, 0x00, 0x02, 0x53, 0x00,
-  0x88, 0x69, 0x67, 0x6d, 0x61, 0x59, 0x59, 0x00, 0x01, 0x00, 0x05, 0x0a,
-  0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0f, 0x00,
-  0x02, 0x07, 0x00, 0x02, 0x53, 0x00, 0x8c, 0x69, 0x67, 0x6d, 0x61, 0x59,
-  0x59, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00, 0x09, 0x05, 0x00, 0x02,
-  0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff,
-  0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00,
-  0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00,
-  0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c,
-  0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0f, 0x00, 0x02, 0x07, 0x00, 0x02,
-  0x53, 0x00, 0x88, 0x69, 0x67, 0x6d, 0x61, 0x59, 0x5a, 0x00, 0x01, 0x00,
-  0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06,
-  0x0f, 0x00, 0x02, 0x07, 0x00, 0x02, 0x53, 0x00, 0x8c, 0x69, 0x67, 0x6d,
-  0x61, 0x59, 0x5a, 0x00, 0x01, 0x00, 0x01, 0x00, 0x09, 0x00, 0x09, 0x05,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff,
-  0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02,
-  0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01,
-  0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01,
-  0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01,
-  0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0f, 0x00, 0x02, 0x07,
-  0x00, 0x02, 0x53, 0x00, 0x88, 0x69, 0x67, 0x6d, 0x61, 0x5a, 0x5a, 0x00,
-  0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08,
-  0x00, 0x06, 0x0f, 0x00, 0x02, 0x07, 0x00, 0x02, 0x53, 0x00, 0x8c, 0x69,
-  0x67, 0x6d, 0x61, 0x5a, 0x5a, 0x00, 0x01, 0x00, 0x01, 0x00, 0x0a, 0x00,
-  0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00,
-  0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06,
-  0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b,
-  0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00,
-  0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12,
-  0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x17, 0x00,
-  0x02, 0x0f, 0x00, 0x02, 0x50, 0x00, 0x90, 0x6f, 0x69, 0x6e, 0x74, 0x43,
-  0x6f, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x01, 0x00,
-  0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06,
-  0x17, 0x00, 0x02, 0x0f, 0x00, 0x02, 0x50, 0x00, 0x94, 0x6f, 0x69, 0x6e,
-  0x74, 0x43, 0x6f, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x63, 0x65, 0x00,
-  0x01, 0x00, 0x01, 0x00, 0x0b, 0x00, 0x09, 0x04, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x10,
-  0x00, 0x01, 0x80, 0x01, 0x00, 0x81, 0x01, 0x00, 0x0f, 0x01, 0x00, 0x02,
-  0x04, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x09, 0x00, 0x02, 0x2c, 0x00,
-  0x95, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x43, 0x31, 0x00, 0x08, 0x00,
-  0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x43, 0x31, 0x00, 0x00, 0xfd, 0xff,
-  0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0x00, 0x03, 0x12, 0x00, 0x01, 0x80,
-  0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02,
-  0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12,
-  0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80,
-  0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02,
-  0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12,
-  0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80,
-  0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02, 0x03, 0x00,
-  0x02, 0x6d, 0x00, 0x84, 0x31, 0x31, 0x00, 0x01, 0x00, 0x05, 0x0a, 0x00,
-  0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02,
-  0x03, 0x00, 0x02, 0x6d, 0x00, 0x88, 0x31, 0x31, 0x00, 0x01, 0x00, 0x01,
-  0x00, 0x0c, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff,
-  0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff,
-  0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e,
-  0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06,
-  0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d, 0x00, 0x84, 0x31, 0x32, 0x00,
-  0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08,
-  0x00, 0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d, 0x00, 0x88, 0x31,
-  0x32, 0x00, 0x01, 0x00, 0x01, 0x00, 0x0d, 0x00, 0x09, 0x05, 0x00, 0x02,
-  0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff,
-  0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00,
-  0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00,
-  0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c,
-  0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02,
-  0x6d, 0x00, 0x84, 0x31, 0x33, 0x00, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01,
-  0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02, 0x03,
-  0x00, 0x02, 0x6d, 0x00, 0x88, 0x31, 0x33, 0x00, 0x01, 0x00, 0x01, 0x00,
-  0x0e, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff,
-  0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff,
-  0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67,
-  0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06,
-  0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d, 0x00, 0x84, 0x32, 0x31, 0x00,
-  0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08,
-  0x00, 0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d, 0x00, 0x88, 0x32,
-  0x31, 0x00, 0x01, 0x00, 0x01, 0x00, 0x0f, 0x00, 0x09, 0x05, 0x00, 0x02,
-  0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff,
-  0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00,
-  0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00,
-  0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c,
-  0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02,
-  0x6d, 0x00, 0x84, 0x32, 0x32, 0x00, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01,
-  0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02, 0x03,
-  0x00, 0x02, 0x6d, 0x00, 0x88, 0x32, 0x32, 0x00, 0x01, 0x00, 0x01, 0x00,
-  0x10, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff,
-  0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff,
-  0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67,
-  0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06,
-  0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d, 0x00, 0x84, 0x32, 0x33, 0x00,
-  0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08,
-  0x00, 0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d, 0x00, 0x88, 0x32,
-  0x33, 0x00, 0x01, 0x00, 0x01, 0x00, 0x11, 0x00, 0x09, 0x05, 0x00, 0x02,
-  0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff,
-  0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00,
-  0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00,
-  0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c,
-  0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02,
-  0x6d, 0x00, 0x84, 0x33, 0x31, 0x00, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01,
-  0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02, 0x03,
-  0x00, 0x02, 0x6d, 0x00, 0x88, 0x33, 0x31, 0x00, 0x01, 0x00, 0x01, 0x00,
-  0x12, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff,
-  0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff,
-  0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67,
-  0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06,
-  0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d, 0x00, 0x84, 0x33, 0x32, 0x00,
-  0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08,
-  0x00, 0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d, 0x00, 0x88, 0x33,
-  0x32, 0x00, 0x01, 0x00, 0x01, 0x00, 0x13, 0x00, 0x09, 0x05, 0x00, 0x02,
-  0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff,
-  0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00,
-  0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00,
-  0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c,
-  0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02,
-  0x6d, 0x00, 0x84, 0x33, 0x33, 0x00, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01,
-  0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02, 0x03,
-  0x00, 0x02, 0x6d, 0x00, 0x88, 0x33, 0x33, 0x00, 0x01, 0x00, 0x01, 0x00,
-  0x14, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff,
-  0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff,
-  0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67,
-  0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0x15, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x06, 0xff, 0xff, 0xff, 0xff, 0x10, 0x00, 0x02, 0x53, 0x63, 0x68, 0x65,
-  0x6d, 0x61, 0x41, 0x74, 0x74, 0x44, 0x65, 0x66, 0x4c, 0x69, 0x73, 0x74,
-  0xfe, 0xff, 0xff, 0xff, 0x1d, 0x00, 0x16, 0xfe, 0xff, 0xff, 0xff, 0x09,
-  0x00, 0x06, 0x4f, 0x00, 0x02, 0x53, 0x00, 0x02, 0x57, 0x00, 0x02, 0x5b,
-  0x00, 0x02, 0x5f, 0x00, 0x02, 0x63, 0x00, 0x02, 0x67, 0x00, 0x02, 0x6b,
-  0x00, 0x02, 0x6f, 0x00, 0x02, 0x73, 0x00, 0x12, 0xfd, 0xff, 0xff, 0xff,
-  0x00, 0x0b, 0x01, 0x01, 0x00, 0x05, 0xff, 0xff, 0xff, 0xff, 0x15, 0x00,
-  0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x06, 0x71,
-  0x00, 0x01, 0x80, 0xfe, 0xff, 0xff, 0xff, 0x1d, 0x00, 0x16, 0xfe, 0xff,
-  0xff, 0xff, 0x0a, 0x00, 0x06, 0x1e, 0x00, 0x02, 0x22, 0x00, 0x02, 0x26,
-  0x00, 0x02, 0x2a, 0x00, 0x02, 0x2e, 0x00, 0x02, 0x32, 0x00, 0x02, 0x36,
-  0x00, 0x02, 0x3a, 0x00, 0x02, 0x3e, 0x00, 0x02, 0x42, 0x00, 0x02, 0x76,
-  0x00, 0x12, 0xfd, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x0a, 0x00,
-  0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x15, 0x00, 0x02,
-  0x0d, 0x00, 0x02, 0x47, 0x00, 0x92, 0x50, 0x53, 0x43, 0x6f, 0x76, 0x61,
-  0x72, 0x69, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x01, 0x00, 0x01, 0x00, 0x29,
-  0x00, 0x09, 0x04, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff,
-  0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x10, 0x00, 0x01, 0x80, 0x01, 0x00,
-  0x81, 0x01, 0x00, 0x0f, 0x05, 0x00, 0x02, 0x04, 0x00, 0x02, 0xfe, 0xff,
-  0xff, 0xff, 0x09, 0x00, 0x02, 0x2c, 0x00, 0x95, 0x5f, 0x5f, 0x41, 0x6e,
-  0x6f, 0x6e, 0x43, 0x35, 0x00, 0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e, 0x6f,
-  0x6e, 0x43, 0x35, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff,
-  0xff, 0x00, 0x03, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01,
-  0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03,
-  0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01,
-  0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03,
-  0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08,
-  0x00, 0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d, 0x00, 0x84, 0x31,
-  0x31, 0x00, 0x01, 0x00, 0x05, 0x4f, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d,
-  0x00, 0x84, 0x31, 0x32, 0x00, 0x01, 0x00, 0x05, 0x53, 0x00, 0x0e, 0x01,
-  0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02,
-  0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00,
-  0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02,
-  0x03, 0x00, 0x02, 0x6d, 0x00, 0x84, 0x31, 0x33, 0x00, 0x01, 0x00, 0x05,
-  0x57, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00,
-  0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d, 0x00, 0x84, 0x32, 0x31,
-  0x00, 0x01, 0x00, 0x05, 0x5b, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d,
-  0x00, 0x84, 0x32, 0x32, 0x00, 0x01, 0x00, 0x05, 0x5f, 0x00, 0x0e, 0x01,
-  0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02,
-  0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00,
-  0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02,
-  0x03, 0x00, 0x02, 0x6d, 0x00, 0x84, 0x32, 0x33, 0x00, 0x01, 0x00, 0x05,
-  0x63, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00,
-  0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d, 0x00, 0x84, 0x33, 0x31,
-  0x00, 0x01, 0x00, 0x05, 0x67, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02, 0x03, 0x00, 0x02, 0x6d,
-  0x00, 0x84, 0x33, 0x32, 0x00, 0x01, 0x00, 0x05, 0x6b, 0x00, 0x0e, 0x01,
-  0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02,
-  0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00,
-  0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0b, 0x00, 0x02,
-  0x03, 0x00, 0x02, 0x6d, 0x00, 0x84, 0x33, 0x33, 0x00, 0x01, 0x00, 0x05,
-  0x6f, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x15, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01,
-  0x00, 0x06, 0x71, 0x00, 0x01, 0x80, 0xfe, 0xff, 0xff, 0xff, 0x1d, 0x00,
-  0x16, 0xfe, 0xff, 0xff, 0xff, 0x09, 0x00, 0x06, 0x4f, 0x00, 0x02, 0x53,
-  0x00, 0x02, 0x57, 0x00, 0x02, 0x5b, 0x00, 0x02, 0x5f, 0x00, 0x02, 0x63,
-  0x00, 0x02, 0x67, 0x00, 0x02, 0x6b, 0x00, 0x02, 0x6f, 0x00, 0x02, 0x96,
-  0x00, 0x12, 0xfd, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x0a, 0x00,
-  0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x12, 0x00, 0x02,
-  0x0a, 0x00, 0x02, 0x44, 0x00, 0x8e, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69,
-  0x6f, 0x6e, 0x73, 0x01, 0x00, 0x01, 0x00, 0x18, 0x00, 0x09, 0x04, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff,
-  0xff, 0xff, 0x10, 0x00, 0x01, 0x80, 0x01, 0x00, 0x81, 0x01, 0x00, 0x0f,
-  0x02, 0x00, 0x02, 0x04, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x09, 0x00,
-  0x02, 0x2c, 0x00, 0x95, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x43, 0x32,
-  0x00, 0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x43, 0x32, 0x00,
-  0x00, 0xfd, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0x00, 0x03, 0x12,
-  0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80,
-  0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02,
-  0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00,
-  0x06, 0x0e, 0x00, 0x02, 0x06, 0x00, 0x02, 0x49, 0x00, 0x86, 0x67, 0x6e,
-  0x6f, 0x72, 0x65, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x0e, 0x00, 0x02, 0x06, 0x00, 0x02, 0x49,
-  0x00, 0x8a, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x01, 0x00, 0x01, 0x00, 0x19,
-  0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff,
-  0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff,
-  0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00,
-  0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12,
-  0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0e, 0x00,
-  0x02, 0x06, 0x00, 0x02, 0x54, 0x00, 0x86, 0x61, 0x72, 0x67, 0x65, 0x74,
-  0x01, 0x00, 0x05, 0x0b, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01,
-  0x80, 0x08, 0x00, 0x06, 0x0d, 0x00, 0x02, 0x05, 0x00, 0x02, 0x56, 0x00,
-  0x86, 0x61, 0x6c, 0x75, 0x65, 0x00, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01,
-  0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0d, 0x00, 0x02, 0x05,
-  0x00, 0x02, 0x56, 0x00, 0x8a, 0x61, 0x6c, 0x75, 0x65, 0x00, 0x01, 0x00,
-  0x01, 0x00, 0x1b, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe,
-  0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff,
-  0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69,
-  0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02,
-  0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08,
-  0x00, 0x06, 0x0e, 0x00, 0x02, 0x06, 0x00, 0x02, 0x53, 0x00, 0x86, 0x74,
-  0x64, 0x44, 0x65, 0x76, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c,
-  0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0e, 0x00, 0x02, 0x06, 0x00, 0x02,
-  0x53, 0x00, 0x8a, 0x74, 0x64, 0x44, 0x65, 0x76, 0x01, 0x00, 0x01, 0x00,
-  0x1c, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff,
-  0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff,
-  0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67,
-  0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0x15, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x06, 0x71, 0x00, 0x01, 0x80, 0xfe, 0xff, 0xff, 0xff, 0x1d, 0x00, 0x16,
-  0xfe, 0xff, 0xff, 0xff, 0x04, 0x00, 0x06, 0xa0, 0x00, 0x02, 0x0b, 0x00,
-  0x02, 0xa6, 0x00, 0x02, 0xaa, 0x00, 0x02, 0xad, 0x00, 0x12, 0xfd, 0xff,
-  0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x13, 0x00, 0x02, 0x0b, 0x00, 0x02, 0x44,
-  0x00, 0x90, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e,
-  0x00, 0x01, 0x00, 0x01, 0x00, 0x17, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff,
-  0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85,
-  0x74, 0x72, 0x69, 0x6e, 0x67, 0xfe, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x01,
-  0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0c, 0x00, 0x02, 0x04,
-  0x00, 0x02, 0x4e, 0x00, 0x88, 0x61, 0x6d, 0x65, 0x01, 0x00, 0x01, 0x00,
-  0x2f, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff,
-  0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff,
-  0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67,
-  0xfe, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80,
-  0x08, 0x00, 0x06, 0x0d, 0x00, 0x02, 0x05, 0x00, 0x02, 0x54, 0x00, 0x8a,
-  0x6f, 0x74, 0x61, 0x6c, 0x00, 0x01, 0x00, 0x01, 0x00, 0x26, 0x00, 0x09,
-  0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b,
-  0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00,
-  0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0xfe, 0xff, 0xff,
-  0xff, 0x67, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x6b, 0x00, 0x02, 0xfe,
-  0xff, 0xff, 0xff, 0xa0, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x6f, 0x00,
-  0x02, 0xfe, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01,
-  0x80, 0x08, 0x00, 0x06, 0x0e, 0x00, 0x02, 0x06, 0x00, 0x02, 0x48, 0x00,
-  0x8a, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x01, 0x00, 0x01, 0x00, 0x2a, 0x00,
-  0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00,
-  0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06,
-  0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0xfe, 0xff,
-  0xff, 0xff, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00,
-  0x06, 0x0e, 0x00, 0x02, 0x06, 0x00, 0x02, 0x43, 0x00, 0x8a, 0x6f, 0x6f,
-  0x72, 0x64, 0x73, 0x01, 0x00, 0x01, 0x00, 0x16, 0x00, 0x09, 0x05, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff,
-  0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73,
-  0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0xfe, 0xff, 0xff, 0xff, 0x0a,
-  0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x16, 0x00,
-  0x02, 0x0e, 0x00, 0x02, 0x44, 0x00, 0x92, 0x6e, 0x61, 0x4d, 0x65, 0x61,
-  0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x01, 0x00, 0x01, 0x00,
-  0x1d, 0x00, 0x09, 0x04, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff,
-  0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x10, 0x00, 0x01, 0x80, 0x01,
-  0x00, 0x81, 0x01, 0x00, 0x0f, 0x03, 0x00, 0x02, 0x04, 0x00, 0x02, 0xfe,
-  0xff, 0xff, 0xff, 0x09, 0x00, 0x02, 0x2c, 0x00, 0x95, 0x5f, 0x5f, 0x41,
-  0x6e, 0x6f, 0x6e, 0x43, 0x33, 0x00, 0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e,
-  0x6f, 0x6e, 0x43, 0x33, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0xfd, 0xff,
-  0xff, 0xff, 0x00, 0x03, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00,
-  0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00,
-  0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00,
-  0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00,
-  0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00,
-  0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00,
-  0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00,
-  0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00,
-  0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00,
-  0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00,
-  0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00,
-  0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00,
-  0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00,
-  0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00,
-  0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00,
-  0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80,
-  0x08, 0x00, 0x06, 0x0c, 0x00, 0x02, 0x04, 0x00, 0x02, 0x54, 0x00, 0x84,
-  0x79, 0x70, 0x65, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x0c, 0x00, 0x02, 0x04, 0x00, 0x02, 0x54,
-  0x00, 0x88, 0x79, 0x70, 0x65, 0x01, 0x00, 0x01, 0x00, 0x1e, 0x00, 0x09,
-  0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b,
-  0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00,
-  0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01,
-  0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01,
-  0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0e, 0x00, 0x02, 0x06,
-  0x00, 0x02, 0x49, 0x00, 0x86, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x01, 0x00,
-  0x05, 0xa0, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x05, 0x01, 0x00, 0x02, 0x04,
-  0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x16,
-  0x00, 0x02, 0x0e, 0x00, 0x02, 0x52, 0x00, 0x8e, 0x65, 0x66, 0x65, 0x72,
-  0x65, 0x6e, 0x63, 0x65, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x01, 0x00, 0x05,
-  0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x16,
-  0x00, 0x02, 0x0e, 0x00, 0x02, 0x52, 0x00, 0x92, 0x65, 0x66, 0x65, 0x72,
-  0x65, 0x6e, 0x63, 0x65, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x01, 0x00, 0x01,
-  0x00, 0x1f, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff,
-  0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff,
-  0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e,
-  0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x05, 0x01, 0x00, 0x02, 0x04, 0x00,
-  0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12,
-  0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0d, 0x00,
-  0x02, 0x05, 0x00, 0x02, 0x45, 0x00, 0x86, 0x70, 0x6f, 0x63, 0x68, 0x00,
-  0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08,
-  0x00, 0x06, 0x0d, 0x00, 0x02, 0x05, 0x00, 0x02, 0x45, 0x00, 0x8a, 0x70,
-  0x6f, 0x63, 0x68, 0x00, 0x01, 0x00, 0x01, 0x00, 0x20, 0x00, 0x09, 0x05,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff,
-  0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02,
-  0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01,
-  0x00, 0x05, 0x01, 0x00, 0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x0d, 0x00, 0x02, 0x05, 0x00, 0x02, 0x46,
-  0x00, 0x86, 0x69, 0x72, 0x73, 0x74, 0x00, 0x01, 0x00, 0x05, 0x0a, 0x00,
-  0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0d, 0x00, 0x02,
-  0x05, 0x00, 0x02, 0x46, 0x00, 0x8a, 0x69, 0x72, 0x73, 0x74, 0x00, 0x01,
-  0x00, 0x01, 0x00, 0x21, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13,
-  0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72,
-  0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02,
-  0x01, 0x00, 0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80,
-  0x08, 0x00, 0x06, 0x0e, 0x00, 0x02, 0x06, 0x00, 0x02, 0x53, 0x00, 0x86,
-  0x65, 0x63, 0x6f, 0x6e, 0x64, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80,
-  0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0e, 0x00, 0x02, 0x06, 0x00,
-  0x02, 0x53, 0x00, 0x8a, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x01, 0x00, 0x01,
-  0x00, 0x22, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff,
-  0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff,
-  0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e,
-  0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00,
-  0x06, 0x0d, 0x00, 0x02, 0x05, 0x00, 0x02, 0x54, 0x00, 0x86, 0x68, 0x69,
-  0x72, 0x64, 0x00, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x0d, 0x00, 0x02, 0x05, 0x00, 0x02, 0x54,
-  0x00, 0x8a, 0x68, 0x69, 0x72, 0x64, 0x00, 0x01, 0x00, 0x01, 0x00, 0x23,
-  0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff,
-  0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff,
-  0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00,
-  0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x04,
-  0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0d,
-  0x00, 0x02, 0x05, 0x00, 0x02, 0x56, 0x00, 0x86, 0x61, 0x6c, 0x75, 0x65,
-  0x00, 0x01, 0x00, 0x05, 0xa6, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x0e, 0x00, 0x02, 0x06, 0x00, 0x02, 0x53,
-  0x00, 0x86, 0x74, 0x64, 0x44, 0x65, 0x76, 0x01, 0x00, 0x05, 0xaa, 0x00,
-  0x0e, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x04,
-  0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x12,
-  0x00, 0x02, 0x0a, 0x00, 0x02, 0x49, 0x00, 0x8a, 0x6e, 0x73, 0x74, 0x48,
-  0x65, 0x69, 0x67, 0x68, 0x74, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80,
-  0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x12, 0x00, 0x02, 0x0a, 0x00,
-  0x02, 0x49, 0x00, 0x8e, 0x6e, 0x73, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68,
-  0x74, 0x01, 0x00, 0x01, 0x00, 0x24, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff,
-  0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85,
-  0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x12, 0x00, 0x02, 0x0a, 0x00, 0x02, 0x54,
-  0x00, 0x8a, 0x61, 0x72, 0x67, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x01,
-  0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00,
-  0x06, 0x12, 0x00, 0x02, 0x0a, 0x00, 0x02, 0x54, 0x00, 0x8e, 0x61, 0x72,
-  0x67, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x01, 0x00, 0x01, 0x00, 0x25,
-  0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff,
-  0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff,
-  0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00,
-  0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x04,
-  0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0d,
-  0x00, 0x02, 0x05, 0x00, 0x02, 0x54, 0x00, 0x86, 0x6f, 0x74, 0x61, 0x6c,
-  0x00, 0x01, 0x00, 0x05, 0xb3, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x12, 0x00, 0x02, 0x0a, 0x00, 0x02, 0x44,
-  0x00, 0x8a, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x01,
-  0x00, 0x05, 0x98, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02,
-  0x01, 0x00, 0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80,
-  0x08, 0x00, 0x06, 0x0e, 0x00, 0x02, 0x06, 0x00, 0x02, 0x56, 0x00, 0x86,
-  0x73, 0x63, 0x61, 0x6c, 0x65, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80,
-  0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0e, 0x00, 0x02, 0x06, 0x00,
-  0x02, 0x56, 0x00, 0x8a, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x01, 0x00, 0x01,
-  0x00, 0x27, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff,
-  0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff,
-  0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e,
-  0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00,
-  0x06, 0x13, 0x00, 0x02, 0x0b, 0x00, 0x02, 0x47, 0x00, 0x8c, 0x50, 0x53,
-  0x42, 0x61, 0x73, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x01, 0x00, 0x05,
-  0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x13,
-  0x00, 0x02, 0x0b, 0x00, 0x02, 0x47, 0x00, 0x90, 0x50, 0x53, 0x42, 0x61,
-  0x73, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x01, 0x00, 0x01, 0x00, 0x28,
-  0x00, 0x09, 0x04, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff,
-  0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x10, 0x00, 0x01, 0x80, 0x01, 0x00,
-  0x81, 0x01, 0x00, 0x0f, 0x04, 0x00, 0x02, 0x04, 0x00, 0x02, 0xfe, 0xff,
-  0xff, 0xff, 0x09, 0x00, 0x02, 0x2c, 0x00, 0x95, 0x5f, 0x5f, 0x41, 0x6e,
-  0x6f, 0x6e, 0x43, 0x34, 0x00, 0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e, 0x6f,
-  0x6e, 0x43, 0x34, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff,
-  0xff, 0x00, 0x03, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01,
-  0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03,
-  0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01,
-  0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03,
-  0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x09,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0x58, 0x00, 0x02, 0x01, 0x00, 0x06, 0x1e,
-  0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x09,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0x59, 0x00, 0x02, 0x01, 0x00, 0x06, 0x22,
-  0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06,
-  0x09, 0x00, 0x02, 0x01, 0x00, 0x02, 0x5a, 0x00, 0x02, 0x01, 0x00, 0x06,
-  0x26, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00,
-  0x06, 0x0f, 0x00, 0x02, 0x07, 0x00, 0x02, 0x53, 0x00, 0x88, 0x69, 0x67,
-  0x6d, 0x61, 0x58, 0x58, 0x00, 0x01, 0x00, 0x05, 0x2a, 0x00, 0x0e, 0x01,
-  0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02,
-  0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00,
-  0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0f, 0x00, 0x02,
-  0x07, 0x00, 0x02, 0x53, 0x00, 0x88, 0x69, 0x67, 0x6d, 0x61, 0x58, 0x59,
-  0x00, 0x01, 0x00, 0x05, 0x2e, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x0f, 0x00, 0x02, 0x07, 0x00, 0x02, 0x53,
-  0x00, 0x88, 0x69, 0x67, 0x6d, 0x61, 0x58, 0x5a, 0x00, 0x01, 0x00, 0x05,
-  0x32, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00,
-  0x06, 0x0f, 0x00, 0x02, 0x07, 0x00, 0x02, 0x53, 0x00, 0x88, 0x69, 0x67,
-  0x6d, 0x61, 0x59, 0x59, 0x00, 0x01, 0x00, 0x05, 0x36, 0x00, 0x0e, 0x01,
-  0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02,
-  0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00,
-  0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0f, 0x00, 0x02,
-  0x07, 0x00, 0x02, 0x53, 0x00, 0x88, 0x69, 0x67, 0x6d, 0x61, 0x59, 0x5a,
-  0x00, 0x01, 0x00, 0x05, 0x3a, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x0f, 0x00, 0x02, 0x07, 0x00, 0x02, 0x53,
-  0x00, 0x88, 0x69, 0x67, 0x6d, 0x61, 0x5a, 0x5a, 0x00, 0x01, 0x00, 0x05,
-  0x3e, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00,
-  0x06, 0x15, 0x00, 0x02, 0x0d, 0x00, 0x02, 0x47, 0x00, 0x8e, 0x50, 0x53,
-  0x43, 0x6f, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x01,
-  0x00, 0x05, 0x78, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x05, 0xff, 0xff, 0xff,
-  0xff, 0x15, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01,
-  0x00, 0x06, 0x71, 0x00, 0x01, 0x80, 0xfe, 0xff, 0xff, 0xff, 0x1d, 0x00,
-  0x16, 0xfe, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x06, 0x1e, 0x00, 0x02, 0x22,
-  0x00, 0x02, 0x26, 0x00, 0x02, 0x2a, 0x00, 0x02, 0x2e, 0x00, 0x02, 0x32,
-  0x00, 0x02, 0x36, 0x00, 0x02, 0x3a, 0x00, 0x02, 0x3e, 0x00, 0x02, 0x78,
-  0x00, 0x02, 0x21, 0x01, 0x00, 0x11, 0xfd, 0xff, 0xff, 0xff, 0x00, 0x0b,
-  0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x04, 0x00,
-  0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12,
-  0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0e, 0x00,
-  0x02, 0x06, 0x00, 0x02, 0x48, 0x00, 0x86, 0x73, 0x63, 0x61, 0x6c, 0x65,
-  0x01, 0x00, 0x05, 0xb5, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x05, 0x01, 0x00,
-  0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00,
-  0x06, 0x0e, 0x00, 0x02, 0x06, 0x00, 0x02, 0x4c, 0x00, 0x86, 0x73, 0x63,
-  0x61, 0x6c, 0x65, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x0e, 0x00, 0x02, 0x06, 0x00, 0x02, 0x4c,
-  0x00, 0x8a, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x01, 0x00, 0x01, 0x00, 0x2b,
-  0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff,
-  0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff,
-  0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00,
-  0x0b, 0x01, 0x01, 0x00, 0x05, 0x01, 0x00, 0x02, 0x04, 0x00, 0x02, 0x01,
-  0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01,
-  0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0e, 0x00, 0x02, 0x06,
-  0x00, 0x02, 0x50, 0x00, 0x86, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x01, 0x00,
-  0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06,
-  0x0e, 0x00, 0x02, 0x06, 0x00, 0x02, 0x50, 0x00, 0x8a, 0x73, 0x63, 0x61,
-  0x6c, 0x65, 0x01, 0x00, 0x01, 0x00, 0x2c, 0x00, 0x09, 0x05, 0x00, 0x02,
-  0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff,
-  0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00,
-  0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x05,
-  0x01, 0x00, 0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80,
-  0x08, 0x00, 0x06, 0x14, 0x00, 0x02, 0x0c, 0x00, 0x02, 0x43, 0x00, 0x8c,
-  0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x01,
-  0x00, 0x05, 0x0e, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02,
-  0x01, 0x00, 0x02, 0x04, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80,
-  0x08, 0x00, 0x06, 0x0e, 0x00, 0x02, 0x06, 0x00, 0x02, 0x43, 0x00, 0x86,
-  0x6f, 0x6f, 0x72, 0x64, 0x73, 0x01, 0x00, 0x05, 0xb7, 0x00, 0x0e, 0x01,
-  0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x04, 0x00, 0x02,
-  0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00,
-  0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0e, 0x00, 0x02,
-  0x06, 0x00, 0x02, 0x53, 0x00, 0x86, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x01,
-  0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00,
-  0x06, 0x0e, 0x00, 0x02, 0x06, 0x00, 0x02, 0x53, 0x00, 0x8a, 0x6f, 0x75,
-  0x72, 0x63, 0x65, 0x01, 0x00, 0x01, 0x00, 0x2d, 0x00, 0x09, 0x05, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff,
-  0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73,
-  0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00,
-  0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x24, 0x00, 0x02, 0x01, 0x01,
-  0x00, 0x01, 0x01, 0x00, 0x02, 0xff, 0xff, 0xff, 0xff, 0x00, 0x03, 0x71,
-  0x00, 0x01, 0x80, 0xfe, 0xff, 0xff, 0xff, 0x1d, 0x00, 0x16, 0xfe, 0xff,
-  0xff, 0xff, 0x15, 0x00, 0x06, 0xd2, 0x00, 0x02, 0xa0, 0x00, 0x02, 0xd8,
-  0x00, 0x02, 0xdc, 0x00, 0x02, 0xe0, 0x00, 0x02, 0xe4, 0x00, 0x02, 0xe8,
-  0x00, 0x02, 0xa6, 0x00, 0x02, 0xaa, 0x00, 0x02, 0xf0, 0x00, 0x02, 0xf4,
-  0x00, 0x02, 0xb3, 0x00, 0x02, 0x98, 0x00, 0x02, 0xfc, 0x00, 0x03, 0x01,
-  0x00, 0x01, 0xb5, 0x00, 0x02, 0x27, 0x01, 0x00, 0x01, 0x2b, 0x01, 0x00,
-  0x01, 0x0e, 0x00, 0x02, 0xb7, 0x00, 0x02, 0x33, 0x01, 0x00, 0x01, 0x36,
-  0x01, 0x00, 0x11, 0xfd, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x0a,
-  0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0e, 0x00,
-  0x02, 0x06, 0x00, 0x02, 0x48, 0x00, 0x8a, 0x65, 0x69, 0x67, 0x68, 0x74,
-  0x01, 0x00, 0x01, 0x00, 0x33, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00,
-  0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74,
-  0x72, 0x69, 0x6e, 0x67, 0xfe, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x02, 0xfe,
-  0xff, 0xff, 0xff, 0x36, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x3a, 0x00,
-  0x02, 0xfe, 0xff, 0xff, 0xff, 0xe8, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff,
-  0xe4, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x2b, 0x01, 0x00, 0x01, 0xfe,
-  0xff, 0xff, 0xff, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08,
-  0x00, 0x06, 0x0d, 0x00, 0x02, 0x05, 0x00, 0x02, 0x59, 0x00, 0x8a, 0x41,
-  0x78, 0x69, 0x73, 0x00, 0x01, 0x00, 0x01, 0x00, 0x32, 0x00, 0x09, 0x05,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff,
-  0xff, 0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02,
-  0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0xfe, 0xff, 0xff, 0xff,
-  0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x14,
-  0x00, 0x02, 0x0c, 0x00, 0x02, 0x53, 0x00, 0x90, 0x74, 0x61, 0x74, 0x69,
-  0x6f, 0x6e, 0x43, 0x6f, 0x6f, 0x72, 0x64, 0x01, 0x00, 0x01, 0x00, 0x30,
-  0x00, 0x09, 0x04, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff,
-  0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x10, 0x00, 0x01, 0x80, 0x01, 0x00,
-  0x81, 0x01, 0x00, 0x0f, 0x07, 0x00, 0x02, 0x04, 0x00, 0x02, 0xfe, 0xff,
-  0xff, 0xff, 0x09, 0x00, 0x02, 0x2c, 0x00, 0x95, 0x5f, 0x5f, 0x41, 0x6e,
-  0x6f, 0x6e, 0x43, 0x37, 0x00, 0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e, 0x6f,
-  0x6e, 0x43, 0x37, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff,
-  0xff, 0x00, 0x03, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01,
-  0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03,
-  0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08,
-  0x00, 0x06, 0x0c, 0x00, 0x02, 0x04, 0x00, 0x02, 0x4e, 0x00, 0x84, 0x61,
-  0x6d, 0x65, 0x01, 0x00, 0x05, 0xb1, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x0d, 0x00, 0x02, 0x05, 0x00, 0x02, 0x58,
-  0x00, 0x86, 0x41, 0x78, 0x69, 0x73, 0x00, 0x01, 0x00, 0x05, 0x0a, 0x00,
-  0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0d, 0x00, 0x02,
-  0x05, 0x00, 0x02, 0x58, 0x00, 0x8a, 0x41, 0x78, 0x69, 0x73, 0x00, 0x01,
-  0x00, 0x01, 0x00, 0x31, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13,
-  0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72,
-  0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02,
-  0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80,
-  0x08, 0x00, 0x06, 0x0d, 0x00, 0x02, 0x05, 0x00, 0x02, 0x59, 0x00, 0x86,
-  0x41, 0x78, 0x69, 0x73, 0x00, 0x01, 0x00, 0x05, 0x3a, 0x01, 0x00, 0x0d,
-  0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00,
-  0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12,
-  0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0e, 0x00,
-  0x02, 0x06, 0x00, 0x02, 0x48, 0x00, 0x86, 0x65, 0x69, 0x67, 0x68, 0x74,
-  0x01, 0x00, 0x05, 0x38, 0x01, 0x00, 0x0d, 0x01, 0x01, 0x00, 0x01, 0x01,
-  0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x16, 0x00, 0x02, 0x0e, 0x00, 0x02, 0x48,
-  0x00, 0x8e, 0x65, 0x6d, 0x69, 0x73, 0x70, 0x68, 0x65, 0x72, 0x65, 0x5a,
-  0x6f, 0x6e, 0x65, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x16, 0x00, 0x02, 0x0e, 0x00, 0x02, 0x48,
-  0x00, 0x92, 0x65, 0x6d, 0x69, 0x73, 0x70, 0x68, 0x65, 0x72, 0x65, 0x5a,
-  0x6f, 0x6e, 0x65, 0x01, 0x00, 0x01, 0x00, 0x34, 0x00, 0x09, 0x05, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff,
-  0xff, 0xff, 0x00, 0x13, 0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73,
-  0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00,
-  0x05, 0x01, 0x00, 0x02, 0x15, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01,
-  0x00, 0x02, 0x01, 0x00, 0x06, 0x71, 0x00, 0x01, 0x80, 0xfe, 0xff, 0xff,
-  0xff, 0x1d, 0x00, 0x16, 0xfe, 0xff, 0xff, 0xff, 0x05, 0x00, 0x06, 0xb1,
-  0x00, 0x02, 0x47, 0x01, 0x00, 0x01, 0x3a, 0x01, 0x00, 0x01, 0x38, 0x01,
-  0x00, 0x01, 0x4f, 0x01, 0x00, 0x01, 0x52, 0x01, 0x00, 0x11, 0xfd, 0xff,
-  0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xaa, 0x00, 0x02, 0xfe, 0xff, 0xff,
-  0xff, 0x4f, 0x01, 0x00, 0x01, 0xfe, 0xff, 0xff, 0xff, 0x4f, 0x00, 0x02,
-  0xfe, 0xff, 0xff, 0xff, 0x53, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x57,
-  0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x14, 0x00, 0x02, 0x0c, 0x00, 0x02, 0x44,
-  0x00, 0x90, 0x6e, 0x61, 0x58, 0x6d, 0x6c, 0x46, 0x6f, 0x72, 0x6d, 0x61,
-  0x74, 0x01, 0x00, 0x01, 0x00, 0x35, 0x00, 0x09, 0x04, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff,
-  0x10, 0x00, 0x01, 0x80, 0x01, 0x00, 0x81, 0x01, 0x00, 0x0f, 0x08, 0x00,
-  0x02, 0x04, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x09, 0x00, 0x02, 0x2c,
-  0x00, 0x95, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x43, 0x38, 0x00, 0x08,
-  0x00, 0x5f, 0x5f, 0x41, 0x6e, 0x6f, 0x6e, 0x43, 0x38, 0x00, 0x00, 0xfd,
-  0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0x00, 0x03, 0x12, 0x00, 0x01,
-  0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x12, 0x00, 0x02, 0x0a, 0x00, 0x02, 0x44,
-  0x00, 0x8a, 0x6e, 0x61, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x01,
-  0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00,
-  0x06, 0x12, 0x00, 0x02, 0x0a, 0x00, 0x02, 0x44, 0x00, 0x8e, 0x6e, 0x61,
-  0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x01, 0x00, 0x01, 0x00, 0x2e,
-  0x00, 0x09, 0x04, 0x00, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff,
-  0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x10, 0x00, 0x01, 0x80, 0x01, 0x00,
-  0x81, 0x01, 0x00, 0x0f, 0x06, 0x00, 0x02, 0x04, 0x00, 0x02, 0xfe, 0xff,
-  0xff, 0xff, 0x09, 0x00, 0x02, 0x2c, 0x00, 0x95, 0x5f, 0x5f, 0x41, 0x6e,
-  0x6f, 0x6e, 0x43, 0x36, 0x00, 0x08, 0x00, 0x5f, 0x5f, 0x41, 0x6e, 0x6f,
-  0x6e, 0x43, 0x36, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff,
-  0xff, 0x00, 0x03, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02,
-  0x12, 0x00, 0x01, 0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01,
-  0x80, 0x00, 0x03, 0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x00, 0x03,
-  0x02, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08,
-  0x00, 0x06, 0x0c, 0x00, 0x02, 0x04, 0x00, 0x02, 0x4e, 0x00, 0x84, 0x61,
-  0x6d, 0x65, 0x01, 0x00, 0x05, 0xb1, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00,
-  0x01, 0x80, 0x08, 0x00, 0x06, 0x13, 0x00, 0x02, 0x0b, 0x00, 0x02, 0x43,
-  0x00, 0x8c, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73,
-  0x00, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80,
-  0x08, 0x00, 0x06, 0x13, 0x00, 0x02, 0x0b, 0x00, 0x02, 0x43, 0x00, 0x90,
-  0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x00, 0x01,
-  0x00, 0x01, 0x00, 0x15, 0x00, 0x09, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02,
-  0xfe, 0xff, 0xff, 0xff, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 0x00, 0x13,
-  0xff, 0xff, 0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72,
-  0x69, 0x6e, 0x67, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02,
-  0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00,
-  0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80,
-  0x08, 0x00, 0x06, 0x0c, 0x00, 0x02, 0x04, 0x00, 0x02, 0x54, 0x00, 0x84,
-  0x79, 0x70, 0x65, 0x01, 0x00, 0x05, 0xd2, 0x00, 0x0e, 0x01, 0x01, 0x00,
-  0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x01,
-  0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01, 0x80,
-  0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x14, 0x00, 0x02, 0x0c, 0x00,
-  0x02, 0x53, 0x00, 0x8c, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f,
-  0x6f, 0x72, 0x64, 0x01, 0x00, 0x05, 0x3c, 0x01, 0x00, 0x0d, 0x01, 0x01,
-  0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01,
-  0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x12, 0x00, 0x01,
-  0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x13, 0x00, 0x02, 0x0b,
-  0x00, 0x02, 0x44, 0x00, 0x8c, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
-  0x69, 0x6f, 0x6e, 0x00, 0x01, 0x00, 0x05, 0xaf, 0x00, 0x0e, 0x01, 0x01,
-  0x00, 0x05, 0x01, 0x00, 0x02, 0x15, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01,
-  0x01, 0x00, 0x02, 0x01, 0x00, 0x06, 0x71, 0x00, 0x01, 0x80, 0xfe, 0xff,
-  0xff, 0xff, 0x1d, 0x00, 0x16, 0xfe, 0xff, 0xff, 0xff, 0x05, 0x00, 0x06,
-  0xb1, 0x00, 0x02, 0x65, 0x01, 0x00, 0x01, 0xd2, 0x00, 0x02, 0x3c, 0x01,
-  0x00, 0x01, 0xaf, 0x00, 0x02, 0x6e, 0x01, 0x00, 0x11, 0xfd, 0xff, 0xff,
-  0xff, 0x00, 0x0b, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00,
-  0x02, 0x12, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06,
-  0x16, 0x00, 0x02, 0x0e, 0x00, 0x02, 0x44, 0x00, 0x8e, 0x6e, 0x61, 0x4d,
-  0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x01, 0x00,
-  0x05, 0xb9, 0x00, 0x0e, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0x01,
-  0x00, 0x02, 0x24, 0x00, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02,
-  0xff, 0xff, 0xff, 0xff, 0x00, 0x03, 0x71, 0x00, 0x01, 0x80, 0xfe, 0xff,
-  0xff, 0xff, 0x1d, 0x00, 0x06, 0x03, 0x00, 0x06, 0xff, 0xff, 0xff, 0xff,
-  0x0c, 0x00, 0x02, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x41, 0x74, 0x74,
-  0x44, 0x65, 0x66, 0x00, 0x03, 0x0a, 0x00, 0x07, 0xfe, 0xff, 0xff, 0xff,
-  0x00, 0x06, 0x05, 0x00, 0x02, 0x47, 0x00, 0x85, 0x44, 0x41, 0x39, 0x34,
-  0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x03, 0x02,
-  0x00, 0x02, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x16, 0x00, 0x02,
-  0x0e, 0x00, 0x02, 0x72, 0x00, 0x8f, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e,
-  0x63, 0x65, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x01, 0x00, 0xff, 0xff, 0xff,
-  0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e, 0x67,
-  0x00, 0x07, 0x74, 0x01, 0x00, 0x82, 0x80, 0x00, 0x00, 0x81, 0x0a, 0x00,
-  0x06, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x06, 0x0a, 0x00, 0x02, 0x30, 0x00,
-  0x89, 0x31, 0x2e, 0x30, 0x31, 0x2e, 0x31, 0x39, 0x39, 0x34, 0xff, 0xff,
-  0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x03, 0x02, 0x00, 0x02, 0x0c,
-  0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0d, 0x00, 0x02, 0x05, 0x00, 0x02,
-  0x65, 0x00, 0x87, 0x70, 0x6f, 0x63, 0x68, 0x00, 0x01, 0x00, 0xff, 0xff,
-  0xff, 0xff, 0x06, 0x00, 0x02, 0x73, 0x00, 0x85, 0x74, 0x72, 0x69, 0x6e,
-  0x67, 0x00, 0x07, 0x74, 0x01, 0x00, 0x00, 0x80, 0x02, 0x00, 0x02, 0x0a,
-  0x00, 0x07, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x06, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x03, 0x02, 0x00,
-  0x02, 0x0c, 0x00, 0x01, 0x80, 0x08, 0x00, 0x06, 0x0c, 0x00, 0x02, 0x04,
-  0x00, 0x02, 0x74, 0x00, 0x85, 0x79, 0x70, 0x65, 0x01, 0x00, 0xfe, 0xff,
-  0xff, 0xff, 0x00, 0x03, 0x06, 0x00, 0x0a, 0x03, 0x00, 0x06, 0xfe, 0xff,
-  0xff, 0xff, 0x02, 0x00, 0x06, 0x5a, 0x01, 0x00, 0x01, 0xb9, 0x00, 0x02,
-  0x73, 0x01, 0x00, 0x11, 0xfd, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff,
-  0xd2, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x33, 0x01, 0x00, 0x01, 0xfe,
-  0xff, 0xff, 0xff, 0xd8, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0xdc, 0x00,
-  0x02, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x81, 0x01, 0x00, 0x00, 0xfe, 0xff,
-  0xff, 0xff, 0xa6, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x3e, 0x00, 0x02,
-  0xfe, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x65,
-  0x01, 0x00, 0x01, 0xfe, 0xff, 0xff, 0xff, 0x47, 0x01, 0x00, 0x01, 0xfe,
-  0xff, 0xff, 0xff, 0xf4, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x1e, 0x00,
-  0x02, 0xfe, 0xff, 0xff, 0xff, 0x22, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff,
-  0x26, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x27, 0x01, 0x00, 0x01, 0xfe,
-  0xff, 0xff, 0xff, 0x5b, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x5f, 0x00,
-  0x02, 0xfe, 0xff, 0xff, 0xff, 0x63, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff,
-  0xe0, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x5a, 0x01, 0x00, 0x01, 0xfe,
-  0xff, 0xff, 0xff, 0x42, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x2a, 0x00,
-  0x02, 0xfe, 0xff, 0xff, 0xff, 0x2e, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff,
-  0x32, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x6d, 0x00, 0x0e, 0xfe, 0xff,
-  0xff, 0xff, 0x00, 0x03, 0xfe, 0xff, 0xff, 0xff, 0x1d, 0x00, 0x0e, 0xfe,
-  0xff, 0xff, 0xff, 0x1d, 0x00, 0x06, 0x09, 0x00, 0x06, 0x44, 0x00, 0x02,
-  0x9a, 0x00, 0x02, 0xbb, 0x00, 0x02, 0x02, 0x01, 0x00, 0x01, 0x7a, 0x00,
-  0x02, 0x5c, 0x01, 0x00, 0x01, 0x3e, 0x01, 0x00, 0x01, 0x56, 0x01, 0x00,
-  0x01, 0x11, 0x00, 0x02, 0xfe, 0xff, 0xff, 0xff, 0x0d, 0x00, 0x0e, 0xfe,
-  0xff, 0xff, 0xff, 0x0d, 0x00, 0x0e, 0xfe, 0xff, 0xff, 0xff, 0x1d, 0x00,
-  0x0e, 0xfe, 0xff, 0xff, 0xff, 0x1d, 0x00, 0x12, 0x01, 0x00, 0x02, 0x03,
-  0x00, 0x06, 0xfe, 0xff, 0xff, 0xff, 0x01, 0x00, 0x06, 0x30, 0x00, 0x02,
-  0x43, 0x00, 0xaf, 0x3a, 0x5c, 0x44, 0x61, 0x74, 0x61, 0x5c, 0x76, 0x73,
-  0x31, 0x30, 0x5c, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x5c,
-  0x64, 0x79, 0x6e, 0x61, 0x6e, 0x65, 0x74, 0x5f, 0x33, 0x5f, 0x30, 0x33,
-  0x5f, 0x30, 0x30, 0x2f, 0x44, 0x79, 0x6e, 0x61, 0x4d, 0x4c, 0x2e, 0x78,
-  0x73, 0x64, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f,
-  0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f,
-  0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f,
-  0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f,
-  0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f,
-  0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f, 0x00, 0x7f,
-  0x00, 0x7f, 0x00, 0x7f, 0x00, 0x63
-};
-
diff --git a/dynadjust/include/io/DynaML-schema.hxx b/dynadjust/include/io/DynaML-schema.hxx
deleted file mode 100644
index 0f8fedebf..000000000
--- a/dynadjust/include/io/DynaML-schema.hxx
+++ /dev/null
@@ -1,8 +0,0 @@
-// Automatically generated. Do not edit.
-//
-
-/// \cond
-#include <xercesc/util/XercesDefs.hpp>
-/// \endcond
-
-extern const XMLByte DynaML_schema[11430UL];
diff --git a/dynadjust/include/io/bms_file.cpp b/dynadjust/include/io/bms_file.cpp
index 0f78268a3..6b961705a 100644
--- a/dynadjust/include/io/bms_file.cpp
+++ b/dynadjust/include/io/bms_file.cpp
@@ -147,6 +147,14 @@ std::uint64_t BmsFile::LoadFile(const std::string& bms_filename,
     ReadFileInfo(bms_file);
     ReadFileMetadata(bms_file, bms_meta);
 
+    // measurement_t grew by observation_epoch in v1.2; record layout requires a v1.2 file.
+    if (!versionAtLeast(1, 2)) {
+      std::ostringstream os;
+      os << "BMS file version " << GetVersion()
+         << " predates observation_epoch support (v1.2); please re-run dnaimport.";
+      throw std::runtime_error(os.str());
+    }
+
     vbinary_msr->reserve(bms_meta.binCount);
     for (msr = 0; msr < bms_meta.binCount; msr++) {
       bms_file.read(reinterpret_cast<char*>(&measRecord),
diff --git a/dynadjust/include/io/bst_file.cpp b/dynadjust/include/io/bst_file.cpp
index 185ad46de..e1c757985 100644
--- a/dynadjust/include/io/bst_file.cpp
+++ b/dynadjust/include/io/bst_file.cpp
@@ -128,6 +128,14 @@ std::uint64_t BstFile::LoadFile(const std::string& bst_filename,
     ReadFileInfo(bst_file);
     ReadFileMetadata(bst_file, bst_meta);
 
+    // station_t grew by observation_epoch in v1.2; bulk I/O requires a v1.2 layout.
+    if (!versionAtLeast(1, 2)) {
+      std::ostringstream os;
+      os << "BST file version " << GetVersion()
+         << " predates observation_epoch support (v1.2); please re-run dnaimport.";
+      throw std::runtime_error(os.str());
+    }
+
     vbinary_stn->resize(bst_meta.binCount);
     static_assert(std::is_trivially_copyable_v<station_t>,
                   "station_t must be trivially copyable for bulk I/O");
diff --git a/dynadjust/include/io/dnaiodnatypes.hpp b/dynadjust/include/io/dnaiodnatypes.hpp
index b2828d6a0..500656f0e 100644
--- a/dynadjust/include/io/dnaiodnatypes.hpp
+++ b/dynadjust/include/io/dnaiodnatypes.hpp
@@ -94,6 +94,7 @@ typedef struct {
 	UINT32 msr_targ_ht;
 	UINT32 msr_id_msr;
 	UINT32 msr_id_cluster;
+	UINT32 msr_gps_obs_epoch;	// DNA v3.02+ column; 0 if file predates v3.02
 } dna_msr_fields;
 
 // DNA version 1.00
@@ -440,6 +441,82 @@ class dna_msr_fields_301
 };
 
 
+// DNA version 3.02 - adds a 25th column for the observation epoch.
+// Columns 0-23 are identical to version 3.01.
+template <class U>
+struct _dna_msr_fields_302_
+{
+	static const U _locations_[25];
+	static const U _widths_[25];
+};
+
+template <class U>
+const U _dna_msr_fields_302_<U>::_locations_[25] =
+{
+	0,		// msr type
+	1,		// ignore
+	2,		// instrument name
+	22,		// target 1
+	42,		// target 2
+	62,		// linear measurement
+	62,		// gps measurement
+	82,		// gps vcv 1
+	102,	// gps vcv 2
+	122,	// gps vcv 3
+	62,		// gps vscale
+	72,		// gps pscale
+	82,		// gps lscale
+	92,		// gps hscale
+	102,	// gps ref frame
+	122,	// gps epoch (reference-frame epoch)
+	76,		// angular d
+	80,		// angular m
+	82,		// angular s
+	90,		// standard deviation
+	99,		// inst height
+	106,	// target height
+	142,	// msr id
+	152,	// cluster id
+	162		// gps observation epoch
+};
+
+template <class U>
+const U _dna_msr_fields_302_<U>::_widths_[25] =
+{
+	1,		// msr type
+	1,		// ignore
+	20,		// instrument name
+	20,		// target 1
+	20,		// target 2
+	14,		// linear measurement
+	20,		// gps measurement
+	20,		// gps vcv 1
+	20,		// gps vcv 2
+	20,		// gps vcv 3
+	10,		// gps vscale
+	10,		// gps pscale
+	10,		// gps lscale
+	10,		// gps hscale
+	20,		// gps ref frame
+	20,		// gps epoch (reference-frame epoch)
+	4,		// angular d
+	2,		// angular m
+	8,		// angular s
+	9,		// standard deviation
+	7,		// inst height
+	7,		// target height
+	10,		// msr id
+	10,		// cluster id
+	20		// gps observation epoch
+};
+
+class dna_msr_fields_302
+	: public _dna_msr_fields_302_<UINT16>
+{
+public:
+};
+
+
 
 template <typename U>
 void assignDNASTNFieldParameters(const UINT16* locs, const UINT16* widths, 
@@ -523,7 +600,9 @@ void assignDNAMSRFieldParameters(const UINT16* locs, const UINT16* widths,
 	dflocs.msr_targ_ht = locs[21];
 	dflocs.msr_id_msr = locs[22];
 	dflocs.msr_id_cluster = locs[23];
-	
+	// Default the 3.02-introduced field to 0; a v3.02 branch overrides it below.
+	dflocs.msr_gps_obs_epoch = 0;
+
 	dfwidths.msr_type = widths[0];
 	dfwidths.msr_ignore = widths[1];
 	dfwidths.msr_inst = widths[2];
@@ -548,14 +627,26 @@ void assignDNAMSRFieldParameters(const UINT16* locs, const UINT16* widths,
 	dfwidths.msr_targ_ht = widths[21];
 	dfwidths.msr_id_msr = widths[22];
 	dfwidths.msr_id_cluster = widths[23];
-	
+	dfwidths.msr_gps_obs_epoch = 0;
 }
 	
 
 template <typename U>
-void determineDNAMSRFieldParameters(const std::string& version, 
+void determineDNAMSRFieldParameters(const std::string& version,
 	dna_msr_fields& dflocs, dna_msr_fields& dfwidths, const U u=0)
 {
+	if (iequals(version, "3.02"))
+	{
+		assignDNAMSRFieldParameters<U>(dna_msr_fields_302::_locations_,
+			dna_msr_fields_302::_widths_,
+			dflocs, dfwidths);
+		// The 3.02-introduced observation-epoch column is beyond the shared
+		// 24-entry assigner, so set it explicitly here.
+		dflocs.msr_gps_obs_epoch = dna_msr_fields_302::_locations_[24];
+		dfwidths.msr_gps_obs_epoch = dna_msr_fields_302::_widths_[24];
+		return;
+	}
+
 	if (iequals(version, "3.01"))
 	{
 		assignDNAMSRFieldParameters<U>(dna_msr_fields_301::_locations_,
diff --git a/dynadjust/include/io/dnaiosnxread.cpp b/dynadjust/include/io/dnaiosnxread.cpp
index 83727cc74..42088811d 100644
--- a/dynadjust/include/io/dnaiosnxread.cpp
+++ b/dynadjust/include/io/dnaiosnxread.cpp
@@ -939,10 +939,15 @@ void DnaIoSnx::ParseSinexStn(std::ifstream** snx_file, const char* sinexRec, vdn
 				stn_ptr->SetReferenceFrame(datum.GetName());
 				stn_ptr->SetEpsg(datum.GetEpsgCode_s());
 
-				yy = LongFromString<UINT32>(sBuf.substr(27, 2)), 
-				doy = LongFromString<UINT32>(sBuf.substr(30, 3)), 
+				yy = LongFromString<UINT32>(sBuf.substr(27, 2)),
+				doy = LongFromString<UINT32>(sBuf.substr(30, 3)),
 				ss = ParseDateFromYyDoy(yy, doy, doy_yyyy, std::string(" "));
-				stn_ptr->SetEpoch(stringFromDate(dateFromStringstream_doy_year<boost::gregorian::date, std::stringstream>(ss)));
+				{
+					std::string sinex_epoch = stringFromDate(dateFromStringstream_doy_year<boost::gregorian::date, std::stringstream>(ss));
+					stn_ptr->SetEpoch(sinex_epoch);
+					// SINEX STAX YY:DOY is the observation data window start — record it as the immutable observation epoch
+					stn_ptr->SetObservationEpoch(sinex_epoch);
+				}
 
 				stn_ptr->SetfileOrder(fileOrder++);
 				stn_ptr->SetXAxis_d(DoubleFromString<double>(trimstr(sBuf.substr(47, 21))));
@@ -1310,6 +1315,7 @@ void DnaIoSnx::ParseSinexMsr(std::ifstream** snx_file, const char* sinexRec, vdn
 	dnaGpsPointCluster->SetReferenceFrame(datum.GetName());
 	dnaGpsPointCluster->SetEpsg(datum.GetEpsgCode_s());
 	dnaGpsPointCluster->SetEpoch(vStations->at(0)->GetEpoch());
+	dnaGpsPointCluster->SetObservationEpoch(vStations->at(0)->GetObservationEpoch());
 
 	UINT32 cov_count, ci;
 
@@ -1328,6 +1334,7 @@ void DnaIoSnx::ParseSinexMsr(std::ifstream** snx_file, const char* sinexRec, vdn
 		dnaGpsPoint->SetReferenceFrame(datum.GetName());
 		dnaGpsPoint->SetEpsg(datum.GetEpsgCode_s());
 		dnaGpsPoint->SetEpoch(vStations->at(p)->GetEpoch());
+		dnaGpsPoint->SetObservationEpoch(vStations->at(p)->GetObservationEpoch());
 
 		dnaGpsPoint->SetPscale(dnaGpsPointCluster->GetPscale());
 		dnaGpsPoint->SetLscale(dnaGpsPointCluster->GetLscale());
diff --git a/dynadjust/include/io/dynadjust_file.cpp b/dynadjust/include/io/dynadjust_file.cpp
index ebc0f2806..e98927ae8 100644
--- a/dynadjust/include/io/dynadjust_file.cpp
+++ b/dynadjust/include/io/dynadjust_file.cpp
@@ -83,24 +83,28 @@ void DynadjustFile::ReadFileInfo(std::ifstream& file_stream)
 void DynadjustFile::WriteFileMetadata(std::ofstream& file_stream, binary_file_meta_t& file_meta)
 {
 	// Write the metadata
-	file_stream.write(reinterpret_cast<char *>(&file_meta.binCount), sizeof(std::uint64_t)); 
-	file_stream.write(reinterpret_cast<char *>(&file_meta.reduced), sizeof(bool)); 
-	file_stream.write(reinterpret_cast<char *>(file_meta.modifiedBy), MOD_NAME_WIDTH); 
-	
-	// Write the epsg code and epoch
+	file_stream.write(reinterpret_cast<char *>(&file_meta.binCount), sizeof(std::uint64_t));
+	file_stream.write(reinterpret_cast<char *>(&file_meta.reduced), sizeof(bool));
+	file_stream.write(reinterpret_cast<char *>(file_meta.modifiedBy), MOD_NAME_WIDTH);
+
+	// Write the epsg code and epochs (reference frame + observation)
 	file_stream.write(reinterpret_cast<char *>(file_meta.epsgCode), STN_EPSG_WIDTH);
 	file_stream.write(reinterpret_cast<char *>(file_meta.epoch), STN_EPOCH_WIDTH);
+	// v1.2+: write observation_epoch after reference-frame epoch
+	file_stream.write(reinterpret_cast<char *>(file_meta.observation_epoch), STN_EPOCH_WIDTH);
 
 	file_stream.write(reinterpret_cast<char*>(&file_meta.reftran), sizeof(bool));
 	file_stream.write(reinterpret_cast<char*>(&file_meta.geoid), sizeof(bool));
 
 	// Write file count and file meta
-	file_stream.write(reinterpret_cast<char *>(&file_meta.inputFileCount), sizeof(std::uint64_t)); 
+	file_stream.write(reinterpret_cast<char *>(&file_meta.inputFileCount), sizeof(std::uint64_t));
 	for (std::uint64_t i(0); i<file_meta.inputFileCount; ++i)
 	{
-		file_stream.write(reinterpret_cast<char *>(file_meta.inputFileMeta[i].filename), FILE_NAME_WIDTH); 
+		file_stream.write(reinterpret_cast<char *>(file_meta.inputFileMeta[i].filename), FILE_NAME_WIDTH);
 		file_stream.write(reinterpret_cast<char *>(file_meta.inputFileMeta[i].epsgCode), STN_EPSG_WIDTH);
 		file_stream.write(reinterpret_cast<char *>(file_meta.inputFileMeta[i].epoch), STN_EPOCH_WIDTH);
+		// v1.2+: observation_epoch per input file
+		file_stream.write(reinterpret_cast<char *>(file_meta.inputFileMeta[i].observation_epoch), STN_EPOCH_WIDTH);
 		file_stream.write(reinterpret_cast<char *>(&file_meta.inputFileMeta[i].filetype), sizeof(UINT16));
 		file_stream.write(reinterpret_cast<char *>(&file_meta.inputFileMeta[i].datatype), sizeof(UINT16));
 	}
@@ -114,15 +118,25 @@ void DynadjustFile::WriteFileMetadata(std::ofstream& file_stream, binary_file_me
 
 void DynadjustFile::ReadFileMetadata(std::ifstream& file_stream, binary_file_meta_t& file_meta)
 {
+	const bool has_observation_epoch = versionAtLeast(1, 2);
+
 	// Read the metadata
-	file_stream.read(reinterpret_cast<char *>(&file_meta.binCount), sizeof(std::uint64_t)); 
-	file_stream.read(reinterpret_cast<char *>(&file_meta.reduced), sizeof(bool)); 
+	file_stream.read(reinterpret_cast<char *>(&file_meta.binCount), sizeof(std::uint64_t));
+	file_stream.read(reinterpret_cast<char *>(&file_meta.reduced), sizeof(bool));
 	file_stream.read(reinterpret_cast<char *>(file_meta.modifiedBy), MOD_NAME_WIDTH);
 
 	// Read the epsg code and epoch
 	file_stream.read(reinterpret_cast<char *>(file_meta.epsgCode), STN_EPSG_WIDTH);
 	file_stream.read(reinterpret_cast<char *>(file_meta.epoch), STN_EPOCH_WIDTH);
 
+	// v1.2+: observation_epoch follows the reference-frame epoch.
+	// Older files fall back to observation_epoch = epoch so legacy files remain loadable
+	// without changing semantics (discontinuity matching uses epoch if observation is empty).
+	if (has_observation_epoch)
+		file_stream.read(reinterpret_cast<char *>(file_meta.observation_epoch), STN_EPOCH_WIDTH);
+	else
+		memcpy(file_meta.observation_epoch, file_meta.epoch, STN_EPOCH_WIDTH);
+
 	file_stream.read(reinterpret_cast<char*>(&file_meta.reftran), sizeof(bool));
 	file_stream.read(reinterpret_cast<char*>(&file_meta.geoid), sizeof(bool));
 
@@ -132,12 +146,16 @@ void DynadjustFile::ReadFileMetadata(std::ifstream& file_stream, binary_file_met
 		delete []file_meta.inputFileMeta;
 
 	file_meta.inputFileMeta = new input_file_meta_t[file_meta.inputFileCount];
-		
+
 	for (std::uint64_t i(0); i<file_meta.inputFileCount; ++i)
 	{
-		file_stream.read(reinterpret_cast<char *>(file_meta.inputFileMeta[i].filename), FILE_NAME_WIDTH); 
+		file_stream.read(reinterpret_cast<char *>(file_meta.inputFileMeta[i].filename), FILE_NAME_WIDTH);
 		file_stream.read(reinterpret_cast<char *>(file_meta.inputFileMeta[i].epsgCode), STN_EPSG_WIDTH);
 		file_stream.read(reinterpret_cast<char *>(file_meta.inputFileMeta[i].epoch), STN_EPOCH_WIDTH);
+		if (has_observation_epoch)
+			file_stream.read(reinterpret_cast<char *>(file_meta.inputFileMeta[i].observation_epoch), STN_EPOCH_WIDTH);
+		else
+			memcpy(file_meta.inputFileMeta[i].observation_epoch, file_meta.inputFileMeta[i].epoch, STN_EPOCH_WIDTH);
 		file_stream.read(reinterpret_cast<char *>(&file_meta.inputFileMeta[i].filetype), sizeof(UINT16));
 		file_stream.read(reinterpret_cast<char *>(&file_meta.inputFileMeta[i].datatype), sizeof(UINT16));
 	}
diff --git a/dynadjust/include/io/dynadjust_file.hpp b/dynadjust/include/io/dynadjust_file.hpp
index 9e82f2c2b..f1c7d046a 100644
--- a/dynadjust/include/io/dynadjust_file.hpp
+++ b/dynadjust/include/io/dynadjust_file.hpp
@@ -37,7 +37,7 @@
 #include <include/config/dnatypes-fwd.hpp>
 #include <include/config/dnatypes-structs.hpp>
 
-#define __FILE_VERSION__ "1.1"
+#define __FILE_VERSION__ "1.2"
 
 namespace dynadjust {
 namespace iostreams {
diff --git a/dynadjust/include/math/dnamatrix_contiguous.cpp b/dynadjust/include/math/dnamatrix_contiguous.cpp
index 2d66cf738..11fcf01ef 100644
--- a/dynadjust/include/math/dnamatrix_contiguous.cpp
+++ b/dynadjust/include/math/dnamatrix_contiguous.cpp
@@ -19,7 +19,9 @@
 // Description  : DynAdjust Matrix library
 //============================================================================
 
+#include <algorithm>
 #include <cmath>
+#include <cstdlib>
 #include <vector>
 #include <include/ide/trace.hpp>
 #include <include/math/dnamatrix_contiguous.hpp>
@@ -29,6 +31,11 @@
 namespace dynadjust {
 namespace math {
 
+// BLAS thread count selected during application start-up.
+static int g_max_blas_threads = 0;
+
+void set_max_blas_threads(int n) { g_max_blas_threads = n; }
+int get_max_blas_threads() { return g_max_blas_threads; }
 
 std::ostream& operator<<(std::ostream& os, const matrix_2d& rhs) {
     if (os.iword(0) == binary) {
@@ -44,18 +51,25 @@ std::ostream& operator<<(std::ostream& os, const matrix_2d& rhs) {
         os.write(reinterpret_cast<const char*>(&rhs._mem_rows), sizeof(UINT32));
         os.write(reinterpret_cast<const char*>(&rhs._mem_cols), sizeof(UINT32));
 
+        // Alignment padding — keeps data region at 8-byte aligned offset (24 bytes)
+        // Must match WriteMappedFileRegion / ReadMappedFileRegion / AttachMappedFileRegion layout
+        const UINT32 pad = 0;
+        os.write(reinterpret_cast<const char*>(&pad), sizeof(UINT32));
+
         UINT32 c, r;
 
         switch (rhs._matrixType) {
         case mtx_lower:
-            // output lower triangular part of a square matrix
             if (rhs._mem_rows != rhs._mem_cols)
                 throw std::runtime_error("matrix_2d operator<< (): Matrix is not square.");
 
-            // print each column
-            for (c = 0; c < rhs._mem_cols; ++c)
-                os.write(reinterpret_cast<const char*>(rhs.getelementref(c, c)), (rhs._mem_rows - c) * sizeof(double));
-
+            if (rhs._packed) {
+                os.write(reinterpret_cast<const char*>(rhs._buffer),
+                         matrix_2d::packed_size(rhs._mem_rows) * sizeof(double));
+            } else {
+                for (c = 0; c < rhs._mem_cols; ++c)
+                    os.write(reinterpret_cast<const char*>(rhs.getelementref(c, c)), (rhs._mem_rows - c) * sizeof(double));
+            }
             break;
         case mtx_sparse: break;
         case mtx_full:
@@ -108,7 +122,7 @@ void out_of_memory_handler() {
 }
 
 matrix_2d::matrix_2d()
-    : _mem_cols(0), _mem_rows(0), _cols(0), _rows(0), _buffer(0), _maxvalCol(0), _maxvalRow(0), _matrixType(mtx_full) {
+    : _mem_cols(0), _mem_rows(0), _cols(0), _rows(0), _buffer(0), _owns_buffer(true), _maxvalCol(0), _maxvalRow(0), _matrixType(mtx_full), _symmetric(false), _packed(false) {
     std::set_new_handler(out_of_memory_handler);
 
     // if this class were to be modified to use templates, each
@@ -125,9 +139,12 @@ matrix_2d::matrix_2d(const UINT32& rows, const UINT32& columns)
       _cols(columns),
       _rows(rows),
       _buffer(0),
+      _owns_buffer(true),
       _maxvalCol(0),
       _maxvalRow(0),
-      _matrixType(mtx_full) {
+      _matrixType(mtx_full),
+      _symmetric(false),
+      _packed(false) {
     std::set_new_handler(out_of_memory_handler);
 
     allocate(_rows, _cols);
@@ -140,9 +157,12 @@ matrix_2d::matrix_2d(const UINT32& rows, const UINT32& columns, const double dat
       _cols(columns),
       _rows(rows),
       _buffer(0),
+      _owns_buffer(true),
       _maxvalCol(0),
       _maxvalRow(0),
-      _matrixType(matrix_type) {
+      _matrixType(matrix_type),
+      _symmetric(false),
+      _packed(false) {
     std::set_new_handler(out_of_memory_handler);
 
     std::stringstream ss;
@@ -197,17 +217,26 @@ matrix_2d::matrix_2d(const matrix_2d& newmat)
       _cols(newmat.columns()),
       _rows(newmat.rows()),
       _buffer(0),
+      _owns_buffer(true),
       _maxvalCol(newmat.maxvalueCol()),
       _maxvalRow(newmat.maxvalueRow()),
-      _matrixType(newmat.matrixType()) {
+      _matrixType(newmat.matrixType()),
+      _symmetric(newmat._symmetric),
+      _packed(newmat._packed) {
     std::set_new_handler(out_of_memory_handler);
 
-    allocate(_mem_rows, _mem_cols);
-
-    const double* ptr = newmat.getbuffer();
-
-    // copy buffer
-    memcpy(_buffer, ptr, newmat.buffersize());
+    if (_packed) {
+        std::size_t ps = packed_size(_mem_rows);
+        _buffer = static_cast<double*>(std::malloc(ps * sizeof(double)));
+        if (!_buffer) throw NetMemoryException("Insufficient memory for packed matrix copy.");
+        memcpy(_buffer, newmat.getbuffer(), ps * sizeof(double));
+    } else {
+        // Allocate without zeroing — memcpy immediately overwrites entire buffer
+        std::size_t total_size = static_cast<std::size_t>(_mem_rows) * _mem_cols;
+        _buffer = static_cast<double*>(std::malloc(total_size * sizeof(double)));
+        if (!_buffer) throw NetMemoryException("Insufficient memory for matrix copy.");
+        memcpy(_buffer, newmat.getbuffer(), total_size * sizeof(double));
+    }
 }
 
 matrix_2d::~matrix_2d() {
@@ -216,14 +245,21 @@ matrix_2d::~matrix_2d() {
 }
 
 std::size_t matrix_2d::get_size() {
+    // 8 UINT32s: matrixType, rows, cols, mem_rows, mem_cols, _pad, maxvalRow, maxvalCol
+    // The padding UINT32 ensures the data region starts at an 8-byte aligned offset (24 bytes)
+    // from the region base, enabling in-place mmap buffer attachment.
     size_t size =
-        (7 * sizeof(UINT32));  // UINT32 _matrixType, _mem_cols, _mem_rows, _cols, _rows, _maxvalRow, _maxvalCol
+        (8 * sizeof(UINT32));
 
     switch (_matrixType) {
     case mtx_lower: size += sumOfConsecutiveIntegers(_mem_rows) * sizeof(double); break;
     case mtx_sparse: break;
     case mtx_full:
-    default: size += buffersize();
+    default:
+        if (_packed)
+            size += packed_size(_mem_rows) * sizeof(double);
+        else
+            size += buffersize();
     }
     return size;
 }
@@ -241,7 +277,6 @@ void matrix_2d::ReadMappedFileRegion(void* addr) {
 
     switch (_matrixType) {
     case mtx_sparse:
-        // _mem_cols and _mem_rows equal _cols and _rows
         _mem_rows = _rows;
         _mem_cols = _cols;
         break;
@@ -250,10 +285,22 @@ void matrix_2d::ReadMappedFileRegion(void* addr) {
     default:
         _mem_rows = *data_U++;
         _mem_cols = *data_U++;
+        ++data_U;  // skip alignment padding UINT32
         break;
     }
 
-    allocate(_mem_rows, _mem_cols);
+    if (_matrixType == mtx_lower && _mem_rows == _mem_cols) {
+        deallocate();
+        _packed = true;
+        _symmetric = true;
+        std::size_t ps = packed_size(_mem_rows);
+        _buffer = static_cast<double*>(std::calloc(ps, sizeof(double)));
+        if (!_buffer) throw NetMemoryException("Insufficient memory for packed matrix read.");
+    } else {
+        _packed = false;
+        _symmetric = false;
+        allocate(_mem_rows, _mem_cols);
+    }
 
     double* data_d;
     int* data_i;
@@ -292,15 +339,22 @@ void matrix_2d::ReadMappedFileRegion(void* addr) {
         return;
         break;
     case mtx_lower:
+        assert(_mem_rows == _mem_cols && "ReadMappedFileRegion(mtx_lower): matrix must be square");
         data_d = reinterpret_cast<double*>(data_U);
 
-        // read each column
-        for (c = 0; c < _mem_cols; ++c) {
-            memcpy(getelementref(c, c), data_d, (_mem_rows - c) * sizeof(double));
-            data_d += (_mem_rows - c);
+        if (_packed) {
+            std::size_t ps = packed_size(_mem_rows);
+            memcpy(_buffer, data_d, ps * sizeof(double));
+            data_d += ps;
+            _symmetric = true;
+        } else {
+            for (c = 0; c < _mem_cols; ++c) {
+                memcpy(getbuffer(c, c), data_d, (_mem_rows - c) * sizeof(double));
+                data_d += (_mem_rows - c);
+            }
+            fillupper();
+            _symmetric = false;
         }
-
-        fillupper();
         break;
     case mtx_full:
     default:
@@ -342,9 +396,32 @@ void matrix_2d::WriteMappedFileRegion(void* addr) {
     default:
         *data_U++ = _mem_rows;
         *data_U++ = _mem_cols;
+        *data_U++ = 0;  // alignment padding
         break;
     }
 
+    // In-place mmap: data is already in the region, only update footer
+    if (!_owns_buffer) {
+        // Calculate footer position by skipping past data
+        double* data_d;
+        switch (_matrixType) {
+        case mtx_lower:
+            if (_packed)
+                data_d = reinterpret_cast<double*>(data_U) + packed_size(_mem_rows);
+            else
+                data_d = reinterpret_cast<double*>(data_U) + sumOfConsecutiveIntegers(_mem_rows);
+            break;
+        case mtx_full:
+        default:
+            data_d = reinterpret_cast<double*>(data_U) + static_cast<std::size_t>(_mem_rows) * _mem_cols;
+            break;
+        }
+        PUINT32 footer = reinterpret_cast<UINT32*>(data_d);
+        *footer++ = _maxvalRow;
+        *footer = _maxvalCol;
+        return;
+    }
+
     double* data_d;
     int* data_i;
 
@@ -384,10 +461,15 @@ void matrix_2d::WriteMappedFileRegion(void* addr) {
     case mtx_lower:
         data_d = reinterpret_cast<double*>(data_U);
 
-        // print each column
-        for (c = 0; c < _mem_cols; ++c) {
-            memcpy(data_d, getbuffer(c, c), (_mem_rows - c) * sizeof(double));
-            data_d += (_mem_rows - c);
+        if (_packed) {
+            std::size_t ps = packed_size(_mem_rows);
+            memcpy(data_d, _buffer, ps * sizeof(double));
+            data_d += ps;
+        } else {
+            for (c = 0; c < _mem_cols; ++c) {
+                memcpy(data_d, getbuffer(c, c), (_mem_rows - c) * sizeof(double));
+                data_d += (_mem_rows - c);
+            }
         }
         break;
     case mtx_full:
@@ -408,16 +490,115 @@ void matrix_2d::WriteMappedFileRegion(void* addr) {
     *data_U = _maxvalCol;
 }
 
-void matrix_2d::allocate() { allocate(_mem_rows, _mem_cols); }
 
-// creates memory for desired "memory size", not matrix dimensions
-void matrix_2d::allocate(const UINT32& rows, const UINT32& columns) {
-    //_method_ = "allocate";
+void matrix_2d::AttachMappedFileRegion(void* addr) {
+    // Read header metadata — same layout as ReadMappedFileRegion
+    PUINT32 data_U = reinterpret_cast<PUINT32>(addr);
+    _matrixType = *data_U++;
+    _rows = *data_U++;
+    _cols = *data_U++;
 
+    switch (_matrixType) {
+    case mtx_sparse:
+        _mem_rows = _rows;
+        _mem_cols = _cols;
+        // Sparse cannot use in-place — fall back to copy path
+        ReadMappedFileRegion(addr);
+        return;
+    case mtx_lower:
+    case mtx_full:
+    default:
+        _mem_rows = *data_U++;
+        _mem_cols = *data_U++;
+        ++data_U;  // skip alignment padding
+        break;
+    }
+
+    // Release any existing buffer
     deallocate();
 
-    // an exception will be thrown by out_of_memory_handler
-    // if memory cannot be allocated
+    // Point _buffer directly at the data region in the mmap
+    _buffer = reinterpret_cast<double*>(data_U);
+    _owns_buffer = false;
+
+    // Set packed/symmetric flags for lower-triangular matrices
+    if (_matrixType == mtx_lower && _mem_rows == _mem_cols) {
+        _packed = true;
+        _symmetric = true;
+    } else {
+        _packed = false;
+    }
+
+    // Read footer (maxvalRow, maxvalCol) from after the data
+    double* data_d;
+    switch (_matrixType) {
+    case mtx_lower:
+        data_d = _buffer + packed_size(_mem_rows);
+        break;
+    case mtx_full:
+    default:
+        data_d = _buffer + static_cast<std::size_t>(_mem_rows) * _mem_cols;
+        break;
+    }
+
+    PUINT32 footer = reinterpret_cast<UINT32*>(data_d);
+    _maxvalRow = *footer++;
+    _maxvalCol = *footer;
+}
+
+
+void matrix_2d::DetachMappedFileRegion(void* addr) {
+    if (_owns_buffer || _buffer == nullptr)
+        return;
+
+    // Write updated footer (maxvalRow, maxvalCol) to the mmap region.
+    // Header: 6 UINT32s (matrixType, rows, cols, mem_rows, mem_cols, pad) = 24 bytes.
+    // Skip past data to find the footer position.
+    double* data_d;
+    switch (_matrixType) {
+    case mtx_lower:
+        data_d = _buffer + packed_size(_mem_rows);
+        break;
+    case mtx_full:
+    default:
+        data_d = _buffer + static_cast<std::size_t>(_mem_rows) * _mem_cols;
+        break;
+    }
+
+    PUINT32 footer = reinterpret_cast<UINT32*>(data_d);
+    *footer++ = _maxvalRow;
+    *footer = _maxvalCol;
+
+    // Detach without freeing the mmap memory
+    _buffer = nullptr;
+    _owns_buffer = true;
+}
+
+
+void matrix_2d::allocate() {
+    if (_matrixType == mtx_lower && _mem_rows == _mem_cols && _mem_rows > 0) {
+        deallocate();
+        _packed = true;
+        _symmetric = true;
+        std::size_t ps = packed_size(_mem_rows);
+        _buffer = static_cast<double*>(std::calloc(ps, sizeof(double)));
+        if (!_buffer) {
+            std::stringstream ss;
+            ss << "Insufficient memory for a packed " << _mem_rows << " x " << _mem_rows << " matrix.";
+            throw NetMemoryException(ss.str());
+        }
+        return;
+    }
+    _packed = false;
+    _symmetric = false;
+    allocate(_mem_rows, _mem_cols);
+}
+
+// creates memory for desired "memory size", not matrix dimensions
+void matrix_2d::allocate(const UINT32& rows, const UINT32& columns) {
+    deallocate();
+    _packed = false;
+    _symmetric = false;
     buy(rows, columns, &_buffer);
 }
 
@@ -429,26 +610,27 @@ void matrix_2d::buy(const UINT32& rows, const UINT32& columns, double** mem_spac
     __row__ = rows;
     __col__ = columns;
 
-    // an exception will be thrown by out_of_memory_handler
-    // if memory cannot be allocated
+    // calloc returns zero-initialised memory.  For large allocations glibc
+    // satisfies calloc via mmap, whose anonymous pages are already zero-filled
+    // by the kernel — so calloc skips the redundant memset that was previously
+    // triggering page-fault storms (97 % of CPU time on the NSW benchmark).
     std::size_t total_size = static_cast<std::size_t>(rows) * static_cast<std::size_t>(columns);
-    (*mem_space) = new double[total_size];
+    (*mem_space) = static_cast<double*>(std::calloc(total_size, sizeof(double)));
 
     if ((*mem_space) == nullptr) {
         std::stringstream ss;
         ss << "Insufficient memory for a " << rows << " x " << columns << " matrix.";
         throw NetMemoryException(ss.str());
     }
-
-    // Initialize memory to zero to prevent uninitialized values
-    std::memset((*mem_space), 0, total_size * sizeof(double));
 }
 
 void matrix_2d::deallocate() {
     if (_buffer != nullptr) {
-        delete[] _buffer;
+        if (_owns_buffer)
+            std::free(_buffer);
         _buffer = nullptr;
     }
+    _owns_buffer = true;
 }
 
 matrix_2d matrix_2d::submatrix(const UINT32& row_begin, const UINT32& col_begin, const UINT32& rows,
@@ -514,9 +696,14 @@ void matrix_2d::submatrix(const UINT32& row_begin, const UINT32& col_begin, matr
 }
 
 void matrix_2d::redim(const UINT32& rows, const UINT32& columns) {
+    if (_packed) {
+        deallocate();
+        _packed = false;
+    }
+    _symmetric = false;
     // if new matrix size is smaller than or equal to the previous
     // matrix size, then simply change dimensions and return
-    if (rows <= _mem_rows && columns <= _mem_cols) {
+    if (_buffer != nullptr && rows <= _mem_rows && columns <= _mem_cols) {
         // Zero out the unused portions when reusing buffer
         // Zero partial columns (rows beyond new row count)
         for (UINT32 col = 0; col < columns && col < _mem_cols; ++col) {
@@ -550,23 +737,46 @@ void matrix_2d::redim(const UINT32& rows, const UINT32& columns) {
     buy(rows, columns, &new_buffer);
     
     // Copy old data to new buffer if there was any
+    bool old_owns = _owns_buffer;
     if (old_buffer != nullptr && old_rows > 0 && old_cols > 0) {
         for (UINT32 col = 0; col < old_cols && col < columns; ++col) {
             for (UINT32 row = 0; row < old_rows && row < rows; ++row) {
                 new_buffer[col * rows + row] = old_buffer[col * old_rows + row];
             }
         }
-        // Delete old buffer
-        delete[] old_buffer;
+        if (old_owns)
+            std::free(old_buffer);
     }
     
     _buffer = new_buffer;
-    
+    _owns_buffer = true;
 
     _rows = _mem_rows = rows;
     _cols = _mem_cols = columns;
 }
 
+void matrix_2d::redim_packed(const UINT32& n) {
+    std::size_t ps = packed_size(n);
+
+    if (_buffer != nullptr && _packed && n <= _mem_rows) {
+        std::memset(_buffer, 0, ps * sizeof(double));
+        _rows = _cols = _mem_rows = _mem_cols = n;
+        return;
+    }
+
+    deallocate();
+    _rows = _cols = _mem_rows = _mem_cols = n;
+    _packed = true;
+    _symmetric = true;
+    _matrixType = mtx_lower;
+    _buffer = static_cast<double*>(std::calloc(ps, sizeof(double)));
+    if (!_buffer) {
+        std::stringstream ss;
+        ss << "Insufficient memory for a packed " << n << " x " << n << " matrix.";
+        throw NetMemoryException(ss.str());
+    }
+}
+
 void matrix_2d::shrink(const UINT32& rows, const UINT32& columns) {
     if (rows > _rows || columns > _cols) {
         std::stringstream ss;
@@ -601,6 +811,8 @@ void matrix_2d::grow(const UINT32& rows, const UINT32& columns) {
 
 void matrix_2d::setsize(const UINT32& rows, const UINT32& columns) {
     deallocate();
+    _packed = false;
+    _symmetric = false;
     _rows = _mem_rows = rows;
     _cols = _mem_cols = columns;
 }
@@ -641,21 +853,53 @@ void matrix_2d::copybuffer(const UINT32& rowstart, const UINT32& columnstart, co
     }
 }
 
-void matrix_2d::copyelements(const UINT32& row_dest, const UINT32& column_dest, const matrix_2d& src,
-                             const UINT32& row_src, const UINT32& column_src, const UINT32& rows,
-                             const UINT32& columns) {
+void matrix_2d::copyelements_generic(const UINT32& row_dest, const UINT32& column_dest, const matrix_2d& src,
+                                     const UINT32& row_src, const UINT32& column_src, const UINT32& rows,
+                                     const UINT32& columns) {
+    assert(_buffer != nullptr && src._buffer != nullptr);
+    assert(row_dest + rows <= _mem_rows && "copyelements_generic(): dest row overflow");
+    assert(column_dest + columns <= _mem_cols && "copyelements_generic(): dest col overflow");
+    assert(row_src + rows <= src._mem_rows && "copyelements_generic(): src row overflow");
+    assert(column_src + columns <= src._mem_cols && "copyelements_generic(): src col overflow");
+    // Fast path: packed source → dense dest (avoids per-element get/put overhead)
+    if (src._packed && !_packed) {
+        for (UINT32 c = 0; c < columns; ++c) {
+            double* d = _buffer + static_cast<std::size_t>(column_dest + c) * _mem_rows + row_dest;
+            UINT32 sc = column_src + c;
+            for (UINT32 r = 0; r < rows; ++r) {
+                UINT32 sr = row_src + r, sj = sc;
+                if (sr < sj) std::swap(sr, sj);
+                d[r] = src._buffer[packed_index(src._rows, sr, sj)];
+            }
+        }
+        return;
+    }
+    // Fast path: dense source → packed dest
+    if (_packed && !src._packed && !src._symmetric) {
+        for (UINT32 c = 0; c < columns; ++c) {
+            const double* s = src._buffer + static_cast<std::size_t>(column_src + c) * src._mem_rows + row_src;
+            UINT32 dc = column_dest + c;
+            for (UINT32 r = 0; r < rows; ++r) {
+                UINT32 dr = row_dest + r;
+                if (dr >= dc)
+                    _buffer[packed_index(_rows, dr, dc)] = s[r];
+            }
+        }
+        return;
+    }
+    // Fallback for remaining packed/symmetric combinations
+    if (src._symmetric || src._packed || _packed) {
+        for (UINT32 r = 0; r < rows; ++r)
+            for (UINT32 c = 0; c < columns; ++c)
+                put(row_dest + r, column_dest + c, src.get(row_src + r, column_src + c));
+        return;
+    }
     UINT32 cd(0), cs(0), colend_dest(column_dest + columns);
     for (cd = column_dest, cs = column_src; cd < colend_dest; ++cd, ++cs)
         memcpy(getelementref(row_dest, cd), src.getbuffer(row_src, cs),
                static_cast<std::size_t>(rows) * sizeof(double));
 }
 
-void matrix_2d::copyelements(const UINT32& row_dest, const UINT32& column_dest, const matrix_2d* src,
-                             const UINT32& row_src, const UINT32& column_src, const UINT32& rows,
-                             const UINT32& columns) {
-    copyelements(row_dest, column_dest, *src, row_src, column_src, rows, columns);
-}
-
 void matrix_2d::sweep(UINT32 k1, UINT32 k2) {
     double eps(1.0e-8), d;
     UINT32 i, j, k, it;
@@ -705,10 +949,47 @@ matrix_2d matrix_2d::sweepinverse() {
     return *this;
 }
 
-matrix_2d matrix_2d::cholesky_inverse(bool LOWER_IS_CLEARED /*=false*/) {
+matrix_2d matrix_2d::cholesky_inverse(bool LOWER_IS_CLEARED /*=false*/, bool mark_symmetric /*=false*/) {
     if (_rows < 1) return *this;
     if (_rows != _cols) throw std::runtime_error("cholesky_inverse(): Matrix is not square.");
 
+    assert(_buffer != nullptr && "cholesky_inverse(): null buffer");
+    assert(_mem_rows >= _rows && "cholesky_inverse(): mem_rows < rows");
+    assert(_mem_cols >= _cols && "cholesky_inverse(): mem_cols < cols");
+    assert(!(mark_symmetric && LOWER_IS_CLEARED) &&
+           "cholesky_inverse(): mark_symmetric with LOWER_IS_CLEARED not supported");
+
+    if (_packed) {
+        // Unpack to full format for fast blocked dpotrf/dpotri, then repack.
+        // dpptrf/dpptri are element-by-element and orders of magnitude slower.
+        lapack_int n = _rows;
+        std::size_t full_size = static_cast<std::size_t>(n) * n;
+
+        // Reuse thread-local workspace to avoid repeated allocation/deallocation.
+        // dpotrf/dpotri with uplo='L' only read the lower triangle, so no
+        // memset is needed — the unpack loop sets all lower-triangle elements.
+        static thread_local std::vector<double> chol_workspace;
+        if (chol_workspace.size() < full_size)
+            chol_workspace.resize(full_size);
+        double* full = chol_workspace.data();
+
+        for (UINT32 j = 0; j < _rows; ++j)
+            for (UINT32 i = j; i < _rows; ++i)
+                full[static_cast<std::size_t>(j) * n + i] = _buffer[packed_index(_rows, i, j)];
+
+        char uplo = LOWER_TRIANGLE;
+        lapack_int info, lda = n;
+        LAPACK_FUNC(dpotrf)(&uplo, &n, full, &lda, &info);
+        if (info != 0) throw MatrixInversionFailure("Matrix inversion failed, the matrix is singular.");
+        LAPACK_FUNC(dpotri)(&uplo, &n, full, &lda, &info);
+        if (info != 0) throw MatrixInversionFailure("Matrix inversion failed, the matrix is singular.");
+
+        for (UINT32 j = 0; j < _rows; ++j)
+            for (UINT32 i = j; i < _rows; ++i)
+                _buffer[packed_index(_rows, i, j)] = full[static_cast<std::size_t>(j) * n + i];
+        return *this;
+    }
+
     char uplo(LOWER_TRIANGLE);
     if (LOWER_IS_CLEARED) uplo = UPPER_TRIANGLE;
 
@@ -727,23 +1008,181 @@ matrix_2d matrix_2d::cholesky_inverse(bool LOWER_IS_CLEARED /*=false*/) {
     if (info != 0)
         throw MatrixInversionFailure("Matrix inversion failed, the matrix is singular.");
 
-    if (LOWER_IS_CLEARED)
+    if (mark_symmetric) {
+        _symmetric = true;
+    } else if (LOWER_IS_CLEARED) {
         filllower();
-    else
+    } else {
         fillupper();
+    }
+
+    return *this;
+}
+
+matrix_2d matrix_2d::cholesky_factor(bool LOWER_IS_CLEARED /*=false*/) {
+    if (_rows < 1) return *this;
+    if (_rows != _cols) throw std::runtime_error("cholesky_factor(): Matrix is not square.");
+
+    assert(_buffer != nullptr && "cholesky_factor(): null buffer");
+    assert(_mem_rows >= _rows && "cholesky_factor(): mem_rows < rows");
+    assert(_mem_cols >= _cols && "cholesky_factor(): mem_cols < cols");
+
+    if (_packed) {
+        // Unpack to full format for dpotrf (same approach as cholesky_inverse).
+        // The factor L is stored back in packed format.
+        lapack_int n = _rows;
+        std::size_t full_size = static_cast<std::size_t>(n) * n;
+
+        // Reuse thread-local workspace; no memset needed (dpotrf reads lower triangle only)
+        static thread_local std::vector<double> chol_workspace;
+        if (chol_workspace.size() < full_size)
+            chol_workspace.resize(full_size);
+        double* full = chol_workspace.data();
+
+        for (UINT32 j = 0; j < _rows; ++j)
+            for (UINT32 i = j; i < _rows; ++i)
+                full[static_cast<std::size_t>(j) * n + i] = _buffer[packed_index(_rows, i, j)];
+
+        char uplo = LOWER_TRIANGLE;
+        lapack_int info, lda = n;
+        LAPACK_FUNC(dpotrf)(&uplo, &n, full, &lda, &info);
+        if (info != 0) throw MatrixInversionFailure("Cholesky factorisation failed, the matrix is singular.");
+
+        // Store the L factor back in packed format
+        for (UINT32 j = 0; j < _rows; ++j)
+            for (UINT32 i = j; i < _rows; ++i)
+                _buffer[packed_index(_rows, i, j)] = full[static_cast<std::size_t>(j) * n + i];
+        return *this;
+    }
+
+    char uplo(LOWER_TRIANGLE);
+    if (LOWER_IS_CLEARED) uplo = UPPER_TRIANGLE;
+
+    lapack_int info, n = _rows;
+    lapack_int lda = _mem_rows;
+
+    LAPACK_FUNC(dpotrf)(&uplo, &n, _buffer, &lda, &info);
+
+    if (info != 0)
+        throw MatrixInversionFailure("Cholesky factorisation failed, the matrix is singular.");
 
     return *this;
 }
 
+void matrix_2d::cholesky_solve(matrix_2d& rhs, bool LOWER_IS_CLEARED /*=false*/) {
+    assert(_rows == _cols && "cholesky_solve(): factor matrix is not square");
+    assert(_rows == rhs._rows && "cholesky_solve(): dimension mismatch");
+    assert(_buffer != nullptr && "cholesky_solve(): null factor buffer");
+    assert(rhs._buffer != nullptr && "cholesky_solve(): null rhs buffer");
+
+    if (_packed) {
+        // Unpack the L factor to full format for dpotrs.
+        lapack_int n = _rows;
+        std::size_t full_size = static_cast<std::size_t>(n) * n;
+
+        // Reuse thread-local workspace; no memset needed (dpotrs reads lower triangle only)
+        static thread_local std::vector<double> chol_workspace;
+        if (chol_workspace.size() < full_size)
+            chol_workspace.resize(full_size);
+        double* full = chol_workspace.data();
+
+        for (UINT32 j = 0; j < _rows; ++j)
+            for (UINT32 i = j; i < _rows; ++i)
+                full[static_cast<std::size_t>(j) * n + i] = _buffer[packed_index(_rows, i, j)];
+
+        char uplo = LOWER_TRIANGLE;
+        lapack_int nrhs = rhs._cols;
+        lapack_int lda = n;
+        lapack_int ldb = rhs._mem_rows;
+        lapack_int info;
+
+        LAPACK_FUNC(dpotrs)(&uplo, &n, &nrhs, full, &lda, rhs._buffer, &ldb, &info);
+
+        if (info != 0)
+            throw MatrixInversionFailure("Cholesky solve failed.");
+        return;
+    }
+
+    char uplo(LOWER_TRIANGLE);
+    if (LOWER_IS_CLEARED) uplo = UPPER_TRIANGLE;
+
+    lapack_int n = _rows;
+    lapack_int nrhs = rhs._cols;
+    lapack_int lda = _mem_rows;
+    lapack_int ldb = rhs._mem_rows;
+    lapack_int info;
+
+    LAPACK_FUNC(dpotrs)(&uplo, &n, &nrhs, _buffer, &lda, rhs._buffer, &ldb, &info);
+
+    if (info != 0)
+        throw MatrixInversionFailure("Cholesky solve failed.");
+}
+
+double matrix_2d::dot(const matrix_2d& other) const {
+    assert(_cols == 1 && other._cols == 1 && "dot(): both matrices must be column vectors");
+    assert(_rows == other._rows && "dot(): dimension mismatch");
+    assert(_buffer != nullptr && other._buffer != nullptr && "dot(): null buffer");
+
+    double result = 0.0;
+    for (UINT32 i = 0; i < _rows; ++i)
+        result += get(i, 0) * other.get(i, 0);
+    return result;
+}
+
 matrix_2d matrix_2d::scale(const double& scalar) {
+    if (_packed) {
+        std::size_t ps = packed_size(_rows);
+        for (std::size_t k = 0; k < ps; ++k)
+            _buffer[k] *= scalar;
+        return *this;
+    }
     UINT32 i, j;
     for (i = 0; i < _rows; ++i)
         for (j = 0; j < _cols; ++j) *getelementref(i, j) *= scalar;
     return *this;
 }
 
-void matrix_2d::blockadd(const UINT32& row_dest, const UINT32& col_dest, const matrix_2d& mat_src,
-                         const UINT32& row_src, const UINT32& col_src, const UINT32& rows, const UINT32& cols) {
+void matrix_2d::scale_symmetric_diagonal(const double* diag) {
+    assert(_symmetric && "scale_symmetric_diagonal(): matrix must be symmetric");
+    if (_packed) {
+        for (UINT32 j = 0; j < _rows; ++j)
+            for (UINT32 i = j; i < _rows; ++i)
+                _buffer[packed_index(_rows, i, j)] *= diag[i] * diag[j];
+        return;
+    }
+    for (UINT32 j = 0; j < _rows; ++j)
+        for (UINT32 i = j; i < _rows; ++i) {
+            double s = diag[i] * diag[j];
+            *getelementref(i, j) *= s;
+        }
+}
+
+void matrix_2d::blockadd_generic(const UINT32& row_dest, const UINT32& col_dest, const matrix_2d& mat_src,
+                                 const UINT32& row_src, const UINT32& col_src, const UINT32& rows, const UINT32& cols) {
+    // Fast path: dense source → packed dest (avoids per-element get/elementadd overhead)
+    if (_packed && !mat_src._packed && !mat_src._symmetric) {
+        for (UINT32 c = 0; c < cols; ++c) {
+            const double* s = mat_src._buffer + static_cast<std::size_t>(col_src + c) * mat_src._mem_rows + row_src;
+            UINT32 dc = col_dest + c;
+            for (UINT32 r = 0; r < rows; ++r) {
+                UINT32 dr = row_dest + r;
+                if (dr >= dc)
+                    _buffer[packed_index(_rows, dr, dc)] += s[r];
+            }
+        }
+        return;
+    }
+    // Fast path: both dense (non-packed, non-symmetric) — use direct buffer arithmetic
+    if (!_packed && !mat_src._packed && !mat_src._symmetric) {
+        for (UINT32 c = 0; c < cols; ++c) {
+            double* d = _buffer + static_cast<std::size_t>(col_dest + c) * _mem_rows + row_dest;
+            const double* s = mat_src._buffer + static_cast<std::size_t>(col_src + c) * mat_src._mem_rows + row_src;
+            for (UINT32 r = 0; r < rows; ++r)
+                d[r] += s[r];
+        }
+        return;
+    }
+    // Fallback: generic per-element path
     UINT32 i_dest, j_dest, i_src, j_src;
     UINT32 i_dest_end(row_dest + rows), j_dest_end(col_dest + cols);
 
@@ -752,9 +1191,8 @@ void matrix_2d::blockadd(const UINT32& row_dest, const UINT32& col_dest, const m
             elementadd(i_dest, j_dest, mat_src.get(i_src, j_src));
 }
 
-// Same as blockadd, but adds transpose.  mat_src must be square.
-void matrix_2d::blockTadd(const UINT32& row_dest, const UINT32& col_dest, const matrix_2d& mat_src,
-                          const UINT32& row_src, const UINT32& col_src, const UINT32& rows, const UINT32& cols) {
+void matrix_2d::blockTadd_generic(const UINT32& row_dest, const UINT32& col_dest, const matrix_2d& mat_src,
+                                  const UINT32& row_src, const UINT32& col_src, const UINT32& rows, const UINT32& cols) {
     UINT32 i_dest, j_dest, i_src, j_src;
     UINT32 i_dest_end(row_dest + rows), j_dest_end(col_dest + cols);
 
@@ -773,79 +1211,153 @@ void matrix_2d::blocksubtract(const UINT32& row_dest, const UINT32& col_dest, co
             elementsubtract(i_dest, j_dest, mat_src.get(i_src, j_src));
 }
 
-// clearlower()
 void matrix_2d::clearlower() {
+    assert(_buffer != nullptr);
+    assert(!_packed && "clearlower(): not valid for packed storage");
     // Sets lower triangle elements to zero
     UINT32 col, row;
-    for (row = 1, col = 0; col < _mem_cols; ++col, ++row)
+    for (row = 1, col = 0; col < _mem_cols && row < _mem_rows; ++col, ++row)
         memset(getelementref(row, col), 0, (static_cast<std::size_t>(_mem_rows) - row) * sizeof(double));
 }
 
-// clearupper()
 void matrix_2d::clearupper() {
+    assert(!_packed && "clearupper(): not valid for packed storage");
     // Sets upper triangle elements to zero
-    UINT32 col, row;
-    for (row = 0; row < _rows; ++row)
-        for (col = row + 1; col < _cols; ++col) put(row, col, 0.0);
+    // Column-major: for each column, zero the rows above the diagonal
+    for (UINT32 col = 1; col < _cols; ++col)
+        memset(_buffer + col * _mem_rows, 0, col * sizeof(double));
 }
 
-// filllower()
 void matrix_2d::filllower() {
-    // copies upper triangle to lower triangle
-    UINT32 column, row;
-    for (row = 1; row < _rows; row++)
-        for (column = 0; column < row; column++) put(row, column, get(column, row));
+    assert(_buffer != nullptr);
+    assert(!_packed && "filllower(): not valid for packed storage");
+    assert(_rows == _cols && "filllower(): matrix must be square");
+    // Copy upper triangle to lower: A(row,col) = A(col,row) for row > col
+    // Column-major: A(r,c) = _buffer[c * _mem_rows + r]
+    // Outer loop over destination columns so writes are sequential in memory.
+    const std::size_t mr = _mem_rows;
+    constexpr UINT32 BLK = 64;
+    for (UINT32 cb = 0; cb < _cols; cb += BLK) {
+        UINT32 ce = std::min(cb + BLK, _cols);
+        for (UINT32 rb = ce; rb < _rows; rb += BLK) {
+            UINT32 re = std::min(rb + BLK, _rows);
+            for (UINT32 col = cb; col < ce; col++) {
+                double* dst = _buffer + col * mr;
+                for (UINT32 row = rb; row < re; row++)
+                    dst[row] = _buffer[row * mr + col];
+            }
+        }
+    }
+    // Diagonal blocks: row > col within the same block
+    for (UINT32 cb = 0; cb < _cols; cb += BLK) {
+        UINT32 ce = std::min(cb + BLK, _cols);
+        for (UINT32 col = cb; col < ce; col++) {
+            double* dst = _buffer + col * mr;
+            for (UINT32 row = col + 1; row < ce; row++)
+                dst[row] = _buffer[row * mr + col];
+        }
+    }
 }
 
-// fillupper()
 void matrix_2d::fillupper() {
-    // copies lower triangle to upper triangle
-    UINT32 column, row;
-    for (row = 1; row < _rows; row++)
-        for (column = 0; column < row; column++) put(column, row, get(row, column));
+    assert(_buffer != nullptr);
+    assert(!_packed && "fillupper(): not valid for packed storage");
+    assert(_rows == _cols && "fillupper(): matrix must be square");
+    // Copy lower triangle to upper: A(r,c) = A(c,r) for r < c
+    // Column-major: A(r,c) = _buffer[c * _mem_rows + r]
+    //
+    // Outer loop over destination columns so writes are sequential in memory.
+    // Reads are strided (one element per source column) but write-combining
+    // and store buffers make sequential writes much faster than sequential reads
+    // for large matrices.
+    const std::size_t mr = _mem_rows;
+    constexpr UINT32 BLK = 64;
+    for (UINT32 cb = 0; cb < _cols; cb += BLK) {
+        UINT32 ce = std::min(cb + BLK, _cols);
+        for (UINT32 rb = 0; rb < ce; rb += BLK) {
+            UINT32 re = std::min(rb + BLK, ce);
+            for (UINT32 col = cb; col < ce; col++) {
+                double* dst = _buffer + col * mr;
+                UINT32 r0 = rb;
+                UINT32 r1 = std::min(re, col);
+                for (UINT32 row = r0; row < r1; row++)
+                    dst[row] = _buffer[row * mr + col];
+            }
+        }
+    }
 }
 
-// zero()
-void matrix_2d::zero() { memset(_buffer, 0, buffersize()); }
+void matrix_2d::zero() {
+    assert(_buffer != nullptr && "zero(): null buffer");
+    if (_packed)
+        memset(_buffer, 0, packed_size(_mem_rows) * sizeof(double));
+    else
+        memset(_buffer, 0, buffersize());
+}
 
 // zero()
 void matrix_2d::zero(const UINT32& row_begin, const UINT32& col_begin, const UINT32& rows, const UINT32& columns) {
+    assert(_buffer != nullptr && "zero(sub): null buffer");
+    assert(row_begin + rows <= _mem_rows && "zero(sub): row overflow");
+    assert(col_begin + columns <= _mem_cols && "zero(sub): col overflow");
     UINT32 col(0), col_end(col_begin + columns);
     for (col = col_begin; col < col_end; ++col) memset(getelementref(row_begin, col), 0, rows * sizeof(double));
 }
 
 
 matrix_2d& matrix_2d::operator=(const matrix_2d& rhs) {
-    // Overloaded assignment operator
     if (this == &rhs) return *this;
 
-    // If rhs data can fit within limits of this matrix, copy
-    // and return. Otherwise, allocate new memory
+    if (rhs._packed) {
+        std::size_t ps = packed_size(rhs._rows);
+        if (_packed && _mem_rows >= rhs._rows) {
+            _rows = _cols = rhs._rows;
+            memcpy(_buffer, rhs._buffer, ps * sizeof(double));
+        } else {
+            deallocate();
+            _rows = _cols = _mem_rows = _mem_cols = rhs._rows;
+            _buffer = static_cast<double*>(std::malloc(ps * sizeof(double)));
+            if (!_buffer) throw NetMemoryException("Insufficient memory for packed matrix assignment.");
+            memcpy(_buffer, rhs._buffer, ps * sizeof(double));
+        }
+        _packed = true;
+        _symmetric = true;
+        _matrixType = rhs._matrixType;
+        _maxvalCol = rhs.maxvalueCol();
+        _maxvalRow = rhs.maxvalueRow();
+        return *this;
+    }
+
+    // rhs is not packed
+    if (_packed) {
+        deallocate();
+        _packed = false;
+        _mem_rows = _mem_cols = 0;
+    }
+
     if (_mem_rows >= rhs.rows() && _mem_cols >= rhs.columns()) {
-        // don't change _mem_rows or _mem_cols.  Simply update
-        // visible dimensions and copy buffer
         _rows = rhs.rows();
         _cols = rhs.columns();
         copybuffer(_rows, _cols, rhs);
 
-        _maxvalCol = rhs.maxvalueCol();  // col of max value
-        _maxvalRow = rhs.maxvalueRow();  // row of max value
+        _maxvalCol = rhs.maxvalueCol();
+        _maxvalRow = rhs.maxvalueRow();
+        _symmetric = rhs._symmetric;
 
         return *this;
     }
 
-    // Okay, rhs is larger, so allocate new memory. Call free
-    // memory first before changing row and column dimensions!
     deallocate();
-    _mem_rows = rhs.memRows();  // change memory limits
+    _mem_rows = rhs.memRows();
     _mem_cols = rhs.memColumns();
-    _rows = rhs.rows();  // change matrix dimensions
+    _rows = rhs.rows();
     _cols = rhs.columns();
     allocate(_mem_rows, _mem_cols);
     copybuffer(_rows, _cols, rhs);
 
-    _maxvalCol = rhs.maxvalueCol();  // col of max value
-    _maxvalRow = rhs.maxvalueRow();  // row of max value
+    _maxvalCol = rhs.maxvalueCol();
+    _maxvalRow = rhs.maxvalueRow();
+    _symmetric = rhs._symmetric;
 
     return *this;
 }
@@ -875,6 +1387,10 @@ matrix_2d matrix_2d::add(const matrix_2d& rhs) {
 // multiplies this matrix by rhs and stores the result in a new matrix
 // Uses Intel MKL dgemm
 matrix_2d matrix_2d::multiply(const char* lhs_trans, const matrix_2d& rhs, const char* rhs_trans) {
+    assert(!_symmetric && "multiply(dgemm): LHS is symmetric — use multiply_sym instead");
+    assert(!rhs._symmetric && "multiply(dgemm): RHS is symmetric — upper triangle is unpopulated");
+    assert(_buffer != nullptr && rhs._buffer != nullptr);
+
     matrix_2d m(_rows, rhs.columns());
 
     const double one = 1.0;
@@ -914,6 +1430,10 @@ matrix_2d matrix_2d::multiply(const char* lhs_trans, const matrix_2d& rhs, const
 // Uses Intel MKL dgemm
 matrix_2d
 matrix_2d::multiply(const matrix_2d& lhs, const char* lhs_trans, const matrix_2d& rhs, const char* rhs_trans) {
+    assert(!lhs._symmetric && "multiply(dgemm): LHS is symmetric — use multiply_sym instead");
+    assert(!rhs._symmetric && "multiply(dgemm): RHS is symmetric — upper triangle is unpopulated");
+    assert(lhs._buffer != nullptr && rhs._buffer != nullptr && _buffer != nullptr);
+
     const double one = 1.0;
     const double zero = 0.0;
 
@@ -947,6 +1467,48 @@ matrix_2d::multiply(const matrix_2d& lhs, const char* lhs_trans, const matrix_2d
     return *this;
 }  // Multiply()
 
+// C (this) = sym_lhs * rhs, using dsymm or dspmv (packed)
+matrix_2d matrix_2d::multiply_sym(const matrix_2d& sym_lhs, const matrix_2d& rhs) {
+    lapack_int m = sym_lhs.rows();
+    lapack_int n = rhs.columns();
+
+    assert(sym_lhs._symmetric && "multiply_sym(): LHS must be marked symmetric");
+    assert(sym_lhs._buffer != nullptr && "multiply_sym(): LHS null buffer");
+    assert(rhs._buffer != nullptr && "multiply_sym(): RHS null buffer");
+    assert(_buffer != nullptr && "multiply_sym(): result null buffer");
+    assert(_buffer != sym_lhs._buffer && _buffer != rhs._buffer &&
+           "multiply_sym(): result must not alias inputs");
+
+    if (sym_lhs.columns() != sym_lhs.rows())
+        throw std::runtime_error("multiply_sym(): LHS matrix is not square.");
+    if (static_cast<lapack_int>(rhs.rows()) != m)
+        throw std::runtime_error("multiply_sym(): Matrix dimensions are incompatible.");
+    if (_rows != static_cast<UINT32>(m) || _cols != static_cast<UINT32>(n))
+        throw std::runtime_error("multiply_sym(): Result matrix dimensions are incompatible.");
+
+    if (sym_lhs._packed) {
+        for (lapack_int j = 0; j < n; ++j) {
+            BLAS_FUNC(dspmv)(CblasColMajor, CblasLower,
+                             m, 1.0, sym_lhs._buffer,
+                             rhs._buffer + j * rhs._mem_rows, 1,
+                             0.0, _buffer + j * _mem_rows, 1);
+        }
+        return *this;
+    }
+
+    assert(sym_lhs.memRows() >= sym_lhs.rows() && "multiply_sym(): LHS LDA < M");
+    assert(rhs.memRows() >= rhs.rows() && "multiply_sym(): RHS LDA < M");
+    assert(_mem_rows >= _rows && "multiply_sym(): result LDA < M");
+
+    BLAS_FUNC(dsymm)(CblasColMajor, CblasLeft, CblasLower,
+                     m, n, 1.0,
+                     sym_lhs.getbuffer(), sym_lhs.memRows(),
+                     rhs.getbuffer(), rhs.memRows(),
+                     0.0, _buffer, _mem_rows);
+
+    return *this;
+}
+
 // Transpose()
 matrix_2d matrix_2d::transpose(const matrix_2d& matA) {
     if ((matA.columns() != _rows) || (matA.rows() != _cols))
@@ -967,9 +1529,19 @@ matrix_2d matrix_2d::transpose() {
     return m;
 }  // Transpose()
 
-// computes and retains the maximum value in the matrix
 double matrix_2d::compute_maximum_value() {
     _maxvalCol = _maxvalRow = 0;
+    if (_packed) {
+        for (UINT32 j = 0; j < _rows; ++j) {
+            for (UINT32 i = j; i < _rows; ++i) {
+                if (fabs(get(i, j)) > fabs(get(_maxvalRow, _maxvalCol))) {
+                    _maxvalRow = i;
+                    _maxvalCol = j;
+                }
+            }
+        }
+        return get(_maxvalRow, _maxvalCol);
+    }
     UINT32 col, row;
     for (row = 0; row < _rows; ++row) {
         for (col = 0; col < _cols; col++) {
diff --git a/dynadjust/include/math/dnamatrix_contiguous.hpp b/dynadjust/include/math/dnamatrix_contiguous.hpp
index be4d79c85..c79fea5d9 100644
--- a/dynadjust/include/math/dnamatrix_contiguous.hpp
+++ b/dynadjust/include/math/dnamatrix_contiguous.hpp
@@ -23,6 +23,7 @@
 #define DNAMATRIX_CONTIGUOUS_H_
 
 /// \cond
+#include <cassert>
 #include <cstring>
 /// \endcond
 
@@ -165,14 +166,26 @@ static_assert(sizeof(lapack_int) == 4, "LP64 interface requires 32-bit integers"
 extern "C" {
 void LAPACK_FUNC(dpotrf)(const char* uplo, const lapack_int* n, double* a, const lapack_int* lda, lapack_int* info);
 void LAPACK_FUNC(dpotri)(const char* uplo, const lapack_int* n, double* a, const lapack_int* lda, lapack_int* info);
+void LAPACK_FUNC(dpptrf)(const char* uplo, const lapack_int* n, double* ap, lapack_int* info);
+void LAPACK_FUNC(dpptri)(const char* uplo, const lapack_int* n, double* ap, lapack_int* info);
 void LAPACK_FUNC(dsytrf)(const char* uplo, const lapack_int* n, double* a, const lapack_int* lda,
                          lapack_int* ipiv, double* work, const lapack_int* lwork, lapack_int* info);
 void LAPACK_FUNC(dsytri)(const char* uplo, const lapack_int* n, double* a, const lapack_int* lda,
                          const lapack_int* ipiv, double* work, lapack_int* info);
+void LAPACK_FUNC(dpotrs)(const char* uplo, const lapack_int* n, const lapack_int* nrhs,
+                         const double* a, const lapack_int* lda, double* b, const lapack_int* ldb, lapack_int* info);
 void BLAS_FUNC(dgemm)(const enum CBLAS_ORDER ORDER, const enum CBLAS_TRANSPOSE TRANSA,
                       const enum CBLAS_TRANSPOSE TRANSB, const lapack_int M, const lapack_int N, const lapack_int K,
                       const double ALPHA, const double* A, const lapack_int LDA, const double* B, const lapack_int LDB,
                       const double BETA, double* C, const lapack_int LDC);
+void BLAS_FUNC(dsymm)(const enum CBLAS_ORDER ORDER, const enum CBLAS_SIDE SIDE, const enum CBLAS_UPLO UPLO,
+                      const lapack_int M, const lapack_int N,
+                      const double ALPHA, const double* A, const lapack_int LDA, const double* B, const lapack_int LDB,
+                      const double BETA, double* C, const lapack_int LDC);
+void BLAS_FUNC(dspmv)(const enum CBLAS_ORDER ORDER, const enum CBLAS_UPLO UPLO,
+                      const lapack_int N, const double ALPHA, const double* AP,
+                      const double* X, const lapack_int INCX,
+                      const double BETA, double* Y, const lapack_int INCY);
 }
 #endif
 
@@ -187,6 +200,10 @@ class MatrixInversionFailure : public std::runtime_error {
     using std::runtime_error::runtime_error;
 };
 
+// Set/get the maximum BLAS thread count used by matrix operations.
+void set_max_blas_threads(int n);
+int get_max_blas_threads();
+
 class matrix_2d;
 typedef std::vector<matrix_2d> v_mat_2d, *pv_mat_2d;
 typedef v_mat_2d::iterator _it_v_mat_2d;
@@ -217,12 +234,62 @@ class matrix_2d : public new_handler_support<matrix_2d> {
     inline UINT32 columns() const { return _cols; }
     inline double* getbuffer() const { return _buffer; }
 
+    inline double dense_get(const UINT32& row, const UINT32& column) const {
+        assert(_buffer != nullptr);
+        assert(!_packed && "dense_get(): matrix must not use packed storage");
+        assert(!_symmetric && "dense_get(): matrix must not use symmetric element redirection");
+        assert(row < _rows && "dense_get(): row out of bounds");
+        assert(column < _cols && "dense_get(): column out of bounds");
+        return _buffer[static_cast<std::size_t>(column) * _mem_rows + row];
+    }
+
+    inline void dense_put(const UINT32& row, const UINT32& column, const double& value) {
+        assert(_buffer != nullptr);
+        assert(!_packed && "dense_put(): matrix must not use packed storage");
+        assert(!_symmetric && "dense_put(): matrix must not use symmetric element redirection");
+        assert(row < _rows && "dense_put(): row out of bounds");
+        assert(column < _cols && "dense_put(): column out of bounds");
+        _buffer[static_cast<std::size_t>(column) * _mem_rows + row] = value;
+    }
+
+    inline void dense_add(const UINT32& row, const UINT32& column, const double& increment) {
+        assert(_buffer != nullptr);
+        assert(!_packed && "dense_add(): matrix must not use packed storage");
+        assert(!_symmetric && "dense_add(): matrix must not use symmetric element redirection");
+        assert(row < _rows && "dense_add(): row out of bounds");
+        assert(column < _cols && "dense_add(): column out of bounds");
+        _buffer[static_cast<std::size_t>(column) * _mem_rows + row] += increment;
+    }
+
+    inline double* dense_ptr(const UINT32& row, const UINT32& column) const {
+        assert(_buffer != nullptr);
+        assert(!_packed && "dense_ptr(): matrix must not use packed storage");
+        assert(!_symmetric && "dense_ptr(): matrix must not use symmetric element redirection");
+        assert(row < _rows && "dense_ptr(): row out of bounds");
+        assert(column < _cols && "dense_ptr(): column out of bounds");
+        return _buffer + static_cast<std::size_t>(column) * _mem_rows + row;
+    }
+
     // element retrieval
     // see DNAMATRIX_ROW_WISE
     inline double& get(const UINT32& row, const UINT32& column) const {
+        assert(_buffer != nullptr);
+        assert(row < _mem_rows && "get(): row out of bounds");
+        assert(column < _mem_cols && "get(): column out of bounds");
+        if (_packed) {
+            UINT32 i = row, j = column;
+            if (i < j) { i = column; j = row; }
+            return _buffer[packed_index(_rows, i, j)];
+        }
+        if (_symmetric && row < column)
+            return DNAMATRIX_ELEMENT(_buffer, _mem_rows, _mem_cols, column, row);
         return DNAMATRIX_ELEMENT(_buffer, _mem_rows, _mem_cols, row, column);
     }
     inline double* getbuffer(const UINT32& row, const UINT32& column) const {
+        assert(_buffer != nullptr);
+        assert(!_packed && "getbuffer(row,col): not valid for packed storage");
+        assert(row < _mem_rows && "getbuffer(): row out of bounds");
+        assert(column < _mem_cols && "getbuffer(): column out of bounds");
         return _buffer + DNAMATRIX_INDEX(_mem_rows, _mem_cols, row, column);
     }
 
@@ -236,9 +303,29 @@ class matrix_2d : public new_handler_support<matrix_2d> {
     inline UINT32 maxvalueCol() const { return _maxvalCol; }
 
     inline double* getelementref(const UINT32& row, const UINT32& column) const {
+        assert(_buffer != nullptr);
+        assert(row < _mem_rows && "getelementref(): row out of bounds");
+        assert(column < _mem_cols && "getelementref(): column out of bounds");
+        if (_packed) {
+            UINT32 i = row, j = column;
+            if (i < j) { i = column; j = row; }
+            return &_buffer[packed_index(_rows, i, j)];
+        }
+        if (_symmetric && row < column)
+            return &(DNAMATRIX_ELEMENT(_buffer, _mem_rows, _mem_cols, column, row));
         return &(DNAMATRIX_ELEMENT(_buffer, _mem_rows, _mem_cols, row, column));
     }
     inline double* getelementref(const UINT32& row, const UINT32& column) {
+        assert(_buffer != nullptr);
+        assert(row < _mem_rows && "getelementref(): row out of bounds");
+        assert(column < _mem_cols && "getelementref(): column out of bounds");
+        if (_packed) {
+            UINT32 i = row, j = column;
+            if (i < j) { i = column; j = row; }
+            return &_buffer[packed_index(_rows, i, j)];
+        }
+        if (_symmetric && row < column)
+            return &(DNAMATRIX_ELEMENT(_buffer, _mem_rows, _mem_cols, column, row));
         return &(DNAMATRIX_ELEMENT(_buffer, _mem_rows, _mem_cols, row, column));
     }
 
@@ -250,34 +337,139 @@ class matrix_2d : public new_handler_support<matrix_2d> {
     inline void maxvalueCol(const UINT32& c) { _maxvalCol = c; }
 
     inline void put(const UINT32& row, const UINT32& column, const double& value) {
+        assert(_buffer != nullptr);
+        assert(row < _mem_rows && "put(): row out of bounds");
+        assert(column < _mem_cols && "put(): column out of bounds");
+        if (_packed) {
+            UINT32 i = row, j = column;
+            if (i < j) { i = column; j = row; }
+            _buffer[packed_index(_rows, i, j)] = value;
+            return;
+        }
         DNAMATRIX_ELEMENT(_buffer, _mem_rows, _mem_cols, row, column) = value;
     }
 
     inline UINT32 matrixType() const { return _matrixType; }
     inline void matrixType(const UINT32 t) { _matrixType = t; }
 
+    inline bool is_symmetric() const { return _symmetric; }
+    inline void set_symmetric(bool s) {
+        assert((!s || _rows == _cols) && "set_symmetric(true): matrix must be square");
+        _symmetric = s;
+    }
+
+    inline bool is_packed() const { return _packed; }
+
+    static inline std::size_t packed_index(UINT32 n, UINT32 i, UINT32 j) {
+        return static_cast<std::size_t>(j) * n - static_cast<std::size_t>(j) * (j - 1) / 2 + (i - j);
+    }
+
+    static inline std::size_t packed_size(UINT32 n) {
+        return static_cast<std::size_t>(n) * (n + 1) / 2;
+    }
+
     // Matrix functions
-    void copyelements(const UINT32& row_dest, const UINT32& column_dest, const matrix_2d& src, const UINT32& row_src,
-                      const UINT32& column_src, const UINT32& rows, const UINT32& columns);
-    void copyelements(const UINT32& row_dest, const UINT32& column_dest, const matrix_2d* src, const UINT32& row_src,
-                      const UINT32& column_src, const UINT32& rows, const UINT32& columns);
+    inline void copyelements(const UINT32& row_dest, const UINT32& column_dest, const matrix_2d& src,
+                             const UINT32& row_src, const UINT32& column_src,
+                             const UINT32& rows, const UINT32& columns) {
+        assert(_buffer != nullptr && src._buffer != nullptr);
+        assert(row_dest + rows <= _mem_rows && "copyelements(): dest row overflow");
+        assert(column_dest + columns <= _mem_cols && "copyelements(): dest col overflow");
+        assert(row_src + rows <= src._mem_rows && "copyelements(): src row overflow");
+        assert(column_src + columns <= src._mem_cols && "copyelements(): src col overflow");
+        if (rows == 3 && columns == 3 && !src._symmetric && !src._packed && !_packed) {
+            for (UINT32 c = 0; c < 3; ++c) {
+                double* dst = _buffer + static_cast<std::size_t>(column_dest + c) * _mem_rows + row_dest;
+                const double* s = src._buffer + static_cast<std::size_t>(column_src + c) * src._mem_rows + row_src;
+                dst[0] = s[0]; dst[1] = s[1]; dst[2] = s[2];
+            }
+            return;
+        }
+        copyelements_generic(row_dest, column_dest, src, row_src, column_src, rows, columns);
+    }
+    void copyelements_generic(const UINT32& row_dest, const UINT32& column_dest, const matrix_2d& src,
+                              const UINT32& row_src, const UINT32& column_src,
+                              const UINT32& rows, const UINT32& columns);
+    inline void copyelements(const UINT32& row_dest, const UINT32& column_dest, const matrix_2d* src,
+                             const UINT32& row_src, const UINT32& column_src,
+                             const UINT32& rows, const UINT32& columns) {
+        copyelements(row_dest, column_dest, *src, row_src, column_src, rows, columns);
+    }
 
     inline void elementadd(const UINT32& row, const UINT32& column, const double& increment) {
+        assert(row < _rows && column < _cols && "elementadd(): out of bounds");
+        if (_packed && row < column) return;
         *getelementref(row, column) += increment;
     }
 
+    inline void lower_add(const UINT32& row, const UINT32& column, const double& increment) {
+        assert(_buffer != nullptr);
+        assert(row < _rows && column < _cols && "lower_add(): out of bounds");
+        if (_packed) {
+            if (row < column) return;
+            _buffer[packed_index(_rows, row, column)] += increment;
+            return;
+        }
+        if (_symmetric && row < column) {
+            _buffer[static_cast<std::size_t>(row) * _mem_rows + column] += increment;
+            return;
+        }
+        _buffer[static_cast<std::size_t>(column) * _mem_rows + row] += increment;
+    }
+
     inline void elementsubtract(const UINT32& row, const UINT32& column, const double& decrement) {
+        assert(row < _rows && column < _cols && "elementsubtract(): out of bounds");
+        if (_packed && row < column) return;
         *getelementref(row, column) -= decrement;
     }
 
     inline void elementmultiply(const UINT32& row, const UINT32& column, const double& scale) {
+        assert(row < _rows && column < _cols && "elementmultiply(): out of bounds");
         *getelementref(row, column) *= scale;
     }
 
-    void blockadd(const UINT32& row_dest, const UINT32& col_dest, const matrix_2d& mat_src, const UINT32& row_src,
-                  const UINT32& col_src, const UINT32& rows, const UINT32& cols);
-    void blockTadd(const UINT32& row_dest, const UINT32& col_dest, const matrix_2d& mat_src, const UINT32& row_src,
-                   const UINT32& col_src, const UINT32& rows, const UINT32& cols);
+    inline void blockadd(const UINT32& row_dest, const UINT32& col_dest, const matrix_2d& mat_src,
+                         const UINT32& row_src, const UINT32& col_src, const UINT32& rows, const UINT32& cols) {
+        assert(_buffer != nullptr && mat_src._buffer != nullptr);
+        assert(row_dest + rows <= _mem_rows && "blockadd(): dest row overflow");
+        assert(col_dest + cols <= _mem_cols && "blockadd(): dest col overflow");
+        assert(row_src + rows <= mat_src._mem_rows && "blockadd(): src row overflow");
+        assert(col_src + cols <= mat_src._mem_cols && "blockadd(): src col overflow");
+        if (rows == 3 && cols == 3 && !mat_src._symmetric && !mat_src._packed && !_packed) {
+            for (UINT32 c = 0; c < 3; ++c) {
+                double* dst = _buffer + static_cast<std::size_t>(col_dest + c) * _mem_rows + row_dest;
+                const double* src = mat_src._buffer + static_cast<std::size_t>(col_src + c) * mat_src._mem_rows + row_src;
+                dst[0] += src[0]; dst[1] += src[1]; dst[2] += src[2];
+            }
+            return;
+        }
+        blockadd_generic(row_dest, col_dest, mat_src, row_src, col_src, rows, cols);
+    }
+    void blockadd_generic(const UINT32& row_dest, const UINT32& col_dest, const matrix_2d& mat_src,
+                          const UINT32& row_src, const UINT32& col_src, const UINT32& rows, const UINT32& cols);
+
+    inline void blockTadd(const UINT32& row_dest, const UINT32& col_dest, const matrix_2d& mat_src,
+                          const UINT32& row_src, const UINT32& col_src, const UINT32& rows, const UINT32& cols) {
+        assert(_buffer != nullptr && mat_src._buffer != nullptr);
+        assert(row_dest + rows <= _mem_rows && "blockTadd(): dest row overflow");
+        assert(col_dest + cols <= _mem_cols && "blockTadd(): dest col overflow");
+        assert(row_src + cols <= mat_src._mem_rows && "blockTadd(): src row overflow (transposed)");
+        assert(col_src + rows <= mat_src._mem_cols && "blockTadd(): src col overflow (transposed)");
+        if (rows == 3 && cols == 3 && !_packed) {
+            for (UINT32 c = 0; c < 3; ++c) {
+                double* dst = _buffer + static_cast<std::size_t>(col_dest + c) * _mem_rows + row_dest;
+                const std::size_t smr = mat_src._mem_rows;
+                const double* src_r0 = mat_src._buffer + static_cast<std::size_t>(row_src) * smr + col_src + c;
+                dst[0] += src_r0[0];
+                dst[1] += src_r0[smr];
+                dst[2] += src_r0[2 * smr];
+            }
+            return;
+        }
+        blockTadd_generic(row_dest, col_dest, mat_src, row_src, col_src, rows, cols);
+    }
+    void blockTadd_generic(const UINT32& row_dest, const UINT32& col_dest, const matrix_2d& mat_src,
+                           const UINT32& row_src, const UINT32& col_src, const UINT32& rows, const UINT32& cols);
     void blocksubtract(const UINT32& row_dest, const UINT32& col_dest, const matrix_2d& mat_src, const UINT32& row_src,
                        const UINT32& col_src, const UINT32& rows, const UINT32& cols);
 
@@ -287,13 +479,19 @@ class matrix_2d : public new_handler_support<matrix_2d> {
     matrix_2d multiply(const char* lhs_trans, const matrix_2d& rhs, const char* rhs_trans); // multiplication
     matrix_2d multiply(const matrix_2d& lhs, const char* lhs_trans, const matrix_2d& rhs,
                        const char* rhs_trans); // multiplication
+    // C = sym_lhs * rhs using dsymm (sym_lhs must be symmetric, lower triangle populated)
+    matrix_2d multiply_sym(const matrix_2d& sym_lhs, const matrix_2d& rhs);
 
     matrix_2d sweepinverse();                                  // Sweep inverse (good for rotation matrices)
-    matrix_2d cholesky_inverse(bool LOWER_IS_CLEARED = false); // Cholesky inverse
+    matrix_2d cholesky_inverse(bool LOWER_IS_CLEARED = false, bool mark_symmetric = false); // Cholesky inverse
+    matrix_2d cholesky_factor(bool LOWER_IS_CLEARED = false);  // Cholesky factor only (dpotrf), no inverse
+    void cholesky_solve(matrix_2d& rhs, bool LOWER_IS_CLEARED = false);  // Solve from pre-factored matrix (dpotrs)
+    double dot(const matrix_2d& other) const;  // Inner product of two column vectors
 
     matrix_2d transpose(const matrix_2d&); // Transpose
     matrix_2d transpose();                 //  ''
     matrix_2d scale(const double& scalar); // scale
+    void scale_symmetric_diagonal(const double* diag);
 
     // overloaded operators
     // equality
@@ -347,6 +545,7 @@ class matrix_2d : public new_handler_support<matrix_2d> {
     void setsize(const UINT32& rows,
                  const UINT32& columns); // sets matrix size to rows * columns only (buffer not allocated any memory)
     void redim(const UINT32& rows, const UINT32& columns); // redimensions matrix to rows * columns
+    void redim_packed(const UINT32& n);                    // redimensions to packed symmetric n×n
     void replace(const UINT32& rowstart, const UINT32& columnstart, const matrix_2d& newmat);
     void replace(const UINT32& rowstart, const UINT32& columnstart, const UINT32& rows, const UINT32& columns,
                  const matrix_2d& newmat);
@@ -369,6 +568,14 @@ class matrix_2d : public new_handler_support<matrix_2d> {
     // Writing to memory mapped file
     void WriteMappedFileRegion(void* addr);
 
+    // In-place mmap: attach _buffer directly to mmap data region (no memcpy)
+    void AttachMappedFileRegion(void* addr);
+
+    // In-place mmap: write footer back, detach _buffer
+    void DetachMappedFileRegion(void* addr);
+
+    inline bool owns_buffer() const { return _owns_buffer; }
+
     // debug
 #ifdef _MSDEBUG
     void trace(const std::string& comment, const std::string& format) const;
@@ -376,12 +583,14 @@ class matrix_2d : public new_handler_support<matrix_2d> {
                const UINT32& row_begin, const UINT32& col_begin, const UINT32& rows, const UINT32& columns) const;
 #endif
 
+    void deallocate();
+
   private:
     inline std::size_t buffersize() const {
+        if (_packed)
+            return packed_size(_mem_rows) * sizeof(double);
         return static_cast<std::size_t>(_mem_rows) * static_cast<std::size_t>(_mem_cols) * sizeof(double);
     }
-
-    void deallocate();
     void buy(const UINT32& rows, const UINT32& columns, double** mem_space);
     void copybuffer(const UINT32& rows, const UINT32& columns, const matrix_2d& oldmat);
     void copybuffer(const UINT32& rowstart, const UINT32& columnstart, const UINT32& rows, const UINT32& columns,
@@ -395,11 +604,14 @@ class matrix_2d : public new_handler_support<matrix_2d> {
     UINT32 _cols;     // number of actual cols
     UINT32 _rows;     // number of actual rows
     double* _buffer;  // matrix buffer elements
+    bool _owns_buffer; // true if _buffer is heap-allocated (false when attached to mmap)
 
     UINT32 _maxvalCol; // col of max value
     UINT32 _maxvalRow; // row of max value
 
     UINT32 _matrixType; // full, upper/lower, sparse
+    bool _symmetric;    // only lower triangle populated (upper is mirror)
+    bool _packed;       // packed column-major lower-triangle storage (n*(n+1)/2 elements)
 };
 
 } // namespace math
diff --git a/dynadjust/include/measurement_types/dnaangle.cpp b/dynadjust/include/measurement_types/dnaangle.cpp
index 5372f4d67..59b795bda 100644
--- a/dynadjust/include/measurement_types/dnaangle.cpp
+++ b/dynadjust/include/measurement_types/dnaangle.cpp
@@ -250,6 +250,7 @@ UINT32 CDnaAngle::SetMeasurementRec(const vstn_t& binaryStn, it_vmsr_t& it_msr,
 	m_dStdDev = sqrt(it_msr->term2);
 	
 	m_epoch = it_msr->epoch;
+	m_observation_epoch = it_msr->observation_epoch;
 	m_sourceFileIndex = it_msr->sourceFileIndex;
 
 	CDnaMeasurement::SetDatabaseMap(*dbidmap);
@@ -278,6 +279,7 @@ void CDnaAngle::WriteBinaryMsr(std::ofstream* binary_stream, PUINT32 msrIndex) c
 	measRecord.fileOrder = ((*msrIndex)++);
 
 	snprintf(measRecord.epoch, sizeof(measRecord.epoch), "%s", m_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
+	snprintf(measRecord.observation_epoch, sizeof(measRecord.observation_epoch), "%s", m_observation_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
 
 	binary_stream->write(reinterpret_cast<char *>(&measRecord), sizeof(measurement_t));
 }
diff --git a/dynadjust/include/measurement_types/dnacoordinate.cpp b/dynadjust/include/measurement_types/dnacoordinate.cpp
index d7d488496..27f5b20ca 100644
--- a/dynadjust/include/measurement_types/dnacoordinate.cpp
+++ b/dynadjust/include/measurement_types/dnacoordinate.cpp
@@ -202,6 +202,7 @@ UINT32 CDnaCoordinate::SetMeasurementRec(const vstn_t& binaryStn, it_vmsr_t& it_
 	m_dStdDev = sqrt(it_msr->term2);
 
 	m_epoch = it_msr->epoch;
+	m_observation_epoch = it_msr->observation_epoch;
 	m_sourceFileIndex = it_msr->sourceFileIndex;
 
 	CDnaMeasurement::SetDatabaseMap(*dbidmap);
@@ -229,6 +230,7 @@ void CDnaCoordinate::WriteBinaryMsr(std::ofstream* binary_stream, PUINT32 msrInd
 	measRecord.fileOrder = ((*msrIndex)++);
 
 	snprintf(measRecord.epoch, sizeof(measRecord.epoch), "%s", m_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
+	snprintf(measRecord.observation_epoch, sizeof(measRecord.observation_epoch), "%s", m_observation_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
 
 	binary_stream->write(reinterpret_cast<char *>(&measRecord), sizeof(measurement_t));
 }
diff --git a/dynadjust/include/measurement_types/dnadirection.cpp b/dynadjust/include/measurement_types/dnadirection.cpp
index 01060e397..f204754bb 100644
--- a/dynadjust/include/measurement_types/dnadirection.cpp
+++ b/dynadjust/include/measurement_types/dnadirection.cpp
@@ -65,6 +65,7 @@ CDnaDirection::CDnaDirection(CDnaDirection&& d)
 	m_msr_db_map = d.m_msr_db_map;
 
 	m_epoch = d.m_epoch;
+	m_observation_epoch = d.m_observation_epoch;
 }
 
 // move assignment operator 
@@ -599,13 +600,14 @@ UINT32 CDnaDirection::SetMeasurementRec(const vstn_t& binaryStn, it_vmsr_t& it_m
 	m_dStdDev = sqrt(it_msr->term2);
 
 	m_epoch = it_msr->epoch;
+	m_observation_epoch = it_msr->observation_epoch;
 	m_sourceFileIndex = it_msr->sourceFileIndex;
 
 	CDnaMeasurement::SetDatabaseMap(*dbidmap);
-	
+
 	return 0;
 }
-	
+
 
 void CDnaDirection::WriteBinaryMsr(std::ofstream* binary_stream, PUINT32 msrIndex) const
 {
@@ -636,6 +638,7 @@ void CDnaDirection::WriteBinaryMsr(std::ofstream* binary_stream, PUINT32 msrInde
 	measRecord.fileOrder = ((*msrIndex)++);
 
 	snprintf(measRecord.epoch, sizeof(measRecord.epoch), "%s", m_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
+	snprintf(measRecord.observation_epoch, sizeof(measRecord.observation_epoch), "%s", m_observation_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
 
 	binary_stream->write(reinterpret_cast<char *>(&measRecord), sizeof(measurement_t));
 }
diff --git a/dynadjust/include/measurement_types/dnadirectionset.cpp b/dynadjust/include/measurement_types/dnadirectionset.cpp
index 3e72c344d..f412adb03 100644
--- a/dynadjust/include/measurement_types/dnadirectionset.cpp
+++ b/dynadjust/include/measurement_types/dnadirectionset.cpp
@@ -394,6 +394,7 @@ UINT32 CDnaDirectionSet::SetMeasurementRec(const vstn_t& binaryStn, it_vmsr_t& i
 	m_lsetID = it_msr->clusterID;
 
 	m_epoch = it_msr->epoch;
+	m_observation_epoch = it_msr->observation_epoch;
 	m_sourceFileIndex = it_msr->sourceFileIndex;
 
 	m_vTargetDirections.clear();
@@ -455,6 +456,7 @@ void CDnaDirectionSet::WriteBinaryMsr(std::ofstream* binary_stream, PUINT32 msrI
 	measRecord.fileOrder = ((*msrIndex)++);
 
 	snprintf(measRecord.epoch, sizeof(measRecord.epoch), "%s", m_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
+	snprintf(measRecord.observation_epoch, sizeof(measRecord.observation_epoch), "%s", m_observation_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
 
 	binary_stream->write(reinterpret_cast<char *>(&measRecord), sizeof(measurement_t));
 
diff --git a/dynadjust/include/measurement_types/dnadistance.cpp b/dynadjust/include/measurement_types/dnadistance.cpp
index f02a2f312..c50d1fb3d 100644
--- a/dynadjust/include/measurement_types/dnadistance.cpp
+++ b/dynadjust/include/measurement_types/dnadistance.cpp
@@ -283,6 +283,7 @@ UINT32 CDnaDistance::SetMeasurementRec(const vstn_t& binaryStn, it_vmsr_t& it_ms
 	m_dStdDev = sqrt(it_msr->term2);
 
 	m_epoch = it_msr->epoch;
+	m_observation_epoch = it_msr->observation_epoch;
 	m_sourceFileIndex = it_msr->sourceFileIndex;
 
 	CDnaMeasurement::SetDatabaseMap(*dbidmap);
@@ -313,6 +314,7 @@ void CDnaDistance::WriteBinaryMsr(std::ofstream* binary_stream, PUINT32 msrIndex
 	measRecord.fileOrder = ((*msrIndex)++);
 
 	snprintf(measRecord.epoch, sizeof(measRecord.epoch), "%s", m_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
+	snprintf(measRecord.observation_epoch, sizeof(measRecord.observation_epoch), "%s", m_observation_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
 
 	binary_stream->write(reinterpret_cast<char *>(&measRecord), sizeof(measurement_t));
 }
diff --git a/dynadjust/include/measurement_types/dnagpsbaseline.cpp b/dynadjust/include/measurement_types/dnagpsbaseline.cpp
index f1d5c501a..68e203102 100644
--- a/dynadjust/include/measurement_types/dnagpsbaseline.cpp
+++ b/dynadjust/include/measurement_types/dnagpsbaseline.cpp
@@ -76,7 +76,8 @@ CDnaGpsBaseline::CDnaGpsBaseline(CDnaGpsBaseline&& g)
 	m_referenceFrame = g.m_referenceFrame;
 	m_epsgCode = g.m_epsgCode;
 	m_epoch = g.m_epoch;
-	
+	m_observation_epoch = g.m_observation_epoch;
+
 	m_dX = g.m_dX;
 	m_dY = g.m_dY;
 	m_dZ = g.m_dZ;
@@ -114,6 +115,7 @@ CDnaGpsBaseline& CDnaGpsBaseline::operator= (CDnaGpsBaseline&& rhs)
 	m_referenceFrame = rhs.m_referenceFrame;
 	m_epsgCode = rhs.m_epsgCode;
 	m_epoch = rhs.m_epoch;
+	m_observation_epoch = rhs.m_observation_epoch;
 
 	m_dX = rhs.m_dX;
 	m_dY = rhs.m_dY;
@@ -371,6 +373,7 @@ UINT32 CDnaGpsBaseline::SetMeasurementRec(const vstn_t& binaryStn, it_vmsr_t& it
 	m_dVscale = it_msr->scale4;
 
 	m_epoch = it_msr->epoch;
+	m_observation_epoch = it_msr->observation_epoch;
 	m_epsgCode = it_msr->epsgCode;
 	m_referenceFrame = datumFromEpsgString<std::string>(it_msr->epsgCode);
 
@@ -437,6 +440,7 @@ void CDnaGpsBaseline::WriteBinaryMsr(std::ofstream* binary_stream, PUINT32 msrIn
 
 	snprintf(measRecord.epsgCode, sizeof(measRecord.epsgCode), "%s", m_epsgCode.substr(0, STN_EPSG_WIDTH).c_str());
 	snprintf(measRecord.epoch, sizeof(measRecord.epoch), "%s", m_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
+	snprintf(measRecord.observation_epoch, sizeof(measRecord.observation_epoch), "%s", m_observation_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
 
 	// X
 	measRecord.measAdj = m_measAdj;
@@ -485,7 +489,7 @@ void CDnaGpsBaseline::WriteBinaryMsr(std::ofstream* binary_stream, PUINT32 msrIn
 	// now write covariance elements
 	std::vector<CDnaCovariance>::const_iterator _it_cov;
 	for (_it_cov=m_vGpsCovariances.begin(); _it_cov!=m_vGpsCovariances.end(); ++_it_cov)
-		_it_cov->WriteBinaryMsr(binary_stream, msrIndex, m_epsgCode, m_epoch);
+		_it_cov->WriteBinaryMsr(binary_stream, msrIndex, m_epsgCode, m_epoch, m_observation_epoch);
 }
 
 void CDnaGpsBaseline::SerialiseDatabaseMap(std::ofstream* os)
@@ -650,17 +654,18 @@ CDnaGpsBaselineCluster::CDnaGpsBaselineCluster(CDnaGpsBaselineCluster&& g)
 	m_dVscale = g.m_dVscale;
 	m_lclusterID = g.m_lclusterID;
 	m_MSmeasurementStations = g.m_MSmeasurementStations;
-	
+
 	m_referenceFrame = g.m_referenceFrame;
 	m_epsgCode = g.m_epsgCode;
 	m_epoch = g.m_epoch;
+	m_observation_epoch = g.m_observation_epoch;
 
 	m_msr_db_map = g.m_msr_db_map;
 
 	m_dbidmap = g.m_dbidmap;
 }
 
-// move assignment operator 
+// move assignment operator
 CDnaGpsBaselineCluster& CDnaGpsBaselineCluster::operator= (CDnaGpsBaselineCluster&& rhs)
 {
 	// check for assignment to self!
@@ -674,6 +679,7 @@ CDnaGpsBaselineCluster& CDnaGpsBaselineCluster::operator= (CDnaGpsBaselineCluste
 	m_referenceFrame = rhs.m_referenceFrame;
 	m_epsgCode = rhs.m_epsgCode;
 	m_epoch = rhs.m_epoch;
+	m_observation_epoch = rhs.m_observation_epoch;
 
 	m_dPscale = rhs.m_dPscale;
 	m_dLscale = rhs.m_dLscale;
@@ -891,6 +897,7 @@ UINT32 CDnaGpsBaselineCluster::SetMeasurementRec(const vstn_t& binaryStn, it_vms
 
 	m_referenceFrame = datumFromEpsgString<std::string>(it_msr->epsgCode);
 	m_epoch = it_msr->epoch;
+	m_observation_epoch = it_msr->observation_epoch;
 	m_epsgCode = it_msr->epsgCode;
 	m_sourceFileIndex = it_msr->sourceFileIndex;
 
diff --git a/dynadjust/include/measurement_types/dnagpspoint.cpp b/dynadjust/include/measurement_types/dnagpspoint.cpp
index 0696c251a..0f2e8a05a 100644
--- a/dynadjust/include/measurement_types/dnagpspoint.cpp
+++ b/dynadjust/include/measurement_types/dnagpspoint.cpp
@@ -78,6 +78,7 @@ CDnaGpsPoint::CDnaGpsPoint(CDnaGpsPoint&& p)
 	m_referenceFrame = p.m_referenceFrame;
 	m_epsgCode = p.m_epsgCode;
 	m_epoch = p.m_epoch;
+	m_observation_epoch = p.m_observation_epoch;
 
 	m_dX = p.m_dX;
 	m_dY = p.m_dY;
@@ -95,7 +96,7 @@ CDnaGpsPoint::CDnaGpsPoint(CDnaGpsPoint&& p)
 	m_dVscale = p.m_dVscale;
 
 	SetCoordType(p.m_strCoordType);
-	
+
 	m_lclusterID = p.m_lclusterID;
 	m_MSmeasurementStations = p.m_MSmeasurementStations;
 
@@ -117,6 +118,7 @@ CDnaGpsPoint& CDnaGpsPoint::operator= (CDnaGpsPoint&& rhs)
 	m_referenceFrame = rhs.m_referenceFrame;
 	m_epsgCode = rhs.m_epsgCode;
 	m_epoch = rhs.m_epoch;
+	m_observation_epoch = rhs.m_observation_epoch;
 
 	m_dX = rhs.m_dX;
 	m_dY = rhs.m_dY;
@@ -134,7 +136,7 @@ CDnaGpsPoint& CDnaGpsPoint::operator= (CDnaGpsPoint&& rhs)
 	m_dVscale = rhs.m_dVscale;
 
 	SetCoordType(rhs.m_strCoordType);
-	
+
 	m_lclusterID = rhs.m_lclusterID;
 	m_MSmeasurementStations = rhs.m_MSmeasurementStations;
 
@@ -478,12 +480,13 @@ UINT32 CDnaGpsPoint::SetMeasurementRec(const vstn_t& binaryStn, it_vmsr_t& it_ms
 	m_dVscale = it_msr->scale4;
 
 	m_epoch = it_msr->epoch;
+	m_observation_epoch = it_msr->observation_epoch;
 	m_epsgCode = it_msr->epsgCode;
 	m_referenceFrame = datumFromEpsgCode<std::string, UINT32>(LongFromString<UINT32>(it_msr->epsgCode));
 
 	m_lclusterID = it_msr->clusterID;
 	m_MSmeasurementStations = (MEASUREMENT_STATIONS)it_msr->measurementStations;
-	
+
 	// X, sigmaXX
 	m_bIgnore = it_msr->ignore;
 	m_strType = it_msr->measType;
@@ -548,6 +551,7 @@ void CDnaGpsPoint::WriteBinaryMsr(std::ofstream* binary_stream, PUINT32 msrIndex
 
 	snprintf(measRecord.epsgCode, sizeof(measRecord.epsgCode), "%s", m_epsgCode.substr(0, STN_EPSG_WIDTH).c_str());
 	snprintf(measRecord.epoch, sizeof(measRecord.epoch), "%s", m_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
+	snprintf(measRecord.observation_epoch, sizeof(measRecord.observation_epoch), "%s", m_observation_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
 
 	// X
 	measRecord.measAdj = m_measAdj;
@@ -596,7 +600,7 @@ void CDnaGpsPoint::WriteBinaryMsr(std::ofstream* binary_stream, PUINT32 msrIndex
 	// now write covariance elements
 	std::vector<CDnaCovariance>::const_iterator _it_cov;
 	for (_it_cov=m_vPointCovariances.begin(); _it_cov!=m_vPointCovariances.end(); ++_it_cov)
-		_it_cov->WriteBinaryMsr(binary_stream, msrIndex, m_epsgCode, m_epoch);
+		_it_cov->WriteBinaryMsr(binary_stream, msrIndex, m_epsgCode, m_epoch, m_observation_epoch);
 }
 
 
@@ -756,6 +760,7 @@ CDnaGpsPointCluster::CDnaGpsPointCluster(CDnaGpsPointCluster&& p)
 	m_referenceFrame = p.m_referenceFrame;
 	m_epsgCode = p.m_epsgCode;
 	m_epoch = p.m_epoch;
+	m_observation_epoch = p.m_observation_epoch;
 
 	m_msr_db_map = p.m_msr_db_map;
 
@@ -776,6 +781,7 @@ CDnaGpsPointCluster& CDnaGpsPointCluster::operator= (CDnaGpsPointCluster&& rhs)
 	m_referenceFrame = rhs.m_referenceFrame;
 	m_epsgCode = rhs.m_epsgCode;
 	m_epoch = rhs.m_epoch;
+	m_observation_epoch = rhs.m_observation_epoch;
 
 	m_dPscale = rhs.m_dPscale;
 	m_dLscale = rhs.m_dLscale;
@@ -1014,6 +1020,7 @@ UINT32 CDnaGpsPointCluster::SetMeasurementRec(const vstn_t& binaryStn, it_vmsr_t
 
 	m_referenceFrame = datumFromEpsgCode<std::string, UINT32>(LongFromString<UINT32>(it_msr->epsgCode));
 	m_epoch = it_msr->epoch;
+	m_observation_epoch = it_msr->observation_epoch;
 	m_epsgCode = it_msr->epsgCode;
 	m_sourceFileIndex = it_msr->sourceFileIndex;
 
diff --git a/dynadjust/include/measurement_types/dnaheight.cpp b/dynadjust/include/measurement_types/dnaheight.cpp
index ae86d6c41..3ffecad56 100644
--- a/dynadjust/include/measurement_types/dnaheight.cpp
+++ b/dynadjust/include/measurement_types/dnaheight.cpp
@@ -184,6 +184,7 @@ UINT32 CDnaHeight::SetMeasurementRec(const vstn_t& binaryStn, it_vmsr_t& it_msr,
 	m_dStdDev = sqrt(it_msr->term2);
 
 	m_epoch = it_msr->epoch;
+	m_observation_epoch = it_msr->observation_epoch;
 	m_sourceFileIndex = it_msr->sourceFileIndex;
 
 	CDnaMeasurement::SetDatabaseMap(*dbidmap);
@@ -213,6 +214,7 @@ void CDnaHeight::WriteBinaryMsr(std::ofstream* binary_stream, PUINT32 msrIndex)
 	measRecord.fileOrder = ((*msrIndex)++);
 
 	snprintf(measRecord.epoch, sizeof(measRecord.epoch), "%s", m_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
+	snprintf(measRecord.observation_epoch, sizeof(measRecord.observation_epoch), "%s", m_observation_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
 
 	binary_stream->write(reinterpret_cast<char *>(&measRecord), sizeof(measurement_t));
 }
diff --git a/dynadjust/include/measurement_types/dnaheightdifference.cpp b/dynadjust/include/measurement_types/dnaheightdifference.cpp
index ba7e26db0..c8c15a8a1 100644
--- a/dynadjust/include/measurement_types/dnaheightdifference.cpp
+++ b/dynadjust/include/measurement_types/dnaheightdifference.cpp
@@ -220,6 +220,7 @@ UINT32 CDnaHeightDifference::SetMeasurementRec(const vstn_t& binaryStn, it_vmsr_
 	m_dStdDev = sqrt(it_msr->term2);
 
 	m_epoch = it_msr->epoch;
+	m_observation_epoch = it_msr->observation_epoch;
 	m_sourceFileIndex = it_msr->sourceFileIndex;
 
 	CDnaMeasurement::SetDatabaseMap(*dbidmap);
@@ -248,6 +249,7 @@ void CDnaHeightDifference::WriteBinaryMsr(std::ofstream* binary_stream, PUINT32
 	measRecord.fileOrder = ((*msrIndex)++);
 
 	snprintf(measRecord.epoch, sizeof(measRecord.epoch), "%s", m_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
+	snprintf(measRecord.observation_epoch, sizeof(measRecord.observation_epoch), "%s", m_observation_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
 
 	binary_stream->write(reinterpret_cast<char *>(&measRecord), sizeof(measurement_t));
 }
diff --git a/dynadjust/include/measurement_types/dnameasurement.cpp b/dynadjust/include/measurement_types/dnameasurement.cpp
index 6608a4881..6a76d77ea 100644
--- a/dynadjust/include/measurement_types/dnameasurement.cpp
+++ b/dynadjust/include/measurement_types/dnameasurement.cpp
@@ -221,19 +221,20 @@ UINT32 CDnaCovariance::SetMeasurementRec(const vstn_t&, it_vmsr_t& it_msr)
 }
 	
 
-void CDnaCovariance::WriteBinaryMsr(std::ofstream *binary_stream, PUINT32 msrIndex, const std::string& epsgCode, const std::string& epoch) const
+void CDnaCovariance::WriteBinaryMsr(std::ofstream *binary_stream, PUINT32 msrIndex, const std::string& epsgCode, const std::string& epoch, const std::string& observation_epoch) const
 {
 	*msrIndex += 3;
 	measurement_t measRecord;
 
 	// Common
 	measRecord.measType = GetTypeC();
-	measRecord.station1 = m_lstn1Index;	
-	measRecord.station2 = m_lstn2Index;	
+	measRecord.station1 = m_lstn1Index;
+	measRecord.station2 = m_lstn2Index;
 	measRecord.clusterID = m_lclusterID;
-	
+
 	snprintf(measRecord.epsgCode, sizeof(measRecord.epsgCode), "%s", epsgCode.substr(0, STN_EPSG_WIDTH).c_str());
 	snprintf(measRecord.epoch, sizeof(measRecord.epoch), "%s", epoch.substr(0, STN_EPOCH_WIDTH).c_str());
+	snprintf(measRecord.observation_epoch, sizeof(measRecord.observation_epoch), "%s", observation_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
 
 	// X
 	measRecord.measStart = xCov;
@@ -360,6 +361,7 @@ CDnaMeasurement::CDnaMeasurement()
 	, m_epsgCode(DEFAULT_EPSG_S)
 	, m_sourceFileIndex(0)
 	, m_epoch("")
+	, m_observation_epoch("")
 	, m_bInsufficient(false)
 {
 }
@@ -388,6 +390,7 @@ CDnaMeasurement::CDnaMeasurement(CDnaMeasurement&& m)
 	m_preAdjCorr = m.m_preAdjCorr;
 
 	m_epoch = m.m_epoch;
+	m_observation_epoch = m.m_observation_epoch;
 	m_epsgCode = m.m_epsgCode;
 	m_sourceFileIndex = m.m_sourceFileIndex;
 
@@ -419,6 +422,7 @@ CDnaMeasurement& CDnaMeasurement::operator= (CDnaMeasurement&& rhs)
 	m_preAdjCorr = rhs.m_preAdjCorr;
 
 	m_epoch = rhs.m_epoch;
+	m_observation_epoch = rhs.m_observation_epoch;
 	m_epsgCode = rhs.m_epsgCode;
 	m_sourceFileIndex = rhs.m_sourceFileIndex;
 
@@ -501,6 +505,16 @@ void CDnaMeasurement::SerialiseDatabaseMap(std::ofstream* os)
 void CDnaMeasurement::SetEpoch(const std::string& epoch)
 {
 	m_epoch = epoch;
+	// Default the (immutable) observation epoch to the reference-frame epoch
+	// when it has not been explicitly supplied. Legacy DNA v3.01 / DynaML
+	// files without <EpochOfObservation> thus behave identically to before.
+	if (m_observation_epoch.empty())
+		m_observation_epoch = epoch;
+}
+
+void CDnaMeasurement::SetObservationEpoch(const std::string& observation_epoch)
+{
+	m_observation_epoch = observation_epoch;
 }
 
 }	// namespace measurements
diff --git a/dynadjust/include/measurement_types/dnameasurement.hpp b/dynadjust/include/measurement_types/dnameasurement.hpp
index 20bcf90e8..0fabeaa55 100644
--- a/dynadjust/include/measurement_types/dnameasurement.hpp
+++ b/dynadjust/include/measurement_types/dnameasurement.hpp
@@ -144,15 +144,20 @@ typedef struct msr_t {
 			memset(epsgCode, '\0', sizeof(epsgCode));
 			snprintf(epsgCode, sizeof(epsgCode), DEFAULT_EPSG_S);
 			memset(epoch, '\0', sizeof(epoch));
+			memset(observation_epoch, '\0', sizeof(observation_epoch));
 	}
 
 	char	measType;				// 'A', 'S', 'X', ... , etc.
 	char	measStart;				// Start of a measurement (0=start or X, 1=Y, 2=Z, 3=covX, 4=covY, 5=covZ)
 	char	measurementStations;	// One-, two- or three-station measurement
 	char	epsgCode[7];			// epsg ID, i.e. NNNNN (where NNNNN is in the range 0-32767)
-	char	epoch[12];				// date, i.e. "DD.MM.YYYY" (10 chars)
-									// if datum is dynamic, Epoch is YYYY MM DD
-									// if datum is static, Epoch is ignored
+	char	epoch[STN_EPOCH_WIDTH];	// Epoch of Reference Frame, i.e. "DD.MM.YYYY" (10 chars)
+									// Mutable via dnareftran.
+									// If datum is static, Epoch is ignored.
+	char	observation_epoch[STN_EPOCH_WIDTH];	// Epoch of Observation, i.e. "DD.MM.YYYY" (10 chars)
+									// Immutable under reftran. Timestamp at which the measurement
+									// was observed. Used for discontinuity station-instance
+									// allocation. Empty if not supplied.
 	char	coordType[4];			// "LLH", "UTM", ... , etc.
 	bool	ignore;
 	UINT32	station1;        		// stations 1, 2 and 3 are indices to
@@ -221,7 +226,7 @@ class CDnaCovariance
 	inline bool GetIgnore() const { return m_bIgnore; }
 
 	inline virtual UINT32 CalcBinaryRecordCount() const { return 3; }
-	void WriteBinaryMsr(std::ofstream* binary_stream, PUINT32 msrIndex, const std::string& epsgCode, const std::string& epoch) const;
+	void WriteBinaryMsr(std::ofstream* binary_stream, PUINT32 msrIndex, const std::string& epsgCode, const std::string& epoch, const std::string& observation_epoch) const;
 	virtual UINT32 SetMeasurementRec(const vstn_t& binaryStn, it_vmsr_t& it_msr);
 	virtual void WriteDynaMLMsr(std::ofstream* dynaml_stream) const;
 	virtual void WriteDNAMsr(std::ofstream* dna_stream, 
@@ -374,6 +379,7 @@ class CDnaMeasurement
 
 	virtual inline std::string GetReferenceFrame() const { return ""; }
 	inline std::string GetEpoch() const { return m_epoch; }
+	inline std::string GetObservationEpoch() const { return m_observation_epoch; }
 	
 	virtual inline std::vector<CDnaGpsBaseline>* GetBaselines_ptr() { return 0; }
 	virtual inline std::vector<CDnaDirection>* GetDirections_ptr() { return 0; }
@@ -402,6 +408,7 @@ class CDnaMeasurement
 	
 	virtual void SetReferenceFrame(const std::string&) {}
 	void SetEpoch(const std::string& epoch);
+	void SetObservationEpoch(const std::string& observation_epoch);
 	
 	virtual void SetLscale(const std::string&) {}
 	virtual void SetLscale(const double&) {}
@@ -485,7 +492,8 @@ class CDnaMeasurement
 	UINT32		m_sourceFileIndex;
 
 	std::string	m_epoch;
-	
+	std::string	m_observation_epoch;
+
 	msr_database_id_map		m_msr_db_map;
 
 	bool	m_bInsufficient;
@@ -514,21 +522,21 @@ class DNATYPE_API MsrTally
 	UINT32 TotalCount();
 	void coutSummary(std::ostream &os, const std::string& title);
 	UINT32 MeasurementCount(const char& msrType);
-	
+
 	void CreateTally(const vdnaMsrPtr& vMeasurements);
 	void CreateTally(const vmsr_t& vMeasurements, const vUINT32& CML);
 	UINT32 CreateTally(const vmsr_t& vMeasurements, bool countValidOnly=false);
-	
+
 	void IncrementMsrType(const char& msrType, const UINT32& count=1);
-	
+
 	void coutSummaryMsrToStn(std::ostream &os, const std::string& station);
 	void coutSummaryMsrToStn_Compressed(std::ostream &os, const std::string& station);
 
-	//bool GPSOnly();	
+	//bool GPSOnly();
 	inline bool ContainsNonGPS() { return containsNonGPS; }
 
 	static _MEASUREMENT_STATIONS_ Stations(const char& measType);
-	
+
 	bool containsNonGPS;
 
 	UINT32 A, B, C, D, E, G, H, I, J, K, L, M, P, Q, R, S, V, X, Y, Z;
diff --git a/dynadjust/include/measurement_types/dnastation.cpp b/dynadjust/include/measurement_types/dnastation.cpp
index c728fa278..83a4d455f 100644
--- a/dynadjust/include/measurement_types/dnastation.cpp
+++ b/dynadjust/include/measurement_types/dnastation.cpp
@@ -120,7 +120,7 @@ CDnaStation::CDnaStation(const std::string& referenceframe, const std::string& e
 	, m_fgeoidSep(0.), m_dmeridianDef(0.), m_dverticalDef(0.)
 	, m_lfileOrder(0), m_lnameOrder(0)
 	, m_zone(0), m_unusedStation(INVALID_STATION)
-	, m_referenceFrame(referenceframe), m_epoch(epoch)
+	, m_referenceFrame(referenceframe), m_epoch(epoch), m_observation_epoch(epoch)
 	, m_constraintType(free_3D)
 {
 	m_epsgCode = epsgStringFromName<std::string>(referenceframe);
@@ -170,6 +170,7 @@ CDnaStation::CDnaStation(const CDnaStation& newStation)
 	m_referenceFrame = newStation.m_referenceFrame;
 	m_epsgCode = newStation.m_epsgCode;
 	m_epoch = newStation.m_epoch;
+	m_observation_epoch = newStation.m_observation_epoch;
 
 	m_constraintType = newStation.m_constraintType;
 }
@@ -215,6 +216,7 @@ CDnaStation::CDnaStation(const std::string& strName, const std::string& strConst
 	m_referenceFrame = DEFAULT_DATUM;
 	m_epsgCode = DEFAULT_EPSG_S;
 	m_epoch = "";
+	m_observation_epoch = "";
 }
 
 CDnaStation& CDnaStation::operator =(const CDnaStation& rhs)
@@ -261,9 +263,10 @@ CDnaStation& CDnaStation::operator =(const CDnaStation& rhs)
 	m_referenceFrame = rhs.m_referenceFrame;
 	m_epsgCode = rhs.m_epsgCode;
 	m_epoch = rhs.m_epoch;
+	m_observation_epoch = rhs.m_observation_epoch;
 
 	m_constraintType = rhs.m_constraintType;
-	
+
 	return *this;
 }
 
@@ -675,6 +678,7 @@ void CDnaStation::WriteBinaryStn(std::ofstream* binary_stream, const UINT16 bUnu
 	stationRecord.unusedStation = bUnused;
 
 	strcpy(stationRecord.epoch, m_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
+	strcpy(stationRecord.observation_epoch, m_observation_epoch.substr(0, STN_EPOCH_WIDTH).c_str());
 	strcpy(stationRecord.epsgCode, m_epsgCode.substr(0, STN_EPSG_WIDTH).c_str());
 
 	binary_stream->write(reinterpret_cast<char *>(&stationRecord), sizeof(station_t));
@@ -948,6 +952,7 @@ void CDnaStation::SetStationRec(const station_t& stationRecord)
 	m_unusedStation = (stationRecord.unusedStation == VALID_STATION ? true : false);
 
 	m_epoch = stationRecord.epoch;
+	m_observation_epoch = stationRecord.observation_epoch;
 	m_epsgCode = stationRecord.epsgCode;
 	m_referenceFrame = datumFromEpsgCode<std::string, UINT32>(LongFromString<UINT32>(m_epsgCode));
 }
diff --git a/dynadjust/include/measurement_types/dnastation.hpp b/dynadjust/include/measurement_types/dnastation.hpp
index aa8d8452c..8051e6a8b 100644
--- a/dynadjust/include/measurement_types/dnastation.hpp
+++ b/dynadjust/include/measurement_types/dnastation.hpp
@@ -276,9 +276,18 @@ class CDnaStation
 
 	inline std::string GetReferenceFrame() const { return m_referenceFrame; }
 	inline std::string GetEpoch() const { return m_epoch; }
-	
+	inline std::string GetObservationEpoch() const { return m_observation_epoch; }
+
 	inline void SetReferenceFrame(const std::string& r) { m_referenceFrame = trimstr(r); }
-	inline void SetEpoch(const std::string& e) { m_epoch = trimstr(e); }
+	// Default observation_epoch to epoch when unset so legacy inputs preserve
+	// prior behaviour; once set, observation_epoch is immutable under reftran.
+	inline void SetEpoch(const std::string& e)
+	{
+		m_epoch = trimstr(e);
+		if (m_observation_epoch.empty())
+			m_observation_epoch = m_epoch;
+	}
+	inline void SetObservationEpoch(const std::string& e) { m_observation_epoch = trimstr(e); }
 	inline void SetEpsg(const std::string& e) { m_epsgCode = trimstr(e); }
 
 	std::string m_strName;
@@ -325,6 +334,7 @@ class CDnaStation
 	std::string	m_referenceFrame;
 	std::string	m_epsgCode;
 	std::string	m_epoch;
+	std::string	m_observation_epoch;
 
 	CONSTRAINT_TYPE m_constraintType;
 };
diff --git a/dynadjust/include/memory/dnafile_mapping.cpp b/dynadjust/include/memory/dnafile_mapping.cpp
index 1a301b315..675e3c600 100644
--- a/dynadjust/include/memory/dnafile_mapping.cpp
+++ b/dynadjust/include/memory/dnafile_mapping.cpp
@@ -22,7 +22,13 @@
 
 #include <include/memory/dnafile_mapping.hpp>
 
-namespace dynadjust { 
+#ifdef __linux__
+#include <cstdint>
+#include <sys/mman.h>
+#include <unistd.h>
+#endif
+
+namespace dynadjust {
 namespace memory {
 
 //block_map_t::block_map_t()
@@ -72,15 +78,33 @@ block_map_t::block_map_t(const block_map_t &p)
 void block_map_t::MapRegion(FileMapPtr file_map_ptr) {
 	region_ptr_.reset(
 		new boost::interprocess::mapped_region(
-			*file_map_ptr, 
-			boost::interprocess::read_write, 
-			region_offset_, 
+			*file_map_ptr,
+			boost::interprocess::read_write,
+			region_offset_,
 			data_size_
 			)
 		);
 }
 
 
+void block_map_t::AdviseSequential() {
+	if (region_ptr_)
+		region_ptr_->advise(boost::interprocess::mapped_region::advice_sequential);
+}
+
+
+void block_map_t::AdviseDontNeed() {
+	if (region_ptr_)
+		region_ptr_->advise(boost::interprocess::mapped_region::advice_dontneed);
+}
+
+
+void block_map_t::AdviseWillNeed() {
+	if (region_ptr_)
+		region_ptr_->advise(boost::interprocess::mapped_region::advice_willneed);
+}
+
+
 // class to hold addresses and sizes for all matrices 
 // in a vector of segmented blocks
 vmat_file_map::vmat_file_map()
@@ -129,10 +153,54 @@ void vmat_file_map::CreateFileMap()
 }
 	
 
-void vmat_file_map::MapRegion(const UINT32 block) 
+void vmat_file_map::MapRegion(const UINT32 block)
 {
 	vblockMapRegions_.at(block).MapRegion(file_map_ptr_);
 }
+
+
+void vmat_file_map::AdviseRegion(const UINT32 block, boost::interprocess::mapped_region::advice_types advice)
+{
+	auto& region = vblockMapRegions_.at(block);
+#ifdef __linux__
+	// Boost's mapped_region::advise calls madvise() without
+	// page-aligning the address.  Stage regions are packed
+	// end-to-end so only the first region's address is page-
+	// aligned by chance; madvise on the rest fails silently
+	// with EINVAL.  Round start up and end down to whole
+	// pages, then call madvise directly.  For DONTNEED also
+	// flush dirty pages asynchronously so the kernel can
+	// evict them promptly.
+	if (region.region_ptr_ && region.data_size_ > 0) {
+		const std::size_t page_size =
+			static_cast<std::size_t>(sysconf(_SC_PAGESIZE));
+		auto base = reinterpret_cast<std::uintptr_t>(
+			region.region_ptr_->get_address());
+		std::uintptr_t aligned_start =
+			(base + page_size - 1) & ~(page_size - 1);
+		std::uintptr_t aligned_end =
+			(base + region.data_size_) & ~(page_size - 1);
+		if (aligned_end > aligned_start) {
+			void* addr = reinterpret_cast<void*>(aligned_start);
+			std::size_t len = aligned_end - aligned_start;
+			int madv = MADV_NORMAL;
+			switch (advice) {
+			case boost::interprocess::mapped_region::advice_sequential:
+				madv = MADV_SEQUENTIAL; break;
+			case boost::interprocess::mapped_region::advice_willneed:
+				madv = MADV_WILLNEED; break;
+			case boost::interprocess::mapped_region::advice_dontneed:
+				msync(addr, len, MS_ASYNC);
+				madv = MADV_DONTNEED; break;
+			default: break;
+			}
+			madvise(addr, len, madv);
+			return;
+		}
+	}
+#endif
+	region.region_ptr_->advise(advice);
+}
 	
 
 }	// namespace memory 
diff --git a/dynadjust/include/memory/dnafile_mapping.hpp b/dynadjust/include/memory/dnafile_mapping.hpp
index ff33a8eb2..abd08859e 100644
--- a/dynadjust/include/memory/dnafile_mapping.hpp
+++ b/dynadjust/include/memory/dnafile_mapping.hpp
@@ -64,12 +64,17 @@ class block_map_t
 	inline size_t GetDataSize() const { return data_size_; }
 	inline size_t GetRegionOffset() const { return region_offset_; }
 	inline size_t GetCumulativeRegionOffset() const { return region_offset_ + data_size_; }
-	
+
 	inline void SetDataSize(const size_t& size) { data_size_ = size; }
 	inline void SetRegionOffset(const size_t& size) { region_offset_ = size; }
-	
+
 	void MapRegion(FileMapPtr file_map_ptr);
 
+	// Memory advisory hints for mapped regions
+	void AdviseSequential();
+	void AdviseDontNeed();
+	void AdviseWillNeed();
+
 	size_t			data_size_;		// Size of this matrix.  
 	size_t			region_offset_;		// Offset from the beginning of the region
 	MapRegPtr		region_ptr_;		// shared pointer to the region
@@ -92,10 +97,11 @@ class vmat_file_map {
 	void setnewFilePath(const std::string& filePath, bool remove_mapped_file);
 	void CreateFileMap();
 	void MapRegion(const UINT32 block);
+	void AdviseRegion(const UINT32 block, boost::interprocess::mapped_region::advice_types advice);
 
 	inline FileMapPtr getFileMapPtr() const { return file_map_ptr_; }
-	inline void* GetBlockRegionAddr(const UINT32 block) const { 
-		return vblockMapRegions_.at(block).region_ptr_->get_address(); 
+	inline void* GetBlockRegionAddr(const UINT32 block) const {
+		return vblockMapRegions_.at(block).region_ptr_->get_address();
 	}
 
 	vmat_file_map(const vmat_file_map&);				// prevent copying
diff --git a/dynadjust/include/parameters/dnaconsts-datums.hpp b/dynadjust/include/parameters/dnaconsts-datums.hpp
index 86fa177b1..48659d030 100644
--- a/dynadjust/include/parameters/dnaconsts-datums.hpp
+++ b/dynadjust/include/parameters/dnaconsts-datums.hpp
@@ -104,9 +104,15 @@ const UINT16 NAD83_CSRS_V6_i_xyz =	8250; // XYZ
 const UINT16 NAD83_CSRS_V7_i =		8254; //LatLonEht
 const UINT16 NAD83_CSRS_V7_i_xyz =	8253; // XYZ
 const UINT16 NAD83_CSRS_V8_i =     10413; // LatLonEht
-const UINT16 NAD83_CSRS_V8_i_xyz = 10412;  // XYZ
-
+const UINT16 NAD83_CSRS_V8_i_xyz = 10412; // XYZ
 
+const UINT16 YACARE_ROUUSAMS_i = 4309;	 // LatLon (2D) only
+const UINT16 SIRGAS_ROU98_i_xyz = 5379;  // XYZ
+const UINT16 SIRGAS_ROU98_i = 5380;		 // LatLonEht
+const UINT16 SIRGAS_1995_i_xyz = 4974;   // XYZ
+const UINT16 SIRGAS_1995_i = 4975;       // LatLonEht
+const UINT16 SIRGAS_2000_i_xyz = 4988;   // XYZ
+const UINT16 SIRGAS_2000_i = 4989;       // LatLonEht
 
 const char* const AGD66_c =			"4202";
 const char* const AGD84_c =			"4203";
@@ -154,7 +160,13 @@ const char* const NAD83_CSRS_v6_c =  "8250";
 const char* const NAD83_CSRS_v7_c =  "8253";
 const char* const NAD83_CSRS_v8_c = "10412";
 
-const char* const AGD66_epoch =		"01.01.1966";
+const char* const YACARE_ROUUSAMS_c = "4309";
+// epsg strings for SIRGAS provide XYZ definition only
+const char* const SIRGAS_ROU98_c = "5379";
+const char* const SIRGAS_1995_c = "4974";
+const char* const SIRGAS_2000_c = "4988";
+
+const char* const AGD66_epoch = "01.01.1966";
 const char* const AGD84_epoch =		"01.01.1984";
 const char* const GDA94_epoch =		"01.01.1994";
 const char* const GDA2020_epoch =	"01.01.2020";
@@ -193,6 +205,11 @@ const char* const NAD83_CSRS_V6_epoch = "01.01.2010";
 const char* const NAD83_CSRS_V7_epoch = "01.01.2010";
 const char* const NAD83_CSRS_V8_epoch = "01.01.2010";
 
+const char* const YACARE_ROUUSAMS_epoch = "01.01.1963";	// Yacare ROU by U.S. Army Map Service was established in 1963.
+const char* const SIRGAS_ROU98_epoch = "03.07.1995";	// 1995.5
+const char* const SIRGAS_1995_epoch = "01.04.1995";		// 1995.4
+const char* const SIRGAS_2000_epoch = "01.04.2000";		// 2000.4
+
 const char* const AGD66_s =			"AGD66";
 const char* const AGD84_s =			"AGD84";
 const char* const GDA94_s =			"GDA94";
@@ -280,5 +297,15 @@ const char* const NAD83_CSRS_V8_alias1_s = "NAD83 (CSRS) v8";
 const char* const NAD83_CSRS_V8_alias2_s = "NAD83(CSRS)V8";
 const char* const NAD83_CSRS_V8_alias3_s = "NAD83 (CSRS) V8";
 
+const char* const YACARE_ROUUSAMS_s = "YACARE ROUUSAMS";  // Yacare ROU by U.S. Army Map Service was established in 1963.
+const char* const YACARE_ROUUSAMS_alias_s = "YACARE-ROUUSAMS";
+const char* const SIRGAS_ROU98_s = "SIRGAS ROU98";
+const char* const SIRGAS_ROU98_alias_s = "SIRGAS-ROU98";
+const char* const SIRGAS_1995_s = "SIRGAS95";
+const char* const SIRGAS_1995_alias1_s = "SIRGAS 95";
+const char* const SIRGAS_1995_alias2_s = "SIRGAS 1995";
+const char* const SIRGAS_2000_s = "SIRGAS2000";
+const char* const SIRGAS_2000_alias_s = "SIRGAS 2000";
+
 
 #endif  // DNACONSTS_DATUMS_HPP
diff --git a/dynadjust/include/parameters/dnadatumprojectionparam.hpp b/dynadjust/include/parameters/dnadatumprojectionparam.hpp
index 7d2006e00..fa9689ba4 100644
--- a/dynadjust/include/parameters/dnadatumprojectionparam.hpp
+++ b/dynadjust/include/parameters/dnadatumprojectionparam.hpp
@@ -35,16 +35,20 @@
 #include <include/config/dnatypes-fwd.hpp>
 
 // GRS80 parameters
-const double GRS80_a = 6378137.0;					// Semi major axis (a)
-const double GRS80_inv_f = 298.257222101;			// Inverse flattening (1/f)
+const double GRS80_a = 6378137.0;				// Semi major axis (a)
+const double GRS80_inv_f = 298.257222101;		// Inverse flattening (1/f)
 
 // WGS84 parameters
-const double WGS84_a = 6378137.0;					// Semi major axis (a)
-const double WGS84_inv_f = 298.25722360;			// Inverse flattening (1/f)
+const double WGS84_a = 6378137.0;				// Semi major axis (a)
+const double WGS84_inv_f = 298.25722360;		// Inverse flattening (1/f)
 
 // ANS parameters
 const double ANS_a = 6378160.0;					// Semi major axis (a)
-const double ANS_inv_f = 298.25;					// Inverse flattening (1/f)
+const double ANS_inv_f = 298.25;				// Inverse flattening (1/f)
+
+// International 1924 parameters
+const double International24_a = 6378388.0;     // Semi major axis (a)
+const double International24_inv_f = 297.0;		// Inverse flattening (1/f)
 
 // UTM parameters
 const double FALSE_E = 500000.0;				// False Easting
diff --git a/dynadjust/include/parameters/dnaepsg.hpp b/dynadjust/include/parameters/dnaepsg.hpp
index 6dd36cd05..dfc9b9da4 100644
--- a/dynadjust/include/parameters/dnaepsg.hpp
+++ b/dynadjust/include/parameters/dnaepsg.hpp
@@ -218,6 +218,19 @@ U epsgCodeFromName(const S& datumName)
         iequals(datumName, NAD83_CSRS_V8_alias2_s) || 
 		iequals(datumName, NAD83_CSRS_V8_alias3_s))
         return NAD83_CSRS_V8_i_xyz;
+    // SIRGAS
+    if (iequals(datumName, YACARE_ROUUSAMS_s)) 
+		return YACARE_ROUUSAMS_i;
+    if (iequals(datumName, SIRGAS_ROU98_s) || 
+		iequals(datumName, SIRGAS_ROU98_alias_s)) 
+		return SIRGAS_ROU98_i_xyz;
+	if (iequals(datumName, SIRGAS_1995_s) ||
+		iequals(datumName, SIRGAS_1995_alias1_s) ||
+		iequals(datumName, SIRGAS_1995_alias2_s)) 
+		return SIRGAS_1995_i_xyz;
+    if (iequals(datumName, SIRGAS_2000_s) ||
+		iequals(datumName, SIRGAS_2000_alias_s)) 
+		return SIRGAS_2000_i_xyz;
 
     std::stringstream ss;
     ss << "  epsgCodeFromName: '" << datumName << "' is not a supported reference frame label." << std::endl;
@@ -341,6 +354,18 @@ S epsgStringFromName(const S& datumName)
     case NAD83_CSRS_V8_i:
     case NAD83_CSRS_V8_i_xyz: 
 		return NAD83_CSRS_v8_c;
+	// SIRGAS
+    case YACARE_ROUUSAMS_i:
+        return YACARE_ROUUSAMS_c;
+    case SIRGAS_ROU98_i:
+    case SIRGAS_ROU98_i_xyz:
+        return SIRGAS_ROU98_c;
+    case SIRGAS_1995_i:
+    case SIRGAS_1995_i_xyz:
+        return SIRGAS_1995_c;
+    case SIRGAS_2000_i:
+    case SIRGAS_2000_i_xyz:
+        return SIRGAS_2000_c;
 	}
 
 	std::stringstream ss;
@@ -388,6 +413,14 @@ bool isEpsgDatumStatic(const U& epsgCode)
 	case NAD83_CSRS_V7_i_xyz:
     case NAD83_CSRS_V8_i:
     case NAD83_CSRS_V8_i_xyz:
+	//SIRGAS
+    case YACARE_ROUUSAMS_i:
+    case SIRGAS_ROU98_i:
+    case SIRGAS_ROU98_i_xyz:
+    case SIRGAS_1995_i:
+    case SIRGAS_1995_i_xyz:
+    case SIRGAS_2000_i:
+    case SIRGAS_2000_i_xyz:
 		return true;
 	// ITRF....
 	case ITRF1988_i_xyz:
@@ -516,6 +549,13 @@ void spheroidFromEpsgCode(const U& epsgCode, epsg_spheroid& ellipsoid)
 	case NAD83_CSRS_V7_i:
     case NAD83_CSRS_V8_i_xyz:
     case NAD83_CSRS_V8_i:
+	// SIRGAS
+	case SIRGAS_ROU98_i:			// Note: epsg.org has incorrectly assigned WGS 84 ellipsoid to SIRGAS ROU98
+	case SIRGAS_ROU98_i_xyz:
+	case SIRGAS_1995_i:
+	case SIRGAS_1995_i_xyz:
+	case SIRGAS_2000_i:
+	case SIRGAS_2000_i_xyz:
 		// authority
 		ellipsoid.authority_.first = "EPSG";
 		ellipsoid.authority_.second = "7019";
@@ -524,6 +564,16 @@ void spheroidFromEpsgCode(const U& epsgCode, epsg_spheroid& ellipsoid)
 		ellipsoid.name_ = "GRS 1980";
 		ellipsoid.semi_major_ = GRS80_a;
 		break;
+    // SIRGAS (OLD)
+	case YACARE_ROUUSAMS_i:
+        // authority
+        ellipsoid.authority_.first = "EPSG";
+        ellipsoid.authority_.second = "7022";
+        // ellipsoid params
+        ellipsoid.inv_flattening_ = International24_inv_f;
+        ellipsoid.name_ = "International 1924";
+        ellipsoid.semi_major_ = International24_a;
+		break;
 	// WGS84
 	case WGS84_transit_i:
 	case WGS84_transit_i_xyz:
@@ -670,6 +720,18 @@ std::string referenceepochFromEpsgCode(const U& epsgCode)
     case NAD83_CSRS_V8_i_xyz:
     case NAD83_CSRS_V8_i: 
 		return NAD83_CSRS_V8_epoch;
+		// SIRGAS
+	case YACARE_ROUUSAMS_i:
+		return YACARE_ROUUSAMS_epoch;
+	case SIRGAS_ROU98_i:
+	case SIRGAS_ROU98_i_xyz:
+		return SIRGAS_ROU98_epoch;
+	case SIRGAS_1995_i:
+	case SIRGAS_1995_i_xyz:
+		return SIRGAS_1995_epoch;
+	case SIRGAS_2000_i:
+	case SIRGAS_2000_i_xyz: 
+		return SIRGAS_2000_epoch;
 	default:
 		std::stringstream ss;
 		ss << "  referenceepochFromEpsgCode: EPSG code '" << epsgCode << "' is not a supported EPSG code." << std::endl;
@@ -799,6 +861,17 @@ S datumFromEpsgCode(const U& epsgCode)
     case NAD83_CSRS_V8_i_xyz:
     case NAD83_CSRS_V8_i: 
 		return NAD83_CSRS_V8_s;
+	case YACARE_ROUUSAMS_i: 
+		return YACARE_ROUUSAMS_s;
+    case SIRGAS_ROU98_i_xyz:
+    case SIRGAS_ROU98_i: 
+		return SIRGAS_ROU98_s;
+    case SIRGAS_1995_i_xyz:
+    case SIRGAS_1995_i:
+		return SIRGAS_1995_s;
+	case SIRGAS_2000_i_xyz:
+    case SIRGAS_2000_i: 
+		return SIRGAS_2000_s;
 	default:
 		std::stringstream ss;
 		ss << "  datumFromEpsgCode: EPSG code '" << epsgCode << "' is not a supported EPSG code." << std::endl;
@@ -908,6 +981,14 @@ bool validateEpsgCode(const U& epsgCode)
 	case NAD83_CSRS_V7_i:
     case NAD83_CSRS_V8_i_xyz:
     case NAD83_CSRS_V8_i:
+	// SIRGAS
+    case YACARE_ROUUSAMS_i:
+    case SIRGAS_ROU98_i_xyz:
+	case SIRGAS_ROU98_i:
+    case SIRGAS_1995_i_xyz:
+	case SIRGAS_1995_i:
+    case SIRGAS_2000_i_xyz:
+    case SIRGAS_2000_i:
 		return true;
 	default:
 		std::stringstream ss;
diff --git a/dynadjust/include/parameters/dnaframesubstitutions.hpp b/dynadjust/include/parameters/dnaframesubstitutions.hpp
index 8a8fb1ade..a2de4275f 100644
--- a/dynadjust/include/parameters/dnaframesubstitutions.hpp
+++ b/dynadjust/include/parameters/dnaframesubstitutions.hpp
@@ -381,6 +381,39 @@ class WGS84_ITRF2014 : public frame_substitutions_t<T1, T2, T3>
 	virtual ~WGS84_ITRF2014() {}
 };
 
+// SIRGAS95 to ITRF94
+template <class T1 = std::string, class T2 = UINT32, class T3 = double>
+class SIRGAS95_ITRF94 : public frame_substitutions_t<T1, T2, T3> {
+   public:
+    SIRGAS95_ITRF94() {
+        frame_substitutions::frame_name = SIRGAS_1995_s;
+        frame_substitutions::frame_epsg = SIRGAS_1995_i_xyz;
+        frame_substitutions::frame_desc = "";
+        frame_substitutions::substitute_name = ITRF1994_s;
+        frame_substitutions::substitute_epsg = ITRF1994_i_xyz;
+
+        frame_substitutions::from_epoch = dateFromString<boost::gregorian::date>("01.01.1900");
+        frame_substitutions::to_epoch = boost::gregorian::day_clock::local_day() + boost::gregorian::years(100);
+    };
+    virtual ~SIRGAS95_ITRF94() {}
+};
+
+// SIRGAS2000 to ITRF2000
+template <class T1 = std::string, class T2 = UINT32, class T3 = double>
+class SIRGAS2000_ITRF2000 : public frame_substitutions_t<T1, T2, T3> {
+   public:
+    SIRGAS2000_ITRF2000() {
+        frame_substitutions::frame_name = SIRGAS_2000_s;
+        frame_substitutions::frame_epsg = SIRGAS_2000_i_xyz;
+        frame_substitutions::frame_desc = "";
+        frame_substitutions::substitute_name = ITRF2000_s;
+        frame_substitutions::substitute_epsg = ITRF2000_i_xyz;
+
+        frame_substitutions::from_epoch = dateFromString<boost::gregorian::date>("01.01.1900");
+        frame_substitutions::to_epoch = boost::gregorian::day_clock::local_day() + boost::gregorian::years(100);
+    };
+    virtual ~SIRGAS2000_ITRF2000() {}
+};
 
 // FUNCTIONS
 
diff --git a/dynadjust/include/thirdparty/nlohmann/json.hpp b/dynadjust/include/thirdparty/nlohmann/json.hpp
new file mode 100644
index 000000000..8b72ea653
--- /dev/null
+++ b/dynadjust/include/thirdparty/nlohmann/json.hpp
@@ -0,0 +1,24765 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+/****************************************************************************\
+ * Note on documentation: The source files contain links to the online      *
+ * documentation of the public API at https://json.nlohmann.me. This URL    *
+ * contains the most recent documentation and should also be applicable to  *
+ * previous versions; documentation for deprecated functions is not         *
+ * removed, but marked deprecated. See "Generate documentation" section in  *
+ * file docs/README.md.                                                     *
+\****************************************************************************/
+
+#ifndef INCLUDE_NLOHMANN_JSON_HPP_
+#define INCLUDE_NLOHMANN_JSON_HPP_
+
+#include <algorithm> // all_of, find, for_each
+#include <cstddef> // nullptr_t, ptrdiff_t, size_t
+#include <functional> // hash, less
+#include <initializer_list> // initializer_list
+#ifndef JSON_NO_IO
+    #include <iosfwd> // istream, ostream
+#endif  // JSON_NO_IO
+#include <iterator> // random_access_iterator_tag
+#include <memory> // unique_ptr
+#include <string> // string, stoi, to_string
+#include <utility> // declval, forward, move, pair, swap
+#include <vector> // vector
+
+// #include <nlohmann/adl_serializer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <utility>
+
+// #include <nlohmann/detail/abi_macros.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// This file contains all macro definitions affecting or depending on the ABI
+
+#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
+    #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
+        #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3
+            #warning "Already included a different version of the library!"
+        #endif
+    #endif
+#endif
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3   // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_MINOR 11  // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_PATCH 3   // NOLINT(modernize-macro-to-enum)
+
+#ifndef JSON_DIAGNOSTICS
+    #define JSON_DIAGNOSTICS 0
+#endif
+
+#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
+#endif
+
+#if JSON_DIAGNOSTICS
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
+#else
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
+#endif
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
+#else
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
+    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
+#endif
+
+// Construct the namespace ABI tags component
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)
+
+#define NLOHMANN_JSON_ABI_TAGS                                       \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
+            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
+
+// Construct the namespace version component
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
+    _v ## major ## _ ## minor ## _ ## patch
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
+
+#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
+#define NLOHMANN_JSON_NAMESPACE_VERSION
+#else
+#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
+                                           NLOHMANN_JSON_VERSION_MINOR, \
+                                           NLOHMANN_JSON_VERSION_PATCH)
+#endif
+
+// Combine namespace components
+#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
+#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
+    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
+
+#ifndef NLOHMANN_JSON_NAMESPACE
+#define NLOHMANN_JSON_NAMESPACE               \
+    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
+            NLOHMANN_JSON_ABI_TAGS,           \
+            NLOHMANN_JSON_NAMESPACE_VERSION)
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
+#define NLOHMANN_JSON_NAMESPACE_BEGIN                \
+    namespace nlohmann                               \
+    {                                                \
+    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
+                NLOHMANN_JSON_ABI_TAGS,              \
+                NLOHMANN_JSON_NAMESPACE_VERSION)     \
+    {
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_END
+#define NLOHMANN_JSON_NAMESPACE_END                                     \
+    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
+    }  // namespace nlohmann
+#endif
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // transform
+#include <array> // array
+#include <forward_list> // forward_list
+#include <iterator> // inserter, front_inserter, end
+#include <map> // map
+#include <string> // string
+#include <tuple> // tuple, make_tuple
+#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
+#include <unordered_map> // unordered_map
+#include <utility> // pair, declval
+#include <valarray> // valarray
+
+// #include <nlohmann/detail/exceptions.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // nullptr_t
+#include <exception> // exception
+#if JSON_DIAGNOSTICS
+    #include <numeric> // accumulate
+#endif
+#include <stdexcept> // runtime_error
+#include <string> // to_string
+#include <vector> // vector
+
+// #include <nlohmann/detail/value_t.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t
+#include <string> // string
+
+// #include <nlohmann/detail/macro_scope.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <utility> // declval, pair
+// #include <nlohmann/detail/meta/detected.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <type_traits>
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename ...Ts> struct make_void
+{
+    using type = void;
+};
+template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// https://en.cppreference.com/w/cpp/experimental/is_detected
+struct nonesuch
+{
+    nonesuch() = delete;
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const&) = delete;
+    nonesuch(nonesuch const&&) = delete;
+    void operator=(nonesuch const&) = delete;
+    void operator=(nonesuch&&) = delete;
+};
+
+template<class Default,
+         class AlwaysVoid,
+         template<class...> class Op,
+         class... Args>
+struct detector
+{
+    using value_t = std::false_type;
+    using type = Default;
+};
+
+template<class Default, template<class...> class Op, class... Args>
+struct detector<Default, void_t<Op<Args...>>, Op, Args...>
+{
+    using value_t = std::true_type;
+    using type = Op<Args...>;
+};
+
+template<template<class...> class Op, class... Args>
+using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
+
+template<template<class...> class Op, class... Args>
+struct is_detected_lazy : is_detected<Op, Args...> { };
+
+template<template<class...> class Op, class... Args>
+using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or = detector<Default, void, Op, Args...>;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+template<class Expected, template<class...> class Op, class... Args>
+using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
+
+template<class To, template<class...> class Op, class... Args>
+using is_detected_convertible =
+    std::is_convertible<detected_t<Op, Args...>, To>;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/thirdparty/hedley/hedley.hpp>
+
+
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson <evan@nemerson.com>
+// SPDX-License-Identifier: MIT
+
+/* Hedley - https://nemequ.github.io/hedley
+ * Created by Evan Nemerson <evan@nemerson.com>
+ */
+
+#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
+#if defined(JSON_HEDLEY_VERSION)
+    #undef JSON_HEDLEY_VERSION
+#endif
+#define JSON_HEDLEY_VERSION 15
+
+#if defined(JSON_HEDLEY_STRINGIFY_EX)
+    #undef JSON_HEDLEY_STRINGIFY_EX
+#endif
+#define JSON_HEDLEY_STRINGIFY_EX(x) #x
+
+#if defined(JSON_HEDLEY_STRINGIFY)
+    #undef JSON_HEDLEY_STRINGIFY
+#endif
+#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
+
+#if defined(JSON_HEDLEY_CONCAT_EX)
+    #undef JSON_HEDLEY_CONCAT_EX
+#endif
+#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
+
+#if defined(JSON_HEDLEY_CONCAT)
+    #undef JSON_HEDLEY_CONCAT
+#endif
+#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
+
+#if defined(JSON_HEDLEY_CONCAT3_EX)
+    #undef JSON_HEDLEY_CONCAT3_EX
+#endif
+#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
+
+#if defined(JSON_HEDLEY_CONCAT3)
+    #undef JSON_HEDLEY_CONCAT3
+#endif
+#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
+
+#if defined(JSON_HEDLEY_VERSION_ENCODE)
+    #undef JSON_HEDLEY_VERSION_ENCODE
+#endif
+#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
+    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
+
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #undef JSON_HEDLEY_GNUC_VERSION
+#endif
+#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#elif defined(__GNUC__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION)
+    #undef JSON_HEDLEY_MSVC_VERSION
+#endif
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
+#elif defined(_MSC_FULL_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
+#elif defined(_MSC_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#endif
+#if !defined(JSON_HEDLEY_MSVC_VERSION)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
+#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
+#else
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #undef JSON_HEDLEY_INTEL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
+#elif defined(__INTEL_COMPILER) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
+    #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #undef JSON_HEDLEY_PGI_VERSION
+#endif
+#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
+    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
+    #undef JSON_HEDLEY_PGI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #undef JSON_HEDLEY_SUNPRO_VERSION
+#endif
+#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
+#elif defined(__SUNPRO_C)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
+#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
+#elif defined(__SUNPRO_CC)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
+    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#endif
+#if defined(__EMSCRIPTEN__)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #undef JSON_HEDLEY_ARM_VERSION
+#endif
+#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
+#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
+    #undef JSON_HEDLEY_ARM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #undef JSON_HEDLEY_IBM_VERSION
+#endif
+#if defined(__ibmxl__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
+#elif defined(__xlC__) && defined(__xlC_ver__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
+#elif defined(__xlC__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
+    #undef JSON_HEDLEY_IBM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #undef JSON_HEDLEY_TI_VERSION
+#endif
+#if \
+    defined(__TI_COMPILER_VERSION__) && \
+    ( \
+      defined(__TMS470__) || defined(__TI_ARM__) || \
+      defined(__MSP430__) || \
+      defined(__TMS320C2000__) \
+    )
+#if (__TI_COMPILER_VERSION__ >= 16000000)
+    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
+    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #undef JSON_HEDLEY_TI_CL430_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
+    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
+    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
+    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
+    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #undef JSON_HEDLEY_CRAY_VERSION
+#endif
+#if defined(_CRAYC)
+    #if defined(_RELEASE_PATCHLEVEL)
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
+    #else
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
+    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #undef JSON_HEDLEY_IAR_VERSION
+#endif
+#if defined(__IAR_SYSTEMS_ICC__)
+    #if __VER__ > 1000
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
+    #else
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
+    #undef JSON_HEDLEY_IAR_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #undef JSON_HEDLEY_TINYC_VERSION
+#endif
+#if defined(__TINYC__)
+    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
+    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #undef JSON_HEDLEY_DMC_VERSION
+#endif
+#if defined(__DMC__)
+    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
+    #undef JSON_HEDLEY_DMC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #undef JSON_HEDLEY_COMPCERT_VERSION
+#endif
+#if defined(__COMPCERT_VERSION__)
+    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
+    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #undef JSON_HEDLEY_PELLES_VERSION
+#endif
+#if defined(__POCC__)
+    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
+    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #undef JSON_HEDLEY_MCST_LCC_VERSION
+#endif
+#if defined(__LCC__) && defined(__LCC_MINOR__)
+    #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
+#endif
+
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #undef JSON_HEDLEY_GCC_VERSION
+#endif
+#if \
+    defined(JSON_HEDLEY_GNUC_VERSION) && \
+    !defined(__clang__) && \
+    !defined(JSON_HEDLEY_INTEL_VERSION) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_ARM_VERSION) && \
+    !defined(JSON_HEDLEY_CRAY_VERSION) && \
+    !defined(JSON_HEDLEY_TI_VERSION) && \
+    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
+    !defined(__COMPCERT__) && \
+    !defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_ATTRIBUTE
+#endif
+#if \
+  defined(__has_attribute) && \
+  ( \
+    (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
+  )
+#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
+#else
+#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#endif
+#if \
+    defined(__has_cpp_attribute) && \
+    defined(__cplusplus) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#endif
+#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#elif \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_IAR_VERSION) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
+    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_BUILTIN)
+    #undef JSON_HEDLEY_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_FEATURE)
+    #undef JSON_HEDLEY_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GCC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_EXTENSION)
+    #undef JSON_HEDLEY_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_WARNING)
+    #undef JSON_HEDLEY_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
+    #undef JSON_HEDLEY_GNUC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
+    #undef JSON_HEDLEY_GCC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
+    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
+#else
+    #define JSON_HEDLEY_PRAGMA(value)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
+    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#endif
+#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
+    #undef JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
+    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
+#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
+    #define JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+
+/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
+#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
+#      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      else
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      endif
+#    else
+#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    endif
+#  endif
+#endif
+#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
+#endif
+
+#if defined(JSON_HEDLEY_CONST_CAST)
+    #undef JSON_HEDLEY_CONST_CAST
+#endif
+#if defined(__cplusplus)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
+#elif \
+  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_REINTERPRET_CAST)
+    #undef JSON_HEDLEY_REINTERPRET_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_CAST)
+    #undef JSON_HEDLEY_STATIC_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_CPP_CAST)
+    #undef JSON_HEDLEY_CPP_CAST
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
+    ((T) (expr)) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("diag_suppress=Pe137") \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
+#  endif
+#else
+#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#endif
+
+#if defined(JSON_HEDLEY_DEPRECATED)
+    #undef JSON_HEDLEY_DEPRECATED
+#endif
+#if defined(JSON_HEDLEY_DEPRECATED_FOR)
+    #undef JSON_HEDLEY_DEPRECATED_FOR
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
+#elif \
+    (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
+#elif defined(__cplusplus) && (__cplusplus >= 201402L)
+    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
+#else
+    #define JSON_HEDLEY_DEPRECATED(since)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
+#endif
+
+#if defined(JSON_HEDLEY_UNAVAILABLE)
+    #undef JSON_HEDLEY_UNAVAILABLE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
+#else
+    #define JSON_HEDLEY_UNAVAILABLE(available_since)
+#endif
+
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#endif
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
+#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+#elif defined(_Check_return_) /* SAL */
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
+#else
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
+#endif
+
+#if defined(JSON_HEDLEY_SENTINEL)
+    #undef JSON_HEDLEY_SENTINEL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
+#else
+    #define JSON_HEDLEY_SENTINEL(position)
+#endif
+
+#if defined(JSON_HEDLEY_NO_RETURN)
+    #undef JSON_HEDLEY_NO_RETURN
+#endif
+#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NO_RETURN __noreturn
+#elif \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+    #define JSON_HEDLEY_NO_RETURN _Noreturn
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#else
+    #define JSON_HEDLEY_NO_RETURN
+#endif
+
+#if defined(JSON_HEDLEY_NO_ESCAPE)
+    #undef JSON_HEDLEY_NO_ESCAPE
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
+    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
+#else
+    #define JSON_HEDLEY_NO_ESCAPE
+#endif
+
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #undef JSON_HEDLEY_UNREACHABLE
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
+    #undef JSON_HEDLEY_UNREACHABLE_RETURN
+#endif
+#if defined(JSON_HEDLEY_ASSUME)
+    #undef JSON_HEDLEY_ASSUME
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
+#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
+    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
+#elif \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+    #if defined(__cplusplus)
+        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
+    #endif
+#endif
+#if \
+    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
+#elif defined(JSON_HEDLEY_ASSUME)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+#if !defined(JSON_HEDLEY_ASSUME)
+    #if defined(JSON_HEDLEY_UNREACHABLE)
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
+    #endif
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #if  \
+        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
+    #else
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
+    #endif
+#else
+    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
+#endif
+#if !defined(JSON_HEDLEY_UNREACHABLE)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+
+JSON_HEDLEY_DIAGNOSTIC_PUSH
+#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
+    #pragma clang diagnostic ignored "-Wpedantic"
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
+    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#endif
+#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
+    #if defined(__clang__)
+        #pragma clang diagnostic ignored "-Wvariadic-macros"
+    #elif defined(JSON_HEDLEY_GCC_VERSION)
+        #pragma GCC diagnostic ignored "-Wvariadic-macros"
+    #endif
+#endif
+#if defined(JSON_HEDLEY_NON_NULL)
+    #undef JSON_HEDLEY_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
+#else
+    #define JSON_HEDLEY_NON_NULL(...)
+#endif
+JSON_HEDLEY_DIAGNOSTIC_POP
+
+#if defined(JSON_HEDLEY_PRINTF_FORMAT)
+    #undef JSON_HEDLEY_PRINTF_FORMAT
+#endif
+#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
+#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
+#else
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
+#endif
+
+#if defined(JSON_HEDLEY_CONSTEXPR)
+    #undef JSON_HEDLEY_CONSTEXPR
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
+    #endif
+#endif
+#if !defined(JSON_HEDLEY_CONSTEXPR)
+    #define JSON_HEDLEY_CONSTEXPR
+#endif
+
+#if defined(JSON_HEDLEY_PREDICT)
+    #undef JSON_HEDLEY_PREDICT
+#endif
+#if defined(JSON_HEDLEY_LIKELY)
+    #undef JSON_HEDLEY_LIKELY
+#endif
+#if defined(JSON_HEDLEY_UNLIKELY)
+    #undef JSON_HEDLEY_UNLIKELY
+#endif
+#if defined(JSON_HEDLEY_UNPREDICTABLE)
+    #undef JSON_HEDLEY_UNPREDICTABLE
+#endif
+#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
+#endif
+#if \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
+#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
+#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
+#elif \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
+  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
+    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
+#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
+#else
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
+#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
+#endif
+#if !defined(JSON_HEDLEY_UNPREDICTABLE)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
+#endif
+
+#if defined(JSON_HEDLEY_MALLOC)
+    #undef JSON_HEDLEY_MALLOC
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_MALLOC __declspec(restrict)
+#else
+    #define JSON_HEDLEY_MALLOC
+#endif
+
+#if defined(JSON_HEDLEY_PURE)
+    #undef JSON_HEDLEY_PURE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PURE __attribute__((__pure__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
+    )
+#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
+#else
+#  define JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_CONST)
+    #undef JSON_HEDLEY_CONST
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_CONST __attribute__((__const__))
+#elif \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
+#else
+    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_RESTRICT)
+    #undef JSON_HEDLEY_RESTRICT
+#endif
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT restrict
+#elif \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_RESTRICT __restrict
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT _Restrict
+#else
+    #define JSON_HEDLEY_RESTRICT
+#endif
+
+#if defined(JSON_HEDLEY_INLINE)
+    #undef JSON_HEDLEY_INLINE
+#endif
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    (defined(__cplusplus) && (__cplusplus >= 199711L))
+    #define JSON_HEDLEY_INLINE inline
+#elif \
+    defined(JSON_HEDLEY_GCC_VERSION) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
+    #define JSON_HEDLEY_INLINE __inline__
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_INLINE __inline
+#else
+    #define JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_ALWAYS_INLINE)
+    #undef JSON_HEDLEY_ALWAYS_INLINE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
+    )
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
+#else
+#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_NEVER_INLINE)
+    #undef JSON_HEDLEY_NEVER_INLINE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#else
+    #define JSON_HEDLEY_NEVER_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_PRIVATE)
+    #undef JSON_HEDLEY_PRIVATE
+#endif
+#if defined(JSON_HEDLEY_PUBLIC)
+    #undef JSON_HEDLEY_PUBLIC
+#endif
+#if defined(JSON_HEDLEY_IMPORT)
+    #undef JSON_HEDLEY_IMPORT
+#endif
+#if defined(_WIN32) || defined(__CYGWIN__)
+#  define JSON_HEDLEY_PRIVATE
+#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
+#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
+#else
+#  if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    ( \
+      defined(__TI_EABI__) && \
+      ( \
+        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
+      ) \
+    ) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
+#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
+#  else
+#    define JSON_HEDLEY_PRIVATE
+#    define JSON_HEDLEY_PUBLIC
+#  endif
+#  define JSON_HEDLEY_IMPORT    extern
+#endif
+
+#if defined(JSON_HEDLEY_NO_THROW)
+    #undef JSON_HEDLEY_NO_THROW
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
+#else
+    #define JSON_HEDLEY_NO_THROW
+#endif
+
+#if defined(JSON_HEDLEY_FALL_THROUGH)
+    #undef JSON_HEDLEY_FALL_THROUGH
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
+#elif defined(__fallthrough) /* SAL */
+    #define JSON_HEDLEY_FALL_THROUGH __fallthrough
+#else
+    #define JSON_HEDLEY_FALL_THROUGH
+#endif
+
+#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
+    #undef JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
+#elif defined(_Ret_notnull_) /* SAL */
+    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
+#else
+    #define JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+
+#if defined(JSON_HEDLEY_ARRAY_PARAM)
+    #undef JSON_HEDLEY_ARRAY_PARAM
+#endif
+#if \
+    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
+    !defined(__STDC_NO_VLA__) && \
+    !defined(__cplusplus) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
+#else
+    #define JSON_HEDLEY_ARRAY_PARAM(name)
+#endif
+
+#if defined(JSON_HEDLEY_IS_CONSTANT)
+    #undef JSON_HEDLEY_IS_CONSTANT
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
+    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#endif
+/* JSON_HEDLEY_IS_CONSTEXPR_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #undef JSON_HEDLEY_IS_CONSTEXPR_
+#endif
+#if \
+    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
+#endif
+#if !defined(__cplusplus)
+#  if \
+       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
+#endif
+#  elif \
+       ( \
+          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
+          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
+          !defined(JSON_HEDLEY_PGI_VERSION) && \
+          !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
+#endif
+#  elif \
+       defined(JSON_HEDLEY_GCC_VERSION) || \
+       defined(JSON_HEDLEY_INTEL_VERSION) || \
+       defined(JSON_HEDLEY_TINYC_VERSION) || \
+       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
+       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
+       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
+       defined(__clang__)
+#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
+        sizeof(void) != \
+        sizeof(*( \
+                  1 ? \
+                  ((void*) ((expr) * 0L) ) : \
+((struct { char v[sizeof(void) * 2]; } *) 1) \
+                ) \
+              ) \
+                                            )
+#  endif
+#endif
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
+#else
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
+    #undef JSON_HEDLEY_BEGIN_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_END_C_DECLS)
+    #undef JSON_HEDLEY_END_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_C_DECL)
+    #undef JSON_HEDLEY_C_DECL
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
+    #define JSON_HEDLEY_END_C_DECLS }
+    #define JSON_HEDLEY_C_DECL extern "C"
+#else
+    #define JSON_HEDLEY_BEGIN_C_DECLS
+    #define JSON_HEDLEY_END_C_DECLS
+    #define JSON_HEDLEY_C_DECL
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_ASSERT)
+    #undef JSON_HEDLEY_STATIC_ASSERT
+#endif
+#if \
+  !defined(__cplusplus) && ( \
+      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
+      (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
+      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+      defined(_Static_assert) \
+    )
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
+#elif \
+  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
+#else
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
+#endif
+
+#if defined(JSON_HEDLEY_NULL)
+    #undef JSON_HEDLEY_NULL
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
+    #elif defined(NULL)
+        #define JSON_HEDLEY_NULL NULL
+    #else
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
+    #endif
+#elif defined(NULL)
+    #define JSON_HEDLEY_NULL NULL
+#else
+    #define JSON_HEDLEY_NULL ((void*) 0)
+#endif
+
+#if defined(JSON_HEDLEY_MESSAGE)
+    #undef JSON_HEDLEY_MESSAGE
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_MESSAGE(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(message msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
+#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_WARNING)
+    #undef JSON_HEDLEY_WARNING
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_WARNING(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(clang warning msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_REQUIRE)
+    #undef JSON_HEDLEY_REQUIRE
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_MSG)
+    #undef JSON_HEDLEY_REQUIRE_MSG
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
+#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
+#    define JSON_HEDLEY_REQUIRE(expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), msg, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
+#  endif
+#else
+#  define JSON_HEDLEY_REQUIRE(expr)
+#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS)
+    #undef JSON_HEDLEY_FLAGS
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
+    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
+#else
+    #define JSON_HEDLEY_FLAGS
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS_CAST)
+    #undef JSON_HEDLEY_FLAGS_CAST
+#endif
+#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        _Pragma("warning(disable:188)") \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
+#endif
+
+#if defined(JSON_HEDLEY_EMPTY_BASES)
+    #undef JSON_HEDLEY_EMPTY_BASES
+#endif
+#if \
+    (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
+#else
+    #define JSON_HEDLEY_EMPTY_BASES
+#endif
+
+/* Remaining macros are deprecated. */
+
+#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
+#else
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
+    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#endif
+#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
+    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
+    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#endif
+#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
+    #undef JSON_HEDLEY_CLANG_HAS_WARNING
+#endif
+#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
+
+#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
+
+
+// This file contains all internal macro definitions (except those affecting ABI)
+// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+// exclude unsupported compilers
+#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
+    #if defined(__clang__)
+        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
+            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
+        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
+            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #endif
+#endif
+
+// C++ language standard detection
+// if the user manually specified the used c++ version this is skipped
+#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
+    #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
+        #define JSON_HAS_CPP_20
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+        #define JSON_HAS_CPP_14
+    #endif
+    // the cpp 11 flag is always specified because it is the minimal required version
+    #define JSON_HAS_CPP_11
+#endif
+
+#ifdef __has_include
+    #if __has_include(<version>)
+        #include <version>
+    #endif
+#endif
+
+#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
+    #ifdef JSON_HAS_CPP_17
+        #if defined(__cpp_lib_filesystem)
+            #define JSON_HAS_FILESYSTEM 1
+        #elif defined(__cpp_lib_experimental_filesystem)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #elif !defined(__has_include)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #elif __has_include(<filesystem>)
+            #define JSON_HAS_FILESYSTEM 1
+        #elif __has_include(<experimental/filesystem>)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #endif
+
+        // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
+        #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(__clang_major__) && __clang_major__ < 7
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(_MSC_VER) && _MSC_VER < 1914
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before iOS 13
+        #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before macOS Catalina
+        #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+    #endif
+#endif
+
+#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+    #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
+#endif
+
+#ifndef JSON_HAS_FILESYSTEM
+    #define JSON_HAS_FILESYSTEM 0
+#endif
+
+#ifndef JSON_HAS_THREE_WAY_COMPARISON
+    #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \
+        && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L
+        #define JSON_HAS_THREE_WAY_COMPARISON 1
+    #else
+        #define JSON_HAS_THREE_WAY_COMPARISON 0
+    #endif
+#endif
+
+#ifndef JSON_HAS_RANGES
+    // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error
+    #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427
+        #define JSON_HAS_RANGES 0
+    #elif defined(__cpp_lib_ranges)
+        #define JSON_HAS_RANGES 1
+    #else
+        #define JSON_HAS_RANGES 0
+    #endif
+#endif
+
+#ifndef JSON_HAS_STATIC_RTTI
+    #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0
+        #define JSON_HAS_STATIC_RTTI 1
+    #else
+        #define JSON_HAS_STATIC_RTTI 0
+    #endif
+#endif
+
+#ifdef JSON_HAS_CPP_17
+    #define JSON_INLINE_VARIABLE inline
+#else
+    #define JSON_INLINE_VARIABLE
+#endif
+
+#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address)
+    #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#else
+    #define JSON_NO_UNIQUE_ADDRESS
+#endif
+
+// disable documentation warnings on clang
+#if defined(__clang__)
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wdocumentation"
+    #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
+#endif
+
+// allow disabling exceptions
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
+    #define JSON_THROW(exception) throw exception
+    #define JSON_TRY try
+    #define JSON_CATCH(exception) catch(exception)
+    #define JSON_INTERNAL_CATCH(exception) catch(exception)
+#else
+    #include <cstdlib>
+    #define JSON_THROW(exception) std::abort()
+    #define JSON_TRY if(true)
+    #define JSON_CATCH(exception) if(false)
+    #define JSON_INTERNAL_CATCH(exception) if(false)
+#endif
+
+// override exception macros
+#if defined(JSON_THROW_USER)
+    #undef JSON_THROW
+    #define JSON_THROW JSON_THROW_USER
+#endif
+#if defined(JSON_TRY_USER)
+    #undef JSON_TRY
+    #define JSON_TRY JSON_TRY_USER
+#endif
+#if defined(JSON_CATCH_USER)
+    #undef JSON_CATCH
+    #define JSON_CATCH JSON_CATCH_USER
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
+#endif
+#if defined(JSON_INTERNAL_CATCH_USER)
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
+#endif
+
+// allow overriding assert
+#if !defined(JSON_ASSERT)
+    #include <cassert> // assert
+    #define JSON_ASSERT(x) assert(x)
+#endif
+
+// allow to access some private functions (needed by the test suite)
+#if defined(JSON_TESTS_PRIVATE)
+    #define JSON_PRIVATE_UNLESS_TESTED public
+#else
+    #define JSON_PRIVATE_UNLESS_TESTED private
+#endif
+
+/*!
+@brief macro to briefly define a mapping between an enum and JSON
+@def NLOHMANN_JSON_SERIALIZE_ENUM
+@since version 3.4.0
+*/
+#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
+    template<typename BasicJsonType>                                                            \
+    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
+        {                                                                                       \
+            return ej_pair.first == e;                                                          \
+        });                                                                                     \
+        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
+    }                                                                                           \
+    template<typename BasicJsonType>                                                            \
+    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+        {                                                                                       \
+            return ej_pair.second == j;                                                         \
+        });                                                                                     \
+        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
+    }
+
+// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
+// may be removed in the future once the class is split.
+
+#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
+    template<template<typename, typename, typename...> class ObjectType,   \
+             template<typename, typename...> class ArrayType,              \
+             class StringType, class BooleanType, class NumberIntegerType, \
+             class NumberUnsignedType, class NumberFloatType,              \
+             template<typename> class AllocatorType,                       \
+             template<typename, typename = void> class JSONSerializer,     \
+             class BinaryType,                                             \
+             class CustomBaseClass>
+
+#define NLOHMANN_BASIC_JSON_TPL                                            \
+    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
+    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
+    AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>
+
+// Macros to simplify conversion from/to types
+
+#define NLOHMANN_JSON_EXPAND( x ) x
+#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
+#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
+        NLOHMANN_JSON_PASTE64, \
+        NLOHMANN_JSON_PASTE63, \
+        NLOHMANN_JSON_PASTE62, \
+        NLOHMANN_JSON_PASTE61, \
+        NLOHMANN_JSON_PASTE60, \
+        NLOHMANN_JSON_PASTE59, \
+        NLOHMANN_JSON_PASTE58, \
+        NLOHMANN_JSON_PASTE57, \
+        NLOHMANN_JSON_PASTE56, \
+        NLOHMANN_JSON_PASTE55, \
+        NLOHMANN_JSON_PASTE54, \
+        NLOHMANN_JSON_PASTE53, \
+        NLOHMANN_JSON_PASTE52, \
+        NLOHMANN_JSON_PASTE51, \
+        NLOHMANN_JSON_PASTE50, \
+        NLOHMANN_JSON_PASTE49, \
+        NLOHMANN_JSON_PASTE48, \
+        NLOHMANN_JSON_PASTE47, \
+        NLOHMANN_JSON_PASTE46, \
+        NLOHMANN_JSON_PASTE45, \
+        NLOHMANN_JSON_PASTE44, \
+        NLOHMANN_JSON_PASTE43, \
+        NLOHMANN_JSON_PASTE42, \
+        NLOHMANN_JSON_PASTE41, \
+        NLOHMANN_JSON_PASTE40, \
+        NLOHMANN_JSON_PASTE39, \
+        NLOHMANN_JSON_PASTE38, \
+        NLOHMANN_JSON_PASTE37, \
+        NLOHMANN_JSON_PASTE36, \
+        NLOHMANN_JSON_PASTE35, \
+        NLOHMANN_JSON_PASTE34, \
+        NLOHMANN_JSON_PASTE33, \
+        NLOHMANN_JSON_PASTE32, \
+        NLOHMANN_JSON_PASTE31, \
+        NLOHMANN_JSON_PASTE30, \
+        NLOHMANN_JSON_PASTE29, \
+        NLOHMANN_JSON_PASTE28, \
+        NLOHMANN_JSON_PASTE27, \
+        NLOHMANN_JSON_PASTE26, \
+        NLOHMANN_JSON_PASTE25, \
+        NLOHMANN_JSON_PASTE24, \
+        NLOHMANN_JSON_PASTE23, \
+        NLOHMANN_JSON_PASTE22, \
+        NLOHMANN_JSON_PASTE21, \
+        NLOHMANN_JSON_PASTE20, \
+        NLOHMANN_JSON_PASTE19, \
+        NLOHMANN_JSON_PASTE18, \
+        NLOHMANN_JSON_PASTE17, \
+        NLOHMANN_JSON_PASTE16, \
+        NLOHMANN_JSON_PASTE15, \
+        NLOHMANN_JSON_PASTE14, \
+        NLOHMANN_JSON_PASTE13, \
+        NLOHMANN_JSON_PASTE12, \
+        NLOHMANN_JSON_PASTE11, \
+        NLOHMANN_JSON_PASTE10, \
+        NLOHMANN_JSON_PASTE9, \
+        NLOHMANN_JSON_PASTE8, \
+        NLOHMANN_JSON_PASTE7, \
+        NLOHMANN_JSON_PASTE6, \
+        NLOHMANN_JSON_PASTE5, \
+        NLOHMANN_JSON_PASTE4, \
+        NLOHMANN_JSON_PASTE3, \
+        NLOHMANN_JSON_PASTE2, \
+        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
+#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
+#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
+#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
+#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
+#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
+#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
+#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
+#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
+#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
+#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
+#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
+#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
+#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
+#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
+#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
+#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
+#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
+#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
+#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
+#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
+#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
+#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
+#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
+#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
+#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
+#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
+#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
+#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
+#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
+#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
+#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
+#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
+#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
+#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
+#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
+#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
+#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
+#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
+#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
+#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
+#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
+#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
+#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
+#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
+#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
+#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
+#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
+#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
+#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
+#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
+#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
+#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
+#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
+#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
+#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
+#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
+#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
+#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
+#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
+#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
+#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
+
+#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
+#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
+#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1);
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
+@since version 3.9.0
+*/
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
+@since version 3.9.0
+*/
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+// inspired from https://stackoverflow.com/a/26745591
+// allows to call any std function as if (e.g. with begin):
+// using std::begin; begin(x);
+//
+// it allows using the detected idiom to retrieve the return type
+// of such an expression
+#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)                                 \
+    namespace detail {                                                            \
+    using std::std_name;                                                          \
+    \
+    template<typename... T>                                                       \
+    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
+    }                                                                             \
+    \
+    namespace detail2 {                                                           \
+    struct std_name##_tag                                                         \
+    {                                                                             \
+    };                                                                            \
+    \
+    template<typename... T>                                                       \
+    std_name##_tag std_name(T&&...);                                              \
+    \
+    template<typename... T>                                                       \
+    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
+    \
+    template<typename... T>                                                       \
+    struct would_call_std_##std_name                                              \
+    {                                                                             \
+        static constexpr auto const value = ::nlohmann::detail::                  \
+                                            is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
+    };                                                                            \
+    } /* namespace detail2 */ \
+    \
+    template<typename... T>                                                       \
+    struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...>   \
+    {                                                                             \
+    }
+
+#ifndef JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_USE_IMPLICIT_CONVERSIONS 1
+#endif
+
+#if JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_EXPLICIT
+#else
+    #define JSON_EXPLICIT explicit
+#endif
+
+#ifndef JSON_DISABLE_ENUM_SERIALIZATION
+    #define JSON_DISABLE_ENUM_SERIALIZATION 0
+#endif
+
+#ifndef JSON_USE_GLOBAL_UDLS
+    #define JSON_USE_GLOBAL_UDLS 1
+#endif
+
+#if JSON_HAS_THREE_WAY_COMPARISON
+    #include <compare> // partial_ordering
+#endif
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////////////////////
+// JSON type enumeration //
+///////////////////////////
+
+/*!
+@brief the JSON type enumeration
+
+This enumeration collects the different JSON types. It is internally used to
+distinguish the stored values, and the functions @ref basic_json::is_null(),
+@ref basic_json::is_object(), @ref basic_json::is_array(),
+@ref basic_json::is_string(), @ref basic_json::is_boolean(),
+@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
+@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
+@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
+@ref basic_json::is_structured() rely on it.
+
+@note There are three enumeration entries (number_integer, number_unsigned, and
+number_float), because the library distinguishes these three types for numbers:
+@ref basic_json::number_unsigned_t is used for unsigned integers,
+@ref basic_json::number_integer_t is used for signed integers, and
+@ref basic_json::number_float_t is used for floating-point numbers or to
+approximate integers which do not fit in the limits of their respective type.
+
+@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
+value with the default value for a given type
+
+@since version 1.0.0
+*/
+enum class value_t : std::uint8_t
+{
+    null,             ///< null value
+    object,           ///< object (unordered set of name/value pairs)
+    array,            ///< array (ordered collection of values)
+    string,           ///< string value
+    boolean,          ///< boolean value
+    number_integer,   ///< number value (signed integer)
+    number_unsigned,  ///< number value (unsigned integer)
+    number_float,     ///< number value (floating-point)
+    binary,           ///< binary array (ordered collection of bytes)
+    discarded         ///< discarded by the parser callback function
+};
+
+/*!
+@brief comparison operator for JSON types
+
+Returns an ordering that is similar to Python:
+- order: null < boolean < number < object < array < string < binary
+- furthermore, each type is not smaller than itself
+- discarded values are not comparable
+- binary is represented as a b"" string in python and directly comparable to a
+  string; however, making a binary array directly comparable with a string would
+  be surprising behavior in a JSON file.
+
+@since version 1.0.0
+*/
+#if JSON_HAS_THREE_WAY_COMPARISON
+    inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*
+#else
+    inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+#endif
+{
+    static constexpr std::array<std::uint8_t, 9> order = {{
+            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
+            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
+            6 /* binary */
+        }
+    };
+
+    const auto l_index = static_cast<std::size_t>(lhs);
+    const auto r_index = static_cast<std::size_t>(rhs);
+#if JSON_HAS_THREE_WAY_COMPARISON
+    if (l_index < order.size() && r_index < order.size())
+    {
+        return order[l_index] <=> order[r_index]; // *NOPAD*
+    }
+    return std::partial_ordering::unordered;
+#else
+    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
+#endif
+}
+
+// GCC selects the built-in operator< over an operator rewritten from
+// a user-defined spaceship operator
+// Clang, MSVC, and ICC select the rewritten candidate
+// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200)
+#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__)
+inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+{
+    return std::is_lt(lhs <=> rhs); // *NOPAD*
+}
+#endif
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/string_escape.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief replace all occurrences of a substring by another string
+
+@param[in,out] s  the string to manipulate; changed so that all
+               occurrences of @a f are replaced with @a t
+@param[in]     f  the substring to replace with @a t
+@param[in]     t  the string to replace @a f
+
+@pre The search string @a f must not be empty. **This precondition is
+enforced with an assertion.**
+
+@since version 2.0.0
+*/
+template<typename StringType>
+inline void replace_substring(StringType& s, const StringType& f,
+                              const StringType& t)
+{
+    JSON_ASSERT(!f.empty());
+    for (auto pos = s.find(f);                // find first occurrence of f
+            pos != StringType::npos;          // make sure f was found
+            s.replace(pos, f.size(), t),      // replace with t, and
+            pos = s.find(f, pos + t.size()))  // find next occurrence of f
+    {}
+}
+
+/*!
+ * @brief string escaping as described in RFC 6901 (Sect. 4)
+ * @param[in] s string to escape
+ * @return    escaped string
+ *
+ * Note the order of escaping "~" to "~0" and "/" to "~1" is important.
+ */
+template<typename StringType>
+inline StringType escape(StringType s)
+{
+    replace_substring(s, StringType{"~"}, StringType{"~0"});
+    replace_substring(s, StringType{"/"}, StringType{"~1"});
+    return s;
+}
+
+/*!
+ * @brief string unescaping as described in RFC 6901 (Sect. 4)
+ * @param[in] s string to unescape
+ * @return    unescaped string
+ *
+ * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
+ */
+template<typename StringType>
+static void unescape(StringType& s)
+{
+    replace_substring(s, StringType{"~1"}, StringType{"/"});
+    replace_substring(s, StringType{"~0"}, StringType{"~"});
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/position_t.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // size_t
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// struct to capture the start position of the current token
+struct position_t
+{
+    /// the total number of characters read
+    std::size_t chars_read_total = 0;
+    /// the number of characters read in the current line
+    std::size_t chars_read_current_line = 0;
+    /// the number of lines read
+    std::size_t lines_read = 0;
+
+    /// conversion to size_t to preserve SAX interface
+    constexpr operator size_t() const
+    {
+        return chars_read_total;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-FileCopyrightText: 2018 The Abseil Authors
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
+#include <utility> // index_sequence, make_index_sequence, index_sequence_for
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename T>
+using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+#ifdef JSON_HAS_CPP_14
+
+// the following utilities are natively available in C++14
+using std::enable_if_t;
+using std::index_sequence;
+using std::make_index_sequence;
+using std::index_sequence_for;
+
+#else
+
+// alias templates to reduce boilerplate
+template<bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
+// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.
+
+//// START OF CODE FROM GOOGLE ABSEIL
+
+// integer_sequence
+//
+// Class template representing a compile-time integer sequence. An instantiation
+// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
+// type through its template arguments (which is a common need when
+// working with C++11 variadic templates). `absl::integer_sequence` is designed
+// to be a drop-in replacement for C++14's `std::integer_sequence`.
+//
+// Example:
+//
+//   template< class T, T... Ints >
+//   void user_function(integer_sequence<T, Ints...>);
+//
+//   int main()
+//   {
+//     // user_function's `T` will be deduced to `int` and `Ints...`
+//     // will be deduced to `0, 1, 2, 3, 4`.
+//     user_function(make_integer_sequence<int, 5>());
+//   }
+template <typename T, T... Ints>
+struct integer_sequence
+{
+    using value_type = T;
+    static constexpr std::size_t size() noexcept
+    {
+        return sizeof...(Ints);
+    }
+};
+
+// index_sequence
+//
+// A helper template for an `integer_sequence` of `size_t`,
+// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
+// `std::index_sequence`.
+template <size_t... Ints>
+using index_sequence = integer_sequence<size_t, Ints...>;
+
+namespace utility_internal
+{
+
+template <typename Seq, size_t SeqSize, size_t Rem>
+struct Extend;
+
+// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
+{
+    using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
+};
+
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
+{
+    using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
+};
+
+// Recursion helper for 'make_integer_sequence<T, N>'.
+// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
+template <typename T, size_t N>
+struct Gen
+{
+    using type =
+        typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
+};
+
+template <typename T>
+struct Gen<T, 0>
+{
+    using type = integer_sequence<T>;
+};
+
+}  // namespace utility_internal
+
+// Compile-time sequences of integers
+
+// make_integer_sequence
+//
+// This template alias is equivalent to
+// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
+// replacement for C++14's `std::make_integer_sequence`.
+template <typename T, T N>
+using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
+
+// make_index_sequence
+//
+// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
+// and is designed to be a drop-in replacement for C++14's
+// `std::make_index_sequence`.
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
+
+// index_sequence_for
+//
+// Converts a typename pack into an index sequence of the same length, and
+// is designed to be a drop-in replacement for C++14's
+// `std::index_sequence_for()`
+template <typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+//// END OF CODE FROM GOOGLE ABSEIL
+
+#endif
+
+// dispatch utility (taken from ranges-v3)
+template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
+template<> struct priority_tag<0> {};
+
+// taken from ranges-v3
+template<typename T>
+struct static_const
+{
+    static JSON_INLINE_VARIABLE constexpr T value{};
+};
+
+#ifndef JSON_HAS_CPP_17
+    template<typename T>
+    constexpr T static_const<T>::value;
+#endif
+
+template<typename T, typename... Args>
+inline constexpr std::array<T, sizeof...(Args)> make_array(Args&& ... args)
+{
+    return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}};
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <limits> // numeric_limits
+#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
+#include <utility> // declval
+#include <tuple> // tuple
+#include <string> // char_traits
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <iterator> // random_access_iterator_tag
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename It, typename = void>
+struct iterator_types {};
+
+template<typename It>
+struct iterator_types <
+    It,
+    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
+    typename It::reference, typename It::iterator_category >>
+{
+    using difference_type = typename It::difference_type;
+    using value_type = typename It::value_type;
+    using pointer = typename It::pointer;
+    using reference = typename It::reference;
+    using iterator_category = typename It::iterator_category;
+};
+
+// This is required as some compilers implement std::iterator_traits in a way that
+// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
+template<typename T, typename = void>
+struct iterator_traits
+{
+};
+
+template<typename T>
+struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
+            : iterator_types<T>
+{
+};
+
+template<typename T>
+struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
+{
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = T;
+    using difference_type = ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/call_std/begin.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/call_std/end.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/json_fwd.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
+    #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+    #include <cstdint> // int64_t, uint64_t
+    #include <map> // map
+    #include <memory> // allocator
+    #include <string> // string
+    #include <vector> // vector
+
+    // #include <nlohmann/detail/abi_macros.hpp>
+
+
+    /*!
+    @brief namespace for Niels Lohmann
+    @see https://github.com/nlohmann
+    @since version 1.0.0
+    */
+    NLOHMANN_JSON_NAMESPACE_BEGIN
+
+    /*!
+    @brief default JSONSerializer template argument
+
+    This serializer ignores the template arguments and uses ADL
+    ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
+    for serialization.
+    */
+    template<typename T = void, typename SFINAE = void>
+    struct adl_serializer;
+
+    /// a class to store JSON values
+    /// @sa https://json.nlohmann.me/api/basic_json/
+    template<template<typename U, typename V, typename... Args> class ObjectType =
+    std::map,
+    template<typename U, typename... Args> class ArrayType = std::vector,
+    class StringType = std::string, class BooleanType = bool,
+    class NumberIntegerType = std::int64_t,
+    class NumberUnsignedType = std::uint64_t,
+    class NumberFloatType = double,
+    template<typename U> class AllocatorType = std::allocator,
+    template<typename T, typename SFINAE = void> class JSONSerializer =
+    adl_serializer,
+    class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
+    class CustomBaseClass = void>
+    class basic_json;
+
+    /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+    /// @sa https://json.nlohmann.me/api/json_pointer/
+    template<typename RefStringType>
+    class json_pointer;
+
+    /*!
+    @brief default specialization
+    @sa https://json.nlohmann.me/api/json/
+    */
+    using json = basic_json<>;
+
+    /// @brief a minimal map-like container that preserves insertion order
+    /// @sa https://json.nlohmann.me/api/ordered_map/
+    template<class Key, class T, class IgnoredLess, class Allocator>
+    struct ordered_map;
+
+    /// @brief specialization that maintains the insertion order of object keys
+    /// @sa https://json.nlohmann.me/api/ordered_json/
+    using ordered_json = basic_json<nlohmann::ordered_map>;
+
+    NLOHMANN_JSON_NAMESPACE_END
+
+#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+/*!
+@brief detail namespace with internal helper functions
+
+This namespace collects functions that should not be exposed,
+implementations of some @ref basic_json methods, and meta-programming helpers.
+
+@since version 2.1.0
+*/
+namespace detail
+{
+
+/////////////
+// helpers //
+/////////////
+
+// Note to maintainers:
+//
+// Every trait in this file expects a non CV-qualified type.
+// The only exceptions are in the 'aliases for detected' section
+// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
+//
+// In this case, T has to be properly CV-qualified to constraint the function arguments
+// (e.g. to_json(BasicJsonType&, const T&))
+
+template<typename> struct is_basic_json : std::false_type {};
+
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
+
+// used by exceptions create() member functions
+// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t
+// false_type otherwise
+template<typename BasicJsonContext>
+struct is_basic_json_context :
+    std::integral_constant < bool,
+    is_basic_json<typename std::remove_cv<typename std::remove_pointer<BasicJsonContext>::type>::type>::value
+    || std::is_same<BasicJsonContext, std::nullptr_t>::value >
+{};
+
+//////////////////////
+// json_ref helpers //
+//////////////////////
+
+template<typename>
+class json_ref;
+
+template<typename>
+struct is_json_ref : std::false_type {};
+
+template<typename T>
+struct is_json_ref<json_ref<T>> : std::true_type {};
+
+//////////////////////////
+// aliases for detected //
+//////////////////////////
+
+template<typename T>
+using mapped_type_t = typename T::mapped_type;
+
+template<typename T>
+using key_type_t = typename T::key_type;
+
+template<typename T>
+using value_type_t = typename T::value_type;
+
+template<typename T>
+using difference_type_t = typename T::difference_type;
+
+template<typename T>
+using pointer_t = typename T::pointer;
+
+template<typename T>
+using reference_t = typename T::reference;
+
+template<typename T>
+using iterator_category_t = typename T::iterator_category;
+
+template<typename T, typename... Args>
+using to_json_function = decltype(T::to_json(std::declval<Args>()...));
+
+template<typename T, typename... Args>
+using from_json_function = decltype(T::from_json(std::declval<Args>()...));
+
+template<typename T, typename U>
+using get_template_function = decltype(std::declval<T>().template get<U>());
+
+// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
+template<typename BasicJsonType, typename T, typename = void>
+struct has_from_json : std::false_type {};
+
+// trait checking if j.get<T> is valid
+// use this trait instead of std::is_constructible or std::is_convertible,
+// both rely on, or make use of implicit conversions, and thus fail when T
+// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
+template <typename BasicJsonType, typename T>
+struct is_getable
+{
+    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
+};
+
+template<typename BasicJsonType, typename T>
+struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, from_json_function, serializer,
+        const BasicJsonType&, T&>::value;
+};
+
+// This trait checks if JSONSerializer<T>::from_json(json const&) exists
+// this overload is used for non-default-constructible user-defined-types
+template<typename BasicJsonType, typename T, typename = void>
+struct has_non_default_from_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<T, from_json_function, serializer,
+        const BasicJsonType&>::value;
+};
+
+// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
+// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
+template<typename BasicJsonType, typename T, typename = void>
+struct has_to_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
+        T>::value;
+};
+
+template<typename T>
+using detect_key_compare = typename T::key_compare;
+
+template<typename T>
+struct has_key_compare : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {};
+
+// obtains the actual object key comparator
+template<typename BasicJsonType>
+struct actual_object_comparator
+{
+    using object_t = typename BasicJsonType::object_t;
+    using object_comparator_t = typename BasicJsonType::default_object_comparator_t;
+    using type = typename std::conditional < has_key_compare<object_t>::value,
+          typename object_t::key_compare, object_comparator_t>::type;
+};
+
+template<typename BasicJsonType>
+using actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type;
+
+/////////////////
+// char_traits //
+/////////////////
+
+// Primary template of char_traits calls std char_traits
+template<typename T>
+struct char_traits : std::char_traits<T>
+{};
+
+// Explicitly define char traits for unsigned char since it is not standard
+template<>
+struct char_traits<unsigned char> : std::char_traits<char>
+{
+    using char_type = unsigned char;
+    using int_type = uint64_t;
+
+    // Redefine to_int_type function
+    static int_type to_int_type(char_type c) noexcept
+    {
+        return static_cast<int_type>(c);
+    }
+
+    static char_type to_char_type(int_type i) noexcept
+    {
+        return static_cast<char_type>(i);
+    }
+
+    static constexpr int_type eof() noexcept
+    {
+        return static_cast<int_type>(EOF);
+    }
+};
+
+// Explicitly define char traits for signed char since it is not standard
+template<>
+struct char_traits<signed char> : std::char_traits<char>
+{
+    using char_type = signed char;
+    using int_type = uint64_t;
+
+    // Redefine to_int_type function
+    static int_type to_int_type(char_type c) noexcept
+    {
+        return static_cast<int_type>(c);
+    }
+
+    static char_type to_char_type(int_type i) noexcept
+    {
+        return static_cast<char_type>(i);
+    }
+
+    static constexpr int_type eof() noexcept
+    {
+        return static_cast<int_type>(EOF);
+    }
+};
+
+///////////////////
+// is_ functions //
+///////////////////
+
+// https://en.cppreference.com/w/cpp/types/conjunction
+template<class...> struct conjunction : std::true_type { };
+template<class B> struct conjunction<B> : B { };
+template<class B, class... Bn>
+struct conjunction<B, Bn...>
+: std::conditional<static_cast<bool>(B::value), conjunction<Bn...>, B>::type {};
+
+// https://en.cppreference.com/w/cpp/types/negation
+template<class B> struct negation : std::integral_constant < bool, !B::value > { };
+
+// Reimplementation of is_constructible and is_default_constructible, due to them being broken for
+// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
+// This causes compile errors in e.g. clang 3.5 or gcc 4.9.
+template <typename T>
+struct is_default_constructible : std::is_default_constructible<T> {};
+
+template <typename T1, typename T2>
+struct is_default_constructible<std::pair<T1, T2>>
+            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+
+template <typename T1, typename T2>
+struct is_default_constructible<const std::pair<T1, T2>>
+            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+
+template <typename... Ts>
+struct is_default_constructible<std::tuple<Ts...>>
+            : conjunction<is_default_constructible<Ts>...> {};
+
+template <typename... Ts>
+struct is_default_constructible<const std::tuple<Ts...>>
+            : conjunction<is_default_constructible<Ts>...> {};
+
+template <typename T, typename... Args>
+struct is_constructible : std::is_constructible<T, Args...> {};
+
+template <typename T1, typename T2>
+struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
+
+template <typename T1, typename T2>
+struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
+
+template <typename... Ts>
+struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
+
+template <typename... Ts>
+struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
+
+template<typename T, typename = void>
+struct is_iterator_traits : std::false_type {};
+
+template<typename T>
+struct is_iterator_traits<iterator_traits<T>>
+{
+  private:
+    using traits = iterator_traits<T>;
+
+  public:
+    static constexpr auto value =
+        is_detected<value_type_t, traits>::value &&
+        is_detected<difference_type_t, traits>::value &&
+        is_detected<pointer_t, traits>::value &&
+        is_detected<iterator_category_t, traits>::value &&
+        is_detected<reference_t, traits>::value;
+};
+
+template<typename T>
+struct is_range
+{
+  private:
+    using t_ref = typename std::add_lvalue_reference<T>::type;
+
+    using iterator = detected_t<result_of_begin, t_ref>;
+    using sentinel = detected_t<result_of_end, t_ref>;
+
+    // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator
+    // and https://en.cppreference.com/w/cpp/iterator/sentinel_for
+    // but reimplementing these would be too much work, as a lot of other concepts are used underneath
+    static constexpr auto is_iterator_begin =
+        is_iterator_traits<iterator_traits<iterator>>::value;
+
+  public:
+    static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
+};
+
+template<typename R>
+using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
+
+template<typename T>
+using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
+
+// The following implementation of is_complete_type is taken from
+// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
+// and is written by Xiang Fan who agreed to using it in this library.
+
+template<typename T, typename = void>
+struct is_complete_type : std::false_type {};
+
+template<typename T>
+struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType,
+         typename = void>
+struct is_compatible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type_impl <
+    BasicJsonType, CompatibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
+    is_detected<key_type_t, CompatibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    // macOS's is_constructible does not play well with nonesuch...
+    static constexpr bool value =
+        is_constructible<typename object_t::key_type,
+        typename CompatibleObjectType::key_type>::value &&
+        is_constructible<typename object_t::mapped_type,
+        typename CompatibleObjectType::mapped_type>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type
+    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         typename = void>
+struct is_constructible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type_impl <
+    BasicJsonType, ConstructibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
+    is_detected<key_type_t, ConstructibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    static constexpr bool value =
+        (is_default_constructible<ConstructibleObjectType>::value &&
+         (std::is_move_assignable<ConstructibleObjectType>::value ||
+          std::is_copy_assignable<ConstructibleObjectType>::value) &&
+         (is_constructible<typename ConstructibleObjectType::key_type,
+          typename object_t::key_type>::value &&
+          std::is_same <
+          typename object_t::mapped_type,
+          typename ConstructibleObjectType::mapped_type >::value)) ||
+        (has_from_json<BasicJsonType,
+         typename ConstructibleObjectType::mapped_type>::value ||
+         has_non_default_from_json <
+         BasicJsonType,
+         typename ConstructibleObjectType::mapped_type >::value);
+};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type
+    : is_constructible_object_type_impl<BasicJsonType,
+      ConstructibleObjectType> {};
+
+template<typename BasicJsonType, typename CompatibleStringType>
+struct is_compatible_string_type
+{
+    static constexpr auto value =
+        is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type
+{
+    // launder type through decltype() to fix compilation failure on ICPC
+#ifdef __INTEL_COMPILER
+    using laundered_type = decltype(std::declval<ConstructibleStringType>());
+#else
+    using laundered_type = ConstructibleStringType;
+#endif
+
+    static constexpr auto value =
+        conjunction <
+        is_constructible<laundered_type, typename BasicJsonType::string_t>,
+        is_detected_exact<typename BasicJsonType::string_t::value_type,
+        value_type_t, laundered_type >>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
+struct is_compatible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type_impl <
+    BasicJsonType, CompatibleArrayType,
+    enable_if_t <
+    is_detected<iterator_t, CompatibleArrayType>::value&&
+    is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&
+// special case for types like std::filesystem::path whose iterator's value_type are themselves
+// c.f. https://github.com/nlohmann/json/pull/3073
+    !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
+{
+    static constexpr bool value =
+        is_constructible<BasicJsonType,
+        range_value_t<CompatibleArrayType>>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type
+    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
+struct is_constructible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t<std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value >>
+            : std::true_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t < !std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value&&
+    !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+    is_default_constructible<ConstructibleArrayType>::value&&
+(std::is_move_assignable<ConstructibleArrayType>::value ||
+ std::is_copy_assignable<ConstructibleArrayType>::value)&&
+is_detected<iterator_t, ConstructibleArrayType>::value&&
+is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
+is_detected<range_value_t, ConstructibleArrayType>::value&&
+// special case for types like std::filesystem::path whose iterator's value_type are themselves
+// c.f. https://github.com/nlohmann/json/pull/3073
+!std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
+        is_complete_type <
+        detected_t<range_value_t, ConstructibleArrayType >>::value >>
+{
+    using value_type = range_value_t<ConstructibleArrayType>;
+
+    static constexpr bool value =
+        std::is_same<value_type,
+        typename BasicJsonType::array_t::value_type>::value ||
+        has_from_json<BasicJsonType,
+        value_type>::value ||
+        has_non_default_from_json <
+        BasicJsonType,
+        value_type >::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type
+    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType,
+         typename = void>
+struct is_compatible_integer_type_impl : std::false_type {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type_impl <
+    RealIntegerType, CompatibleNumberIntegerType,
+    enable_if_t < std::is_integral<RealIntegerType>::value&&
+    std::is_integral<CompatibleNumberIntegerType>::value&&
+    !std::is_same<bool, CompatibleNumberIntegerType>::value >>
+{
+    // is there an assert somewhere on overflows?
+    using RealLimits = std::numeric_limits<RealIntegerType>;
+    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
+
+    static constexpr auto value =
+        is_constructible<RealIntegerType,
+        CompatibleNumberIntegerType>::value &&
+        CompatibleLimits::is_integer &&
+        RealLimits::is_signed == CompatibleLimits::is_signed;
+};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type
+    : is_compatible_integer_type_impl<RealIntegerType,
+      CompatibleNumberIntegerType> {};
+
+template<typename BasicJsonType, typename CompatibleType, typename = void>
+struct is_compatible_type_impl: std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type_impl <
+    BasicJsonType, CompatibleType,
+    enable_if_t<is_complete_type<CompatibleType>::value >>
+{
+    static constexpr bool value =
+        has_to_json<BasicJsonType, CompatibleType>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type
+    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
+
+template<typename T1, typename T2>
+struct is_constructible_tuple : std::false_type {};
+
+template<typename T1, typename... Args>
+struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
+
+template<typename BasicJsonType, typename T>
+struct is_json_iterator_of : std::false_type {};
+
+template<typename BasicJsonType>
+struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::iterator> : std::true_type {};
+
+template<typename BasicJsonType>
+struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::const_iterator> : std::true_type
+{};
+
+// checks if a given type T is a template specialization of Primary
+template<template <typename...> class Primary, typename T>
+struct is_specialization_of : std::false_type {};
+
+template<template <typename...> class Primary, typename... Args>
+struct is_specialization_of<Primary, Primary<Args...>> : std::true_type {};
+
+template<typename T>
+using is_json_pointer = is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>;
+
+// checks if A and B are comparable using Compare functor
+template<typename Compare, typename A, typename B, typename = void>
+struct is_comparable : std::false_type {};
+
+template<typename Compare, typename A, typename B>
+struct is_comparable<Compare, A, B, void_t<
+decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>())),
+decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>()))
+>> : std::true_type {};
+
+template<typename T>
+using detect_is_transparent = typename T::is_transparent;
+
+// type trait to check if KeyType can be used as object key (without a BasicJsonType)
+// see is_usable_as_basic_json_key_type below
+template<typename Comparator, typename ObjectKeyType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
+         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
+using is_usable_as_key_type = typename std::conditional <
+                              is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value
+                              && !(ExcludeObjectKeyType && std::is_same<KeyType,
+                                   ObjectKeyType>::value)
+                              && (!RequireTransparentComparator
+                                  || is_detected <detect_is_transparent, Comparator>::value)
+                              && !is_json_pointer<KeyType>::value,
+                              std::true_type,
+                              std::false_type >::type;
+
+// type trait to check if KeyType can be used as object key
+// true if:
+//   - KeyType is comparable with BasicJsonType::object_t::key_type
+//   - if ExcludeObjectKeyType is true, KeyType is not BasicJsonType::object_t::key_type
+//   - the comparator is transparent or RequireTransparentComparator is false
+//   - KeyType is not a JSON iterator or json_pointer
+template<typename BasicJsonType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
+         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
+using is_usable_as_basic_json_key_type = typename std::conditional <
+        is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
+        typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
+        RequireTransparentComparator, ExcludeObjectKeyType>::value
+        && !is_json_iterator_of<BasicJsonType, KeyType>::value,
+        std::true_type,
+        std::false_type >::type;
+
+template<typename ObjectType, typename KeyType>
+using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()));
+
+// type trait to check if object_t has an erase() member functions accepting KeyType
+template<typename BasicJsonType, typename KeyType>
+using has_erase_with_key_type = typename std::conditional <
+                                is_detected <
+                                detect_erase_with_key_type,
+                                typename BasicJsonType::object_t, KeyType >::value,
+                                std::true_type,
+                                std::false_type >::type;
+
+// a naive helper to check if a type is an ordered_map (exploits the fact that
+// ordered_map inherits capacity() from std::vector)
+template <typename T>
+struct is_ordered_map
+{
+    using one = char;
+
+    struct two
+    {
+        char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+    };
+
+    template <typename C> static one test( decltype(&C::capacity) ) ;
+    template <typename C> static two test(...);
+
+    enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+};
+
+// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
+template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
+T conditional_static_cast(U value)
+{
+    return static_cast<T>(value);
+}
+
+template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
+T conditional_static_cast(U value)
+{
+    return value;
+}
+
+template<typename... Types>
+using all_integral = conjunction<std::is_integral<Types>...>;
+
+template<typename... Types>
+using all_signed = conjunction<std::is_signed<Types>...>;
+
+template<typename... Types>
+using all_unsigned = conjunction<std::is_unsigned<Types>...>;
+
+// there's a disjunction trait in another PR; replace when merged
+template<typename... Types>
+using same_sign = std::integral_constant < bool,
+      all_signed<Types...>::value || all_unsigned<Types...>::value >;
+
+template<typename OfType, typename T>
+using never_out_of_range = std::integral_constant < bool,
+      (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType)))
+      || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) >;
+
+template<typename OfType, typename T,
+         bool OfTypeSigned = std::is_signed<OfType>::value,
+         bool TSigned = std::is_signed<T>::value>
+struct value_in_range_of_impl2;
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, false, false>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, true, false>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, false, true>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return val >= 0 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, true, true>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) >= static_cast<CommonType>((std::numeric_limits<OfType>::min)())
+               && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T,
+         bool NeverOutOfRange = never_out_of_range<OfType, T>::value,
+         typename = detail::enable_if_t<all_integral<OfType, T>::value>>
+struct value_in_range_of_impl1;
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl1<OfType, T, false>
+{
+    static constexpr bool test(T val)
+    {
+        return value_in_range_of_impl2<OfType, T>::test(val);
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl1<OfType, T, true>
+{
+    static constexpr bool test(T /*val*/)
+    {
+        return true;
+    }
+};
+
+template<typename OfType, typename T>
+inline constexpr bool value_in_range_of(T val)
+{
+    return value_in_range_of_impl1<OfType, T>::test(val);
+}
+
+template<bool Value>
+using bool_constant = std::integral_constant<bool, Value>;
+
+///////////////////////////////////////////////////////////////////////////////
+// is_c_string
+///////////////////////////////////////////////////////////////////////////////
+
+namespace impl
+{
+
+template<typename T>
+inline constexpr bool is_c_string()
+{
+    using TUnExt = typename std::remove_extent<T>::type;
+    using TUnCVExt = typename std::remove_cv<TUnExt>::type;
+    using TUnPtr = typename std::remove_pointer<T>::type;
+    using TUnCVPtr = typename std::remove_cv<TUnPtr>::type;
+    return
+        (std::is_array<T>::value && std::is_same<TUnCVExt, char>::value)
+        || (std::is_pointer<T>::value && std::is_same<TUnCVPtr, char>::value);
+}
+
+}  // namespace impl
+
+// checks whether T is a [cv] char */[cv] char[] C string
+template<typename T>
+struct is_c_string : bool_constant<impl::is_c_string<T>()> {};
+
+template<typename T>
+using is_c_string_uncvref = is_c_string<uncvref_t<T>>;
+
+///////////////////////////////////////////////////////////////////////////////
+// is_transparent
+///////////////////////////////////////////////////////////////////////////////
+
+namespace impl
+{
+
+template<typename T>
+inline constexpr bool is_transparent()
+{
+    return is_detected<detect_is_transparent, T>::value;
+}
+
+}  // namespace impl
+
+// checks whether T has a member named is_transparent
+template<typename T>
+struct is_transparent : bool_constant<impl::is_transparent<T>()> {};
+
+///////////////////////////////////////////////////////////////////////////////
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/string_concat.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstring> // strlen
+#include <string> // string
+#include <utility> // forward
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+inline std::size_t concat_length()
+{
+    return 0;
+}
+
+template<typename... Args>
+inline std::size_t concat_length(const char* cstr, const Args& ... rest);
+
+template<typename StringType, typename... Args>
+inline std::size_t concat_length(const StringType& str, const Args& ... rest);
+
+template<typename... Args>
+inline std::size_t concat_length(const char /*c*/, const Args& ... rest)
+{
+    return 1 + concat_length(rest...);
+}
+
+template<typename... Args>
+inline std::size_t concat_length(const char* cstr, const Args& ... rest)
+{
+    // cppcheck-suppress ignoredReturnValue
+    return ::strlen(cstr) + concat_length(rest...);
+}
+
+template<typename StringType, typename... Args>
+inline std::size_t concat_length(const StringType& str, const Args& ... rest)
+{
+    return str.size() + concat_length(rest...);
+}
+
+template<typename OutStringType>
+inline void concat_into(OutStringType& /*out*/)
+{}
+
+template<typename StringType, typename Arg>
+using string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg && > ()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append = is_detected<string_can_append, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg && > ());
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_op = is_detected<string_can_append_op, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_iter = is_detected<string_can_append_iter, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_data = is_detected<string_can_append_data, StringType, Arg>;
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && detect_string_can_append_op<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest);
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && !detect_string_can_append_iter<OutStringType, Arg>::value
+                         && detect_string_can_append_data<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
+
+template<typename OutStringType, typename Arg, typename... Args,
+         enable_if_t<detect_string_can_append<OutStringType, Arg>::value, int> = 0>
+inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest)
+{
+    out.append(std::forward<Arg>(arg));
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && detect_string_can_append_op<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, Arg&& arg, Args&& ... rest)
+{
+    out += std::forward<Arg>(arg);
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
+{
+    out.append(arg.begin(), arg.end());
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && !detect_string_can_append_iter<OutStringType, Arg>::value
+                         && detect_string_can_append_data<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
+{
+    out.append(arg.data(), arg.size());
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template<typename OutStringType = std::string, typename... Args>
+inline OutStringType concat(Args && ... args)
+{
+    OutStringType str;
+    str.reserve(concat_length(args...));
+    concat_into(str, std::forward<Args>(args)...);
+    return str;
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+////////////////
+// exceptions //
+////////////////
+
+/// @brief general exception of the @ref basic_json class
+/// @sa https://json.nlohmann.me/api/basic_json/exception/
+class exception : public std::exception
+{
+  public:
+    /// returns the explanatory string
+    const char* what() const noexcept override
+    {
+        return m.what();
+    }
+
+    /// the id of the exception
+    const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
+
+  protected:
+    JSON_HEDLEY_NON_NULL(3)
+    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
+
+    static std::string name(const std::string& ename, int id_)
+    {
+        return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
+    }
+
+    static std::string diagnostics(std::nullptr_t /*leaf_element*/)
+    {
+        return "";
+    }
+
+    template<typename BasicJsonType>
+    static std::string diagnostics(const BasicJsonType* leaf_element)
+    {
+#if JSON_DIAGNOSTICS
+        std::vector<std::string> tokens;
+        for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent)
+        {
+            switch (current->m_parent->type())
+            {
+                case value_t::array:
+                {
+                    for (std::size_t i = 0; i < current->m_parent->m_data.m_value.array->size(); ++i)
+                    {
+                        if (&current->m_parent->m_data.m_value.array->operator[](i) == current)
+                        {
+                            tokens.emplace_back(std::to_string(i));
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                case value_t::object:
+                {
+                    for (const auto& element : *current->m_parent->m_data.m_value.object)
+                    {
+                        if (&element.second == current)
+                        {
+                            tokens.emplace_back(element.first.c_str());
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                case value_t::null: // LCOV_EXCL_LINE
+                case value_t::string: // LCOV_EXCL_LINE
+                case value_t::boolean: // LCOV_EXCL_LINE
+                case value_t::number_integer: // LCOV_EXCL_LINE
+                case value_t::number_unsigned: // LCOV_EXCL_LINE
+                case value_t::number_float: // LCOV_EXCL_LINE
+                case value_t::binary: // LCOV_EXCL_LINE
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:   // LCOV_EXCL_LINE
+                    break; // LCOV_EXCL_LINE
+            }
+        }
+
+        if (tokens.empty())
+        {
+            return "";
+        }
+
+        auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
+                                   [](const std::string & a, const std::string & b)
+        {
+            return concat(a, '/', detail::escape(b));
+        });
+        return concat('(', str, ") ");
+#else
+        static_cast<void>(leaf_element);
+        return "";
+#endif
+    }
+
+  private:
+    /// an exception object as storage for error messages
+    std::runtime_error m;
+};
+
+/// @brief exception indicating a parse error
+/// @sa https://json.nlohmann.me/api/basic_json/parse_error/
+class parse_error : public exception
+{
+  public:
+    /*!
+    @brief create a parse error exception
+    @param[in] id_       the id of the exception
+    @param[in] pos       the position where the error occurred (or with
+                         chars_read_total=0 if the position cannot be
+                         determined)
+    @param[in] what_arg  the explanatory string
+    @return parse_error object
+    */
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("parse_error", id_), "parse error",
+                                     position_string(pos), ": ", exception::diagnostics(context), what_arg);
+        return {id_, pos.chars_read_total, w.c_str()};
+    }
+
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("parse_error", id_), "parse error",
+                                     (byte_ != 0 ? (concat(" at byte ", std::to_string(byte_))) : ""),
+                                     ": ", exception::diagnostics(context), what_arg);
+        return {id_, byte_, w.c_str()};
+    }
+
+    /*!
+    @brief byte index of the parse error
+
+    The byte index of the last read character in the input file.
+
+    @note For an input with n bytes, 1 is the index of the first character and
+          n+1 is the index of the terminating null byte or the end of file.
+          This also holds true when reading a byte vector (CBOR or MessagePack).
+    */
+    const std::size_t byte;
+
+  private:
+    parse_error(int id_, std::size_t byte_, const char* what_arg)
+        : exception(id_, what_arg), byte(byte_) {}
+
+    static std::string position_string(const position_t& pos)
+    {
+        return concat(" at line ", std::to_string(pos.lines_read + 1),
+                      ", column ", std::to_string(pos.chars_read_current_line));
+    }
+};
+
+/// @brief exception indicating errors with iterators
+/// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/
+class invalid_iterator : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    invalid_iterator(int id_, const char* what_arg)
+        : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating executing a member function with a wrong type
+/// @sa https://json.nlohmann.me/api/basic_json/type_error/
+class type_error : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating access out of the defined range
+/// @sa https://json.nlohmann.me/api/basic_json/out_of_range/
+class out_of_range : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating other library errors
+/// @sa https://json.nlohmann.me/api/basic_json/other_error/
+class other_error : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static other_error create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/identity_tag.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// dispatching helper struct
+template <class T> struct identity_tag {};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/std_fs.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
+#include <experimental/filesystem>
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace std_fs = std::experimental::filesystem;
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+#elif JSON_HAS_FILESYSTEM
+#include <filesystem>
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace std_fs = std::filesystem;
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+#endif
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be null, but is ", j.type_name()), &j));
+    }
+    n = nullptr;
+}
+
+// overloads for basic_json template parameters
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
+                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+                         int > = 0 >
+void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+
+        case value_t::null:
+        case value_t::object:
+        case value_t::array:
+        case value_t::string:
+        case value_t::boolean:
+        case value_t::binary:
+        case value_t::discarded:
+        default:
+            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
+    }
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
+    }
+    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template <
+    typename BasicJsonType, typename StringType,
+    enable_if_t <
+        std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value
+        && is_detected_exact<typename BasicJsonType::string_t::value_type, value_type_t, StringType>::value
+        && !std::is_same<typename BasicJsonType::string_t, StringType>::value
+        && !is_json_ref<StringType>::value, int > = 0 >
+inline void from_json(const BasicJsonType& j, StringType& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+#if !JSON_DISABLE_ENUM_SERIALIZATION
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, EnumType& e)
+{
+    typename std::underlying_type<EnumType>::type val;
+    get_arithmetic_value(j, val);
+    e = static_cast<EnumType>(val);
+}
+#endif  // JSON_DISABLE_ENUM_SERIALIZATION
+
+// forward_list doesn't have an insert method
+template<typename BasicJsonType, typename T, typename Allocator,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    l.clear();
+    std::transform(j.rbegin(), j.rend(),
+                   std::front_inserter(l), [](const BasicJsonType & i)
+    {
+        return i.template get<T>();
+    });
+}
+
+// valarray doesn't have an insert method
+template<typename BasicJsonType, typename T,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    l.resize(j.size());
+    std::transform(j.begin(), j.end(), std::begin(l),
+                   [](const BasicJsonType & elem)
+    {
+        return elem.template get<T>();
+    });
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType>
+inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
+{
+    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
+                          priority_tag<2> /*unused*/)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType,
+         enable_if_t<
+             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
+             int> = 0>
+auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
+-> decltype(
+    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
+    j.template get<typename ConstructibleArrayType::value_type>(),
+    void())
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    ret.reserve(j.size());
+    std::transform(j.begin(), j.end(),
+                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType,
+         enable_if_t<
+             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
+             int> = 0>
+inline void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
+                                 priority_tag<0> /*unused*/)
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    std::transform(
+        j.begin(), j.end(), std::inserter(ret, end(ret)),
+        [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template < typename BasicJsonType, typename ConstructibleArrayType,
+           enable_if_t <
+               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
+               !is_basic_json<ConstructibleArrayType>::value,
+               int > = 0 >
+auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
+-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
+j.template get<typename ConstructibleArrayType::value_type>(),
+void())
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    from_json_array_impl(j, arr, priority_tag<3> {});
+}
+
+template < typename BasicJsonType, typename T, std::size_t... Idx >
+std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
+        identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
+{
+    return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
+}
+
+template < typename BasicJsonType, typename T, std::size_t N >
+auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
+-> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be binary, but is ", j.type_name()), &j));
+    }
+
+    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
+}
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be object, but is ", j.type_name()), &j));
+    }
+
+    ConstructibleObjectType ret;
+    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
+    using value_type = typename ConstructibleObjectType::value_type;
+    std::transform(
+        inner_object->begin(), inner_object->end(),
+        std::inserter(ret, ret.begin()),
+        [](typename BasicJsonType::object_t::value_type const & p)
+    {
+        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
+    });
+    obj = std::move(ret);
+}
+
+// overload for arithmetic types, not chosen for basic_json template arguments
+// (BooleanType, etc..); note: Is it really necessary to provide explicit
+// overloads for boolean_t etc. in case of a custom BooleanType which is not
+// an arithmetic type?
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t <
+               std::is_arithmetic<ArithmeticType>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+               int > = 0 >
+inline void from_json(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+        case value_t::boolean:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
+            break;
+        }
+
+        case value_t::null:
+        case value_t::object:
+        case value_t::array:
+        case value_t::string:
+        case value_t::binary:
+        case value_t::discarded:
+        default:
+            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
+    }
+}
+
+template<typename BasicJsonType, typename... Args, std::size_t... Idx>
+std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
+{
+    return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
+}
+
+template < typename BasicJsonType, class A1, class A2 >
+std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
+{
+    return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
+            std::forward<BasicJsonType>(j).at(1).template get<A2>()};
+}
+
+template<typename BasicJsonType, typename A1, typename A2>
+inline void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
+{
+    p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
+}
+
+template<typename BasicJsonType, typename... Args>
+std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
+{
+    return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+}
+
+template<typename BasicJsonType, typename... Args>
+inline void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
+{
+    t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+}
+
+template<typename BasicJsonType, typename TupleRelated>
+auto from_json(BasicJsonType&& j, TupleRelated&& t)
+-> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+inline void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+inline void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, std_fs::path& p)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+    p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+#endif
+
+struct from_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(const BasicJsonType& j, T&& val) const
+    noexcept(noexcept(from_json(j, std::forward<T>(val))))
+    -> decltype(from_json(j, std::forward<T>(val)))
+    {
+        return from_json(j, std::forward<T>(val));
+    }
+};
+
+}  // namespace detail
+
+#ifndef JSON_HAS_CPP_17
+/// namespace to hold default `from_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+{
+#endif
+JSON_INLINE_VARIABLE constexpr const auto& from_json = // NOLINT(misc-definitions-in-headers)
+    detail::static_const<detail::from_json_fn>::value;
+#ifndef JSON_HAS_CPP_17
+}  // namespace
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // copy
+#include <iterator> // begin, end
+#include <string> // string
+#include <tuple> // tuple, get
+#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
+#include <utility> // move, forward, declval, pair
+#include <valarray> // valarray
+#include <vector> // vector
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // size_t
+#include <iterator> // input_iterator_tag
+#include <string> // string, to_string
+#include <tuple> // tuple_size, get, tuple_element
+#include <utility> // move
+
+#if JSON_HAS_RANGES
+    #include <ranges> // enable_borrowed_range
+#endif
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename string_type>
+void int_to_string( string_type& target, std::size_t value )
+{
+    // For ADL
+    using std::to_string;
+    target = to_string(value);
+}
+template<typename IteratorType> class iteration_proxy_value
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    using value_type = iteration_proxy_value;
+    using pointer = value_type *;
+    using reference = value_type &;
+    using iterator_category = std::input_iterator_tag;
+    using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
+
+  private:
+    /// the iterator
+    IteratorType anchor{};
+    /// an index for arrays (used to create key names)
+    std::size_t array_index = 0;
+    /// last stringified array index
+    mutable std::size_t array_index_last = 0;
+    /// a string representation of the array index
+    mutable string_type array_index_str = "0";
+    /// an empty string (to return a reference for primitive values)
+    string_type empty_str{};
+
+  public:
+    explicit iteration_proxy_value() = default;
+    explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
+    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
+             && std::is_nothrow_default_constructible<string_type>::value)
+        : anchor(std::move(it))
+        , array_index(array_index_)
+    {}
+
+    iteration_proxy_value(iteration_proxy_value const&) = default;
+    iteration_proxy_value& operator=(iteration_proxy_value const&) = default;
+    // older GCCs are a bit fussy and require explicit noexcept specifiers on defaulted functions
+    iteration_proxy_value(iteration_proxy_value&&)
+    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
+             && std::is_nothrow_move_constructible<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
+    iteration_proxy_value& operator=(iteration_proxy_value&&)
+    noexcept(std::is_nothrow_move_assignable<IteratorType>::value
+             && std::is_nothrow_move_assignable<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
+    ~iteration_proxy_value() = default;
+
+    /// dereference operator (needed for range-based for)
+    const iteration_proxy_value& operator*() const
+    {
+        return *this;
+    }
+
+    /// increment operator (needed for range-based for)
+    iteration_proxy_value& operator++()
+    {
+        ++anchor;
+        ++array_index;
+
+        return *this;
+    }
+
+    iteration_proxy_value operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto tmp = iteration_proxy_value(anchor, array_index);
+        ++anchor;
+        ++array_index;
+        return tmp;
+    }
+
+    /// equality operator (needed for InputIterator)
+    bool operator==(const iteration_proxy_value& o) const
+    {
+        return anchor == o.anchor;
+    }
+
+    /// inequality operator (needed for range-based for)
+    bool operator!=(const iteration_proxy_value& o) const
+    {
+        return anchor != o.anchor;
+    }
+
+    /// return key of the iterator
+    const string_type& key() const
+    {
+        JSON_ASSERT(anchor.m_object != nullptr);
+
+        switch (anchor.m_object->type())
+        {
+            // use integer array index as key
+            case value_t::array:
+            {
+                if (array_index != array_index_last)
+                {
+                    int_to_string( array_index_str, array_index );
+                    array_index_last = array_index;
+                }
+                return array_index_str;
+            }
+
+            // use key from the object
+            case value_t::object:
+                return anchor.key();
+
+            // use an empty key for all primitive types
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return empty_str;
+        }
+    }
+
+    /// return value of the iterator
+    typename IteratorType::reference value() const
+    {
+        return anchor.value();
+    }
+};
+
+/// proxy class for the items() function
+template<typename IteratorType> class iteration_proxy
+{
+  private:
+    /// the container to iterate
+    typename IteratorType::pointer container = nullptr;
+
+  public:
+    explicit iteration_proxy() = default;
+
+    /// construct iteration proxy from a container
+    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
+        : container(&cont) {}
+
+    iteration_proxy(iteration_proxy const&) = default;
+    iteration_proxy& operator=(iteration_proxy const&) = default;
+    iteration_proxy(iteration_proxy&&) noexcept = default;
+    iteration_proxy& operator=(iteration_proxy&&) noexcept = default;
+    ~iteration_proxy() = default;
+
+    /// return iterator begin (needed for range-based for)
+    iteration_proxy_value<IteratorType> begin() const noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container->begin());
+    }
+
+    /// return iterator end (needed for range-based for)
+    iteration_proxy_value<IteratorType> end() const noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container->end());
+    }
+};
+
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
+{
+    return i.key();
+}
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
+{
+    return i.value();
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// The Addition to the STD Namespace is required to add
+// Structured Bindings Support to the iteration_proxy_value class
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+namespace std
+{
+
+#if defined(__clang__)
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+template<typename IteratorType>
+class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
+            : public std::integral_constant<std::size_t, 2> {};
+
+template<std::size_t N, typename IteratorType>
+class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >> // NOLINT(cert-dcl58-cpp)
+{
+  public:
+    using type = decltype(
+                     get<N>(std::declval <
+                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
+};
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+}  // namespace std
+
+#if JSON_HAS_RANGES
+    template <typename IteratorType>
+    inline constexpr bool ::std::ranges::enable_borrowed_range<::nlohmann::detail::iteration_proxy<IteratorType>> = true;
+#endif
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/std_fs.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+//////////////////
+// constructors //
+//////////////////
+
+/*
+ * Note all external_constructor<>::construct functions need to call
+ * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an
+ * allocated value (e.g., a string). See bug issue
+ * https://github.com/nlohmann/json/issues/2865 for more information.
+ */
+
+template<value_t> struct external_constructor;
+
+template<>
+struct external_constructor<value_t::boolean>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::boolean;
+        j.m_data.m_value = b;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::string>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value = s;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value = std::move(s);
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleStringType,
+               enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleStringType& str)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::binary>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::binary;
+        j.m_data.m_value = typename BasicJsonType::binary_t(b);
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::binary;
+        j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_float>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_float;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_unsigned>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_unsigned;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_integer>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_integer;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::array>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = arr;
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = std::move(arr);
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleArrayType,
+               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->reserve(arr.size());
+        for (const bool x : arr)
+        {
+            j.m_data.m_value.array->push_back(x);
+            j.set_parent(j.m_data.m_value.array->back());
+        }
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename T,
+             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->resize(arr.size());
+        if (arr.size() > 0)
+        {
+            std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin());
+        }
+        j.set_parents();
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::object>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value = obj;
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value = std::move(obj);
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleObjectType,
+               enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
+        j.set_parents();
+        j.assert_invariant();
+    }
+};
+
+/////////////
+// to_json //
+/////////////
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
+inline void to_json(BasicJsonType& j, T b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, b);
+}
+
+template < typename BasicJsonType, typename BoolRef,
+           enable_if_t <
+               ((std::is_same<std::vector<bool>::reference, BoolRef>::value
+                 && !std::is_same <std::vector<bool>::reference, typename BasicJsonType::boolean_t&>::value)
+                || (std::is_same<std::vector<bool>::const_reference, BoolRef>::value
+                    && !std::is_same <detail::uncvref_t<std::vector<bool>::const_reference>,
+                                      typename BasicJsonType::boolean_t >::value))
+               && std::is_convertible<const BoolRef&, typename BasicJsonType::boolean_t>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const BoolRef& b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, static_cast<typename BasicJsonType::boolean_t>(b));
+}
+
+template<typename BasicJsonType, typename CompatibleString,
+         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const CompatibleString& s)
+{
+    external_constructor<value_t::string>::construct(j, s);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+{
+    external_constructor<value_t::string>::construct(j, std::move(s));
+}
+
+template<typename BasicJsonType, typename FloatType,
+         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, FloatType val) noexcept
+{
+    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
+{
+    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberIntegerType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
+{
+    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
+}
+
+#if !JSON_DISABLE_ENUM_SERIALIZATION
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, EnumType e) noexcept
+{
+    using underlying_type = typename std::underlying_type<EnumType>::type;
+    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
+}
+#endif  // JSON_DISABLE_ENUM_SERIALIZATION
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const std::vector<bool>& e)
+{
+    external_constructor<value_t::array>::construct(j, e);
+}
+
+template < typename BasicJsonType, typename CompatibleArrayType,
+           enable_if_t < is_compatible_array_type<BasicJsonType,
+                         CompatibleArrayType>::value&&
+                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
+                         !is_basic_json<CompatibleArrayType>::value,
+                         int > = 0 >
+inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
+{
+    external_constructor<value_t::binary>::construct(j, bin);
+}
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template < typename BasicJsonType, typename CompatibleObjectType,
+           enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
+{
+    external_constructor<value_t::object>::construct(j, obj);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+{
+    external_constructor<value_t::object>::construct(j, std::move(obj));
+}
+
+template <
+    typename BasicJsonType, typename T, std::size_t N,
+    enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
+                  const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+                  int > = 0 >
+inline void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
+{
+    j = { p.first, p.second };
+}
+
+// for https://github.com/nlohmann/json/pull/1134
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const T& b)
+{
+    j = { {b.key(), b.value()} };
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    j = { std::get<Idx>(t)... };
+}
+
+template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
+inline void to_json(BasicJsonType& j, const T& t)
+{
+    to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
+}
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const std_fs::path& p)
+{
+    j = p.string();
+}
+#endif
+
+struct to_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
+    -> decltype(to_json(j, std::forward<T>(val)), void())
+    {
+        return to_json(j, std::forward<T>(val));
+    }
+};
+}  // namespace detail
+
+#ifndef JSON_HAS_CPP_17
+/// namespace to hold default `to_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+{
+#endif
+JSON_INLINE_VARIABLE constexpr const auto& to_json = // NOLINT(misc-definitions-in-headers)
+    detail::static_const<detail::to_json_fn>::value;
+#ifndef JSON_HAS_CPP_17
+}  // namespace
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/identity_tag.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @sa https://json.nlohmann.me/api/adl_serializer/
+template<typename ValueType, typename>
+struct adl_serializer
+{
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
+        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
+    {
+        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
+    }
+
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j) noexcept(
+    noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
+    {
+        return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
+    }
+
+    /// @brief convert any value type to a JSON value
+    /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
+        noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
+    -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
+    {
+        ::nlohmann::to_json(j, std::forward<TargetType>(val));
+    }
+};
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/byte_container_with_subtype.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstdint> // uint8_t, uint64_t
+#include <tuple> // tie
+#include <utility> // move
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @brief an internal type for a backed binary type
+/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/
+template<typename BinaryType>
+class byte_container_with_subtype : public BinaryType
+{
+  public:
+    using container_type = BinaryType;
+    using subtype_type = std::uint64_t;
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype() noexcept(noexcept(container_type()))
+        : container_type()
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    bool operator==(const byte_container_with_subtype& rhs) const
+    {
+        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
+               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
+    }
+
+    bool operator!=(const byte_container_with_subtype& rhs) const
+    {
+        return !(rhs == *this);
+    }
+
+    /// @brief sets the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/
+    void set_subtype(subtype_type subtype_) noexcept
+    {
+        m_subtype = subtype_;
+        m_has_subtype = true;
+    }
+
+    /// @brief return the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/
+    constexpr subtype_type subtype() const noexcept
+    {
+        return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
+    }
+
+    /// @brief return whether the value has a subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/
+    constexpr bool has_subtype() const noexcept
+    {
+        return m_has_subtype;
+    }
+
+    /// @brief clears the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/
+    void clear_subtype() noexcept
+    {
+        m_subtype = 0;
+        m_has_subtype = false;
+    }
+
+  private:
+    subtype_type m_subtype = 0;
+    bool m_has_subtype = false;
+};
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/hash.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstdint> // uint8_t
+#include <cstddef> // size_t
+#include <functional> // hash
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// boost::hash_combine
+inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
+{
+    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
+    return seed;
+}
+
+/*!
+@brief hash a JSON value
+
+The hash function tries to rely on std::hash where possible. Furthermore, the
+type of the JSON value is taken into account to have different hash values for
+null, 0, 0U, and false, etc.
+
+@tparam BasicJsonType basic_json specialization
+@param j JSON value to hash
+@return hash value of j
+*/
+template<typename BasicJsonType>
+std::size_t hash(const BasicJsonType& j)
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+    const auto type = static_cast<std::size_t>(j.type());
+    switch (j.type())
+    {
+        case BasicJsonType::value_t::null:
+        case BasicJsonType::value_t::discarded:
+        {
+            return combine(type, 0);
+        }
+
+        case BasicJsonType::value_t::object:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j.items())
+            {
+                const auto h = std::hash<string_t> {}(element.key());
+                seed = combine(seed, h);
+                seed = combine(seed, hash(element.value()));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::array:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j)
+            {
+                seed = combine(seed, hash(element));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::string:
+        {
+            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::boolean:
+        {
+            const auto h = std::hash<bool> {}(j.template get<bool>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_integer:
+        {
+            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_unsigned:
+        {
+            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_float:
+        {
+            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::binary:
+        {
+            auto seed = combine(type, j.get_binary().size());
+            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
+            seed = combine(seed, h);
+            seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
+            for (const auto byte : j.get_binary())
+            {
+                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
+            }
+            return seed;
+        }
+
+        default:                   // LCOV_EXCL_LINE
+            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            return 0;              // LCOV_EXCL_LINE
+    }
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // generate_n
+#include <array> // array
+#include <cmath> // ldexp
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstdio> // snprintf
+#include <cstring> // memcpy
+#include <iterator> // back_inserter
+#include <limits> // numeric_limits
+#include <string> // char_traits, string
+#include <utility> // make_pair, move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstring> // strlen
+#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
+#include <memory> // shared_ptr, make_shared, addressof
+#include <numeric> // accumulate
+#include <string> // string, char_traits
+#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
+#include <utility> // pair, declval
+
+#ifndef JSON_NO_IO
+    #include <cstdio>   // FILE *
+    #include <istream>  // istream
+#endif                  // JSON_NO_IO
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// the supported input formats
+enum class input_format_t { json, cbor, msgpack, ubjson, bson, bjdata };
+
+////////////////////
+// input adapters //
+////////////////////
+
+#ifndef JSON_NO_IO
+/*!
+Input adapter for stdio file access. This adapter read only 1 byte and do not use any
+ buffer. This adapter is a very low level adapter.
+*/
+class file_input_adapter
+{
+  public:
+    using char_type = char;
+
+    JSON_HEDLEY_NON_NULL(2)
+    explicit file_input_adapter(std::FILE* f) noexcept
+        : m_file(f)
+    {
+        JSON_ASSERT(m_file != nullptr);
+    }
+
+    // make class move-only
+    file_input_adapter(const file_input_adapter&) = delete;
+    file_input_adapter(file_input_adapter&&) noexcept = default;
+    file_input_adapter& operator=(const file_input_adapter&) = delete;
+    file_input_adapter& operator=(file_input_adapter&&) = delete;
+    ~file_input_adapter() = default;
+
+    std::char_traits<char>::int_type get_character() noexcept
+    {
+        return std::fgetc(m_file);
+    }
+
+  private:
+    /// the file pointer to read from
+    std::FILE* m_file;
+};
+
+/*!
+Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
+beginning of input. Does not support changing the underlying std::streambuf
+in mid-input. Maintains underlying std::istream and std::streambuf to support
+subsequent use of standard std::istream operations to process any input
+characters following those used in parsing the JSON input.  Clears the
+std::istream flags; any input errors (e.g., EOF) will be detected by the first
+subsequent call for input from the std::istream.
+*/
+class input_stream_adapter
+{
+  public:
+    using char_type = char;
+
+    ~input_stream_adapter()
+    {
+        // clear stream flags; we use underlying streambuf I/O, do not
+        // maintain ifstream flags, except eof
+        if (is != nullptr)
+        {
+            is->clear(is->rdstate() & std::ios::eofbit);
+        }
+    }
+
+    explicit input_stream_adapter(std::istream& i)
+        : is(&i), sb(i.rdbuf())
+    {}
+
+    // delete because of pointer members
+    input_stream_adapter(const input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&&) = delete;
+
+    input_stream_adapter(input_stream_adapter&& rhs) noexcept
+        : is(rhs.is), sb(rhs.sb)
+    {
+        rhs.is = nullptr;
+        rhs.sb = nullptr;
+    }
+
+    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
+    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
+    // end up as the same value, e.g. 0xFFFFFFFF.
+    std::char_traits<char>::int_type get_character()
+    {
+        auto res = sb->sbumpc();
+        // set eof manually, as we don't use the istream interface.
+        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
+        {
+            is->clear(is->rdstate() | std::ios::eofbit);
+        }
+        return res;
+    }
+
+  private:
+    /// the associated input stream
+    std::istream* is = nullptr;
+    std::streambuf* sb = nullptr;
+};
+#endif  // JSON_NO_IO
+
+// General-purpose iterator-based adapter. It might not be as fast as
+// theoretically possible for some containers, but it is extremely versatile.
+template<typename IteratorType>
+class iterator_input_adapter
+{
+  public:
+    using char_type = typename std::iterator_traits<IteratorType>::value_type;
+
+    iterator_input_adapter(IteratorType first, IteratorType last)
+        : current(std::move(first)), end(std::move(last))
+    {}
+
+    typename char_traits<char_type>::int_type get_character()
+    {
+        if (JSON_HEDLEY_LIKELY(current != end))
+        {
+            auto result = char_traits<char_type>::to_int_type(*current);
+            std::advance(current, 1);
+            return result;
+        }
+
+        return char_traits<char_type>::eof();
+    }
+
+  private:
+    IteratorType current;
+    IteratorType end;
+
+    template<typename BaseInputAdapter, size_t T>
+    friend struct wide_string_input_helper;
+
+    bool empty() const
+    {
+        return current == end;
+    }
+};
+
+template<typename BaseInputAdapter, size_t T>
+struct wide_string_input_helper;
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 4>
+{
+    // UTF-32
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-32 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (wc <= 0xFFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else if (wc <= 0x10FFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 4;
+            }
+            else
+            {
+                // unknown character
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+        }
+    }
+};
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 2>
+{
+    // UTF-16
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-16 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (0xD800 > wc || wc >= 0xE000)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else
+            {
+                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
+                {
+                    const auto wc2 = static_cast<unsigned int>(input.get_character());
+                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
+                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
+                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
+                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
+                    utf8_bytes_filled = 4;
+                }
+                else
+                {
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                    utf8_bytes_filled = 1;
+                }
+            }
+        }
+    }
+};
+
+// Wraps another input adapter to convert wide character types into individual bytes.
+template<typename BaseInputAdapter, typename WideCharType>
+class wide_string_input_adapter
+{
+  public:
+    using char_type = char;
+
+    wide_string_input_adapter(BaseInputAdapter base)
+        : base_adapter(base) {}
+
+    typename std::char_traits<char>::int_type get_character() noexcept
+    {
+        // check if buffer needs to be filled
+        if (utf8_bytes_index == utf8_bytes_filled)
+        {
+            fill_buffer<sizeof(WideCharType)>();
+
+            JSON_ASSERT(utf8_bytes_filled > 0);
+            JSON_ASSERT(utf8_bytes_index == 0);
+        }
+
+        // use buffer
+        JSON_ASSERT(utf8_bytes_filled > 0);
+        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
+        return utf8_bytes[utf8_bytes_index++];
+    }
+
+  private:
+    BaseInputAdapter base_adapter;
+
+    template<size_t T>
+    void fill_buffer()
+    {
+        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
+    }
+
+    /// a buffer for UTF-8 bytes
+    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
+
+    /// index to the utf8_codes array for the next valid byte
+    std::size_t utf8_bytes_index = 0;
+    /// number of valid bytes in the utf8_codes array
+    std::size_t utf8_bytes_filled = 0;
+};
+
+template<typename IteratorType, typename Enable = void>
+struct iterator_input_adapter_factory
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using adapter_type = iterator_input_adapter<iterator_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(std::move(first), std::move(last));
+    }
+};
+
+template<typename T>
+struct is_iterator_of_multibyte
+{
+    using value_type = typename std::iterator_traits<T>::value_type;
+    enum
+    {
+        value = sizeof(value_type) > 1
+    };
+};
+
+template<typename IteratorType>
+struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using base_adapter_type = iterator_input_adapter<iterator_type>;
+    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(base_adapter_type(std::move(first), std::move(last)));
+    }
+};
+
+// General purpose iterator-based input
+template<typename IteratorType>
+typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
+{
+    using factory_type = iterator_input_adapter_factory<IteratorType>;
+    return factory_type::create(first, last);
+}
+
+// Convenience shorthand from container to iterator
+// Enables ADL on begin(container) and end(container)
+// Encloses the using declarations in namespace for not to leak them to outside scope
+
+namespace container_input_adapter_factory_impl
+{
+
+using std::begin;
+using std::end;
+
+template<typename ContainerType, typename Enable = void>
+struct container_input_adapter_factory {};
+
+template<typename ContainerType>
+struct container_input_adapter_factory< ContainerType,
+       void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
+       {
+           using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
+
+           static adapter_type create(const ContainerType& container)
+{
+    return input_adapter(begin(container), end(container));
+}
+       };
+
+}  // namespace container_input_adapter_factory_impl
+
+template<typename ContainerType>
+typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
+{
+    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
+}
+
+#ifndef JSON_NO_IO
+// Special cases with fast paths
+inline file_input_adapter input_adapter(std::FILE* file)
+{
+    return file_input_adapter(file);
+}
+
+inline input_stream_adapter input_adapter(std::istream& stream)
+{
+    return input_stream_adapter(stream);
+}
+
+inline input_stream_adapter input_adapter(std::istream&& stream)
+{
+    return input_stream_adapter(stream);
+}
+#endif  // JSON_NO_IO
+
+using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
+
+// Null-delimited strings, and the like.
+template < typename CharT,
+           typename std::enable_if <
+               std::is_pointer<CharT>::value&&
+               !std::is_array<CharT>::value&&
+               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+               sizeof(typename std::remove_pointer<CharT>::type) == 1,
+               int >::type = 0 >
+contiguous_bytes_input_adapter input_adapter(CharT b)
+{
+    auto length = std::strlen(reinterpret_cast<const char*>(b));
+    const auto* ptr = reinterpret_cast<const char*>(b);
+    return input_adapter(ptr, ptr + length);
+}
+
+template<typename T, std::size_t N>
+auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+{
+    return input_adapter(array, array + N);
+}
+
+// This class only handles inputs of input_buffer_adapter type.
+// It's required so that expressions like {ptr, len} can be implicitly cast
+// to the correct adapter.
+class span_input_adapter
+{
+  public:
+    template < typename CharT,
+               typename std::enable_if <
+                   std::is_pointer<CharT>::value&&
+                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+                   sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                   int >::type = 0 >
+    span_input_adapter(CharT b, std::size_t l)
+        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
+
+    template<class IteratorType,
+             typename std::enable_if<
+                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
+                 int>::type = 0>
+    span_input_adapter(IteratorType first, IteratorType last)
+        : ia(input_adapter(first, last)) {}
+
+    contiguous_bytes_input_adapter&& get()
+    {
+        return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
+    }
+
+  private:
+    contiguous_bytes_input_adapter ia;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef>
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/*!
+@brief SAX interface
+
+This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
+Each function is called in different situations while the input is parsed. The
+boolean return value informs the parser whether to continue processing the
+input.
+*/
+template<typename BasicJsonType>
+struct json_sax
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @brief a null value was read
+    @return whether parsing should proceed
+    */
+    virtual bool null() = 0;
+
+    /*!
+    @brief a boolean value was read
+    @param[in] val  boolean value
+    @return whether parsing should proceed
+    */
+    virtual bool boolean(bool val) = 0;
+
+    /*!
+    @brief an integer number was read
+    @param[in] val  integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_integer(number_integer_t val) = 0;
+
+    /*!
+    @brief an unsigned integer number was read
+    @param[in] val  unsigned integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_unsigned(number_unsigned_t val) = 0;
+
+    /*!
+    @brief a floating-point number was read
+    @param[in] val  floating-point value
+    @param[in] s    raw token value
+    @return whether parsing should proceed
+    */
+    virtual bool number_float(number_float_t val, const string_t& s) = 0;
+
+    /*!
+    @brief a string value was read
+    @param[in] val  string value
+    @return whether parsing should proceed
+    @note It is safe to move the passed string value.
+    */
+    virtual bool string(string_t& val) = 0;
+
+    /*!
+    @brief a binary value was read
+    @param[in] val  binary value
+    @return whether parsing should proceed
+    @note It is safe to move the passed binary value.
+    */
+    virtual bool binary(binary_t& val) = 0;
+
+    /*!
+    @brief the beginning of an object was read
+    @param[in] elements  number of object elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_object(std::size_t elements) = 0;
+
+    /*!
+    @brief an object key was read
+    @param[in] val  object key
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool key(string_t& val) = 0;
+
+    /*!
+    @brief the end of an object was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_object() = 0;
+
+    /*!
+    @brief the beginning of an array was read
+    @param[in] elements  number of array elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_array(std::size_t elements) = 0;
+
+    /*!
+    @brief the end of an array was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_array() = 0;
+
+    /*!
+    @brief a parse error occurred
+    @param[in] position    the position in the input where the error occurs
+    @param[in] last_token  the last read token
+    @param[in] ex          an exception object describing the error
+    @return whether parsing should proceed (must return false)
+    */
+    virtual bool parse_error(std::size_t position,
+                             const std::string& last_token,
+                             const detail::exception& ex) = 0;
+
+    json_sax() = default;
+    json_sax(const json_sax&) = default;
+    json_sax(json_sax&&) noexcept = default;
+    json_sax& operator=(const json_sax&) = default;
+    json_sax& operator=(json_sax&&) noexcept = default;
+    virtual ~json_sax() = default;
+};
+
+namespace detail
+{
+/*!
+@brief SAX implementation to create a JSON value from SAX events
+
+This class implements the @ref json_sax interface and processes the SAX events
+to create a JSON value which makes it basically a DOM parser. The structure or
+hierarchy of the JSON value is managed by the stack `ref_stack` which contains
+a pointer to the respective array or object for each recursion depth.
+
+After successful parsing, the value that is passed by reference to the
+constructor contains the parsed value.
+
+@tparam BasicJsonType  the JSON type
+*/
+template<typename BasicJsonType>
+class json_sax_dom_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @param[in,out] r  reference to a JSON value that is manipulated while
+                       parsing
+    @param[in] allow_exceptions_  whether parse errors yield exceptions
+    */
+    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
+        : root(r), allow_exceptions(allow_exceptions_)
+    {}
+
+    // make class move-only
+    json_sax_dom_parser(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~json_sax_dom_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
+
+        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_object());
+
+        // add null at given key and store the reference for later
+        object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val));
+        return true;
+    }
+
+    bool end_object()
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_object());
+
+        ref_stack.back()->set_parents();
+        ref_stack.pop_back();
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
+
+        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_array());
+
+        ref_stack.back()->set_parents();
+        ref_stack.pop_back();
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+    */
+    template<typename Value>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    BasicJsonType* handle_value(Value&& v)
+    {
+        if (ref_stack.empty())
+        {
+            root = BasicJsonType(std::forward<Value>(v));
+            return &root;
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->emplace_back(std::forward<Value>(v));
+            return &(ref_stack.back()->m_data.m_value.array->back());
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_object());
+        JSON_ASSERT(object_element);
+        *object_element = BasicJsonType(std::forward<Value>(v));
+        return object_element;
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+
+template<typename BasicJsonType>
+class json_sax_dom_callback_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using parser_callback_t = typename BasicJsonType::parser_callback_t;
+    using parse_event_t = typename BasicJsonType::parse_event_t;
+
+    json_sax_dom_callback_parser(BasicJsonType& r,
+                                 const parser_callback_t cb,
+                                 const bool allow_exceptions_ = true)
+        : root(r), callback(cb), allow_exceptions(allow_exceptions_)
+    {
+        keep_stack.push_back(true);
+    }
+
+    // make class move-only
+    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~json_sax_dom_callback_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        // check callback for object start
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::object, true);
+        ref_stack.push_back(val.second);
+
+        // check object limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        BasicJsonType k = BasicJsonType(val);
+
+        // check callback for key
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
+        key_keep_stack.push_back(keep);
+
+        // add discarded value at given key and store the reference for later
+        if (keep && ref_stack.back())
+        {
+            object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
+        }
+
+        return true;
+    }
+
+    bool end_object()
+    {
+        if (ref_stack.back())
+        {
+            if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
+            {
+                // discard object
+                *ref_stack.back() = discarded;
+            }
+            else
+            {
+                ref_stack.back()->set_parents();
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
+        {
+            // remove discarded value
+            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
+            {
+                if (it->is_discarded())
+                {
+                    ref_stack.back()->erase(it);
+                    break;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::array, true);
+        ref_stack.push_back(val.second);
+
+        // check array limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        bool keep = true;
+
+        if (ref_stack.back())
+        {
+            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
+            if (keep)
+            {
+                ref_stack.back()->set_parents();
+            }
+            else
+            {
+                // discard array
+                *ref_stack.back() = discarded;
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        // remove discarded value
+        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->pop_back();
+        }
+
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @param[in] v  value to add to the JSON value we build during parsing
+    @param[in] skip_callback  whether we should skip calling the callback
+               function; this is required after start_array() and
+               start_object() SAX events, because otherwise we would call the
+               callback function with an empty array or object, respectively.
+
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+
+    @return pair of boolean (whether value should be kept) and pointer (to the
+            passed value in the ref_stack hierarchy; nullptr if not kept)
+    */
+    template<typename Value>
+    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
+    {
+        JSON_ASSERT(!keep_stack.empty());
+
+        // do not handle this value if we know it would be added to a discarded
+        // container
+        if (!keep_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // create value
+        auto value = BasicJsonType(std::forward<Value>(v));
+
+        // check callback
+        const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
+
+        // do not handle this value if we just learnt it shall be discarded
+        if (!keep)
+        {
+            return {false, nullptr};
+        }
+
+        if (ref_stack.empty())
+        {
+            root = std::move(value);
+            return {true, & root};
+        }
+
+        // skip this value if we already decided to skip the parent
+        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
+        if (!ref_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // we now only expect arrays and objects
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        // array
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
+            return {true, & (ref_stack.back()->m_data.m_value.array->back())};
+        }
+
+        // object
+        JSON_ASSERT(ref_stack.back()->is_object());
+        // check if we should store an element for the current key
+        JSON_ASSERT(!key_keep_stack.empty());
+        const bool store_element = key_keep_stack.back();
+        key_keep_stack.pop_back();
+
+        if (!store_element)
+        {
+            return {false, nullptr};
+        }
+
+        JSON_ASSERT(object_element);
+        *object_element = std::move(value);
+        return {true, object_element};
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// stack to manage which values to keep
+    std::vector<bool> keep_stack {};
+    /// stack to manage which object keys to keep
+    std::vector<bool> key_keep_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+    /// a discarded value for the callback
+    BasicJsonType discarded = BasicJsonType::value_t::discarded;
+};
+
+template<typename BasicJsonType>
+class json_sax_acceptor
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    bool null()
+    {
+        return true;
+    }
+
+    bool boolean(bool /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_integer(number_integer_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool string(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool binary(binary_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
+    {
+        return true;
+    }
+
+    bool key(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool end_object()
+    {
+        return true;
+    }
+
+    bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
+    {
+        return true;
+    }
+
+    bool end_array()
+    {
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
+    {
+        return false;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/lexer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <clocale> // localeconv
+#include <cstddef> // size_t
+#include <cstdio> // snprintf
+#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
+#include <initializer_list> // initializer_list
+#include <string> // char_traits, string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////
+// lexer //
+///////////
+
+template<typename BasicJsonType>
+class lexer_base
+{
+  public:
+    /// token types for the parser
+    enum class token_type
+    {
+        uninitialized,    ///< indicating the scanner is uninitialized
+        literal_true,     ///< the `true` literal
+        literal_false,    ///< the `false` literal
+        literal_null,     ///< the `null` literal
+        value_string,     ///< a string -- use get_string() for actual value
+        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
+        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
+        value_float,      ///< an floating point number -- use get_number_float() for actual value
+        begin_array,      ///< the character for array begin `[`
+        begin_object,     ///< the character for object begin `{`
+        end_array,        ///< the character for array end `]`
+        end_object,       ///< the character for object end `}`
+        name_separator,   ///< the name separator `:`
+        value_separator,  ///< the value separator `,`
+        parse_error,      ///< indicating a parse error
+        end_of_input,     ///< indicating the end of the input buffer
+        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
+    };
+
+    /// return name of values of type token_type (only used for errors)
+    JSON_HEDLEY_RETURNS_NON_NULL
+    JSON_HEDLEY_CONST
+    static const char* token_type_name(const token_type t) noexcept
+    {
+        switch (t)
+        {
+            case token_type::uninitialized:
+                return "<uninitialized>";
+            case token_type::literal_true:
+                return "true literal";
+            case token_type::literal_false:
+                return "false literal";
+            case token_type::literal_null:
+                return "null literal";
+            case token_type::value_string:
+                return "string literal";
+            case token_type::value_unsigned:
+            case token_type::value_integer:
+            case token_type::value_float:
+                return "number literal";
+            case token_type::begin_array:
+                return "'['";
+            case token_type::begin_object:
+                return "'{'";
+            case token_type::end_array:
+                return "']'";
+            case token_type::end_object:
+                return "'}'";
+            case token_type::name_separator:
+                return "':'";
+            case token_type::value_separator:
+                return "','";
+            case token_type::parse_error:
+                return "<parse error>";
+            case token_type::end_of_input:
+                return "end of input";
+            case token_type::literal_or_value:
+                return "'[', '{', or a literal";
+            // LCOV_EXCL_START
+            default: // catch non-enum values
+                return "unknown token";
+                // LCOV_EXCL_STOP
+        }
+    }
+};
+/*!
+@brief lexical analysis
+
+This class organizes the lexical analysis during JSON deserialization.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class lexer : public lexer_base<BasicJsonType>
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename char_traits<char_type>::int_type;
+
+  public:
+    using token_type = typename lexer_base<BasicJsonType>::token_type;
+
+    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
+        : ia(std::move(adapter))
+        , ignore_comments(ignore_comments_)
+        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
+    {}
+
+    // delete because of pointer members
+    lexer(const lexer&) = delete;
+    lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    lexer& operator=(lexer&) = delete;
+    lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~lexer() = default;
+
+  private:
+    /////////////////////
+    // locales
+    /////////////////////
+
+    /// return the locale-dependent decimal point
+    JSON_HEDLEY_PURE
+    static char get_decimal_point() noexcept
+    {
+        const auto* loc = localeconv();
+        JSON_ASSERT(loc != nullptr);
+        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
+    }
+
+    /////////////////////
+    // scan functions
+    /////////////////////
+
+    /*!
+    @brief get codepoint from 4 hex characters following `\u`
+
+    For input "\u c1 c2 c3 c4" the codepoint is:
+      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
+    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
+
+    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
+    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
+    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
+    between the ASCII value of the character and the desired integer value.
+
+    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
+            non-hex character)
+    */
+    int get_codepoint()
+    {
+        // this function only makes sense after reading `\u`
+        JSON_ASSERT(current == 'u');
+        int codepoint = 0;
+
+        const auto factors = { 12u, 8u, 4u, 0u };
+        for (const auto factor : factors)
+        {
+            get();
+
+            if (current >= '0' && current <= '9')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
+            }
+            else if (current >= 'A' && current <= 'F')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
+            }
+            else if (current >= 'a' && current <= 'f')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
+        return codepoint;
+    }
+
+    /*!
+    @brief check if the next byte(s) are inside a given range
+
+    Adds the current byte and, for each passed range, reads a new byte and
+    checks if it is inside the range. If a violation was detected, set up an
+    error message and return false. Otherwise, return true.
+
+    @param[in] ranges  list of integers; interpreted as list of pairs of
+                       inclusive lower and upper bound, respectively
+
+    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
+         1, 2, or 3 pairs. This precondition is enforced by an assertion.
+
+    @return true if and only if no range violation was detected
+    */
+    bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
+    {
+        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
+        add(current);
+
+        for (auto range = ranges.begin(); range != ranges.end(); ++range)
+        {
+            get();
+            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
+            {
+                add(current);
+            }
+            else
+            {
+                error_message = "invalid string: ill-formed UTF-8 byte";
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief scan a string literal
+
+    This function scans a string according to Sect. 7 of RFC 8259. While
+    scanning, bytes are escaped and copied into buffer token_buffer. Then the
+    function returns successfully, token_buffer is *not* null-terminated (as it
+    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
+    string.
+
+    @return token_type::value_string if string could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note In case of errors, variable error_message contains a textual
+          description.
+    */
+    token_type scan_string()
+    {
+        // reset token_buffer (ignore opening quote)
+        reset();
+
+        // we entered the function by reading an open quote
+        JSON_ASSERT(current == '\"');
+
+        while (true)
+        {
+            // get next character
+            switch (get())
+            {
+                // end of file while parsing string
+                case char_traits<char_type>::eof():
+                {
+                    error_message = "invalid string: missing closing quote";
+                    return token_type::parse_error;
+                }
+
+                // closing quote
+                case '\"':
+                {
+                    return token_type::value_string;
+                }
+
+                // escapes
+                case '\\':
+                {
+                    switch (get())
+                    {
+                        // quotation mark
+                        case '\"':
+                            add('\"');
+                            break;
+                        // reverse solidus
+                        case '\\':
+                            add('\\');
+                            break;
+                        // solidus
+                        case '/':
+                            add('/');
+                            break;
+                        // backspace
+                        case 'b':
+                            add('\b');
+                            break;
+                        // form feed
+                        case 'f':
+                            add('\f');
+                            break;
+                        // line feed
+                        case 'n':
+                            add('\n');
+                            break;
+                        // carriage return
+                        case 'r':
+                            add('\r');
+                            break;
+                        // tab
+                        case 't':
+                            add('\t');
+                            break;
+
+                        // unicode escapes
+                        case 'u':
+                        {
+                            const int codepoint1 = get_codepoint();
+                            int codepoint = codepoint1; // start with codepoint1
+
+                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
+                            {
+                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                return token_type::parse_error;
+                            }
+
+                            // check if code point is a high surrogate
+                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
+                            {
+                                // expect next \uxxxx entry
+                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
+                                {
+                                    const int codepoint2 = get_codepoint();
+
+                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
+                                    {
+                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                        return token_type::parse_error;
+                                    }
+
+                                    // check if codepoint2 is a low surrogate
+                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
+                                    {
+                                        // overwrite codepoint
+                                        codepoint = static_cast<int>(
+                                                        // high surrogate occupies the most significant 22 bits
+                                                        (static_cast<unsigned int>(codepoint1) << 10u)
+                                                        // low surrogate occupies the least significant 15 bits
+                                                        + static_cast<unsigned int>(codepoint2)
+                                                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
+                                                        // in the result, so we have to subtract with:
+                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                                                        - 0x35FDC00u);
+                                    }
+                                    else
+                                    {
+                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                        return token_type::parse_error;
+                                    }
+                                }
+                                else
+                                {
+                                    error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+                            else
+                            {
+                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
+                                {
+                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+
+                            // result of the above calculation yields a proper codepoint
+                            JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
+
+                            // translate codepoint into bytes
+                            if (codepoint < 0x80)
+                            {
+                                // 1-byte characters: 0xxxxxxx (ASCII)
+                                add(static_cast<char_int_type>(codepoint));
+                            }
+                            else if (codepoint <= 0x7FF)
+                            {
+                                // 2-byte characters: 110xxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else if (codepoint <= 0xFFFF)
+                            {
+                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else
+                            {
+                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+
+                            break;
+                        }
+
+                        // other characters after escape
+                        default:
+                            error_message = "invalid string: forbidden character after backslash";
+                            return token_type::parse_error;
+                    }
+
+                    break;
+                }
+
+                // invalid control characters
+                case 0x00:
+                {
+                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
+                    return token_type::parse_error;
+                }
+
+                case 0x01:
+                {
+                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
+                    return token_type::parse_error;
+                }
+
+                case 0x02:
+                {
+                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
+                    return token_type::parse_error;
+                }
+
+                case 0x03:
+                {
+                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
+                    return token_type::parse_error;
+                }
+
+                case 0x04:
+                {
+                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
+                    return token_type::parse_error;
+                }
+
+                case 0x05:
+                {
+                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
+                    return token_type::parse_error;
+                }
+
+                case 0x06:
+                {
+                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
+                    return token_type::parse_error;
+                }
+
+                case 0x07:
+                {
+                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
+                    return token_type::parse_error;
+                }
+
+                case 0x08:
+                {
+                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
+                    return token_type::parse_error;
+                }
+
+                case 0x09:
+                {
+                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
+                    return token_type::parse_error;
+                }
+
+                case 0x0A:
+                {
+                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
+                    return token_type::parse_error;
+                }
+
+                case 0x0B:
+                {
+                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
+                    return token_type::parse_error;
+                }
+
+                case 0x0C:
+                {
+                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
+                    return token_type::parse_error;
+                }
+
+                case 0x0D:
+                {
+                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
+                    return token_type::parse_error;
+                }
+
+                case 0x0E:
+                {
+                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
+                    return token_type::parse_error;
+                }
+
+                case 0x0F:
+                {
+                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
+                    return token_type::parse_error;
+                }
+
+                case 0x10:
+                {
+                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
+                    return token_type::parse_error;
+                }
+
+                case 0x11:
+                {
+                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
+                    return token_type::parse_error;
+                }
+
+                case 0x12:
+                {
+                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
+                    return token_type::parse_error;
+                }
+
+                case 0x13:
+                {
+                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
+                    return token_type::parse_error;
+                }
+
+                case 0x14:
+                {
+                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
+                    return token_type::parse_error;
+                }
+
+                case 0x15:
+                {
+                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
+                    return token_type::parse_error;
+                }
+
+                case 0x16:
+                {
+                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
+                    return token_type::parse_error;
+                }
+
+                case 0x17:
+                {
+                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
+                    return token_type::parse_error;
+                }
+
+                case 0x18:
+                {
+                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
+                    return token_type::parse_error;
+                }
+
+                case 0x19:
+                {
+                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
+                    return token_type::parse_error;
+                }
+
+                case 0x1A:
+                {
+                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
+                    return token_type::parse_error;
+                }
+
+                case 0x1B:
+                {
+                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
+                    return token_type::parse_error;
+                }
+
+                case 0x1C:
+                {
+                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
+                    return token_type::parse_error;
+                }
+
+                case 0x1D:
+                {
+                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
+                    return token_type::parse_error;
+                }
+
+                case 0x1E:
+                {
+                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
+                    return token_type::parse_error;
+                }
+
+                case 0x1F:
+                {
+                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
+                    return token_type::parse_error;
+                }
+
+                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
+                case 0x20:
+                case 0x21:
+                case 0x23:
+                case 0x24:
+                case 0x25:
+                case 0x26:
+                case 0x27:
+                case 0x28:
+                case 0x29:
+                case 0x2A:
+                case 0x2B:
+                case 0x2C:
+                case 0x2D:
+                case 0x2E:
+                case 0x2F:
+                case 0x30:
+                case 0x31:
+                case 0x32:
+                case 0x33:
+                case 0x34:
+                case 0x35:
+                case 0x36:
+                case 0x37:
+                case 0x38:
+                case 0x39:
+                case 0x3A:
+                case 0x3B:
+                case 0x3C:
+                case 0x3D:
+                case 0x3E:
+                case 0x3F:
+                case 0x40:
+                case 0x41:
+                case 0x42:
+                case 0x43:
+                case 0x44:
+                case 0x45:
+                case 0x46:
+                case 0x47:
+                case 0x48:
+                case 0x49:
+                case 0x4A:
+                case 0x4B:
+                case 0x4C:
+                case 0x4D:
+                case 0x4E:
+                case 0x4F:
+                case 0x50:
+                case 0x51:
+                case 0x52:
+                case 0x53:
+                case 0x54:
+                case 0x55:
+                case 0x56:
+                case 0x57:
+                case 0x58:
+                case 0x59:
+                case 0x5A:
+                case 0x5B:
+                case 0x5D:
+                case 0x5E:
+                case 0x5F:
+                case 0x60:
+                case 0x61:
+                case 0x62:
+                case 0x63:
+                case 0x64:
+                case 0x65:
+                case 0x66:
+                case 0x67:
+                case 0x68:
+                case 0x69:
+                case 0x6A:
+                case 0x6B:
+                case 0x6C:
+                case 0x6D:
+                case 0x6E:
+                case 0x6F:
+                case 0x70:
+                case 0x71:
+                case 0x72:
+                case 0x73:
+                case 0x74:
+                case 0x75:
+                case 0x76:
+                case 0x77:
+                case 0x78:
+                case 0x79:
+                case 0x7A:
+                case 0x7B:
+                case 0x7C:
+                case 0x7D:
+                case 0x7E:
+                case 0x7F:
+                {
+                    add(current);
+                    break;
+                }
+
+                // U+0080..U+07FF: bytes C2..DF 80..BF
+                case 0xC2:
+                case 0xC3:
+                case 0xC4:
+                case 0xC5:
+                case 0xC6:
+                case 0xC7:
+                case 0xC8:
+                case 0xC9:
+                case 0xCA:
+                case 0xCB:
+                case 0xCC:
+                case 0xCD:
+                case 0xCE:
+                case 0xCF:
+                case 0xD0:
+                case 0xD1:
+                case 0xD2:
+                case 0xD3:
+                case 0xD4:
+                case 0xD5:
+                case 0xD6:
+                case 0xD7:
+                case 0xD8:
+                case 0xD9:
+                case 0xDA:
+                case 0xDB:
+                case 0xDC:
+                case 0xDD:
+                case 0xDE:
+                case 0xDF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
+                case 0xE0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
+                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
+                case 0xE1:
+                case 0xE2:
+                case 0xE3:
+                case 0xE4:
+                case 0xE5:
+                case 0xE6:
+                case 0xE7:
+                case 0xE8:
+                case 0xE9:
+                case 0xEA:
+                case 0xEB:
+                case 0xEC:
+                case 0xEE:
+                case 0xEF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
+                case 0xED:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
+                case 0xF0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
+                case 0xF1:
+                case 0xF2:
+                case 0xF3:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
+                case 0xF4:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // remaining bytes (80..C1 and F5..FF) are ill-formed
+                default:
+                {
+                    error_message = "invalid string: ill-formed UTF-8 byte";
+                    return token_type::parse_error;
+                }
+            }
+        }
+    }
+
+    /*!
+     * @brief scan a comment
+     * @return whether comment could be scanned successfully
+     */
+    bool scan_comment()
+    {
+        switch (get())
+        {
+            // single-line comments skip input until a newline or EOF is read
+            case '/':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case '\n':
+                        case '\r':
+                        case char_traits<char_type>::eof():
+                        case '\0':
+                            return true;
+
+                        default:
+                            break;
+                    }
+                }
+            }
+
+            // multi-line comments skip input until */ is read
+            case '*':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case char_traits<char_type>::eof():
+                        case '\0':
+                        {
+                            error_message = "invalid comment; missing closing '*/'";
+                            return false;
+                        }
+
+                        case '*':
+                        {
+                            switch (get())
+                            {
+                                case '/':
+                                    return true;
+
+                                default:
+                                {
+                                    unget();
+                                    continue;
+                                }
+                            }
+                        }
+
+                        default:
+                            continue;
+                    }
+                }
+            }
+
+            // unexpected character after reading '/'
+            default:
+            {
+                error_message = "invalid comment; expecting '/' or '*' after '/'";
+                return false;
+            }
+        }
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(float& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtof(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtod(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(long double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtold(str, endptr);
+    }
+
+    /*!
+    @brief scan a number literal
+
+    This function scans a string according to Sect. 6 of RFC 8259.
+
+    The function is realized with a deterministic finite state machine derived
+    from the grammar described in RFC 8259. Starting in state "init", the
+    input is read and used to determined the next state. Only state "done"
+    accepts the number. State "error" is a trap state to model errors. In the
+    table below, "anything" means any character but the ones listed before.
+
+    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
+    ---------|----------|----------|----------|---------|---------|----------|-----------
+    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
+    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
+    zero     | done     | done     | exponent | done    | done    | decimal1 | done
+    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
+    decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]
+    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
+    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
+    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
+    any2     | any2     | any2     | done     | done    | done    | done     | done
+
+    The state machine is realized with one label per state (prefixed with
+    "scan_number_") and `goto` statements between them. The state machine
+    contains cycles, but any cycle can be left when EOF is read. Therefore,
+    the function is guaranteed to terminate.
+
+    During scanning, the read bytes are stored in token_buffer. This string is
+    then converted to a signed integer, an unsigned integer, or a
+    floating-point number.
+
+    @return token_type::value_unsigned, token_type::value_integer, or
+            token_type::value_float if number could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note The scanner is independent of the current locale. Internally, the
+          locale's decimal point is used instead of `.` to work with the
+          locale-dependent converters.
+    */
+    token_type scan_number()  // lgtm [cpp/use-of-goto]
+    {
+        // reset token_buffer to store the number's bytes
+        reset();
+
+        // the type of the parsed number; initially set to unsigned; will be
+        // changed if minus sign, decimal point or exponent is read
+        token_type number_type = token_type::value_unsigned;
+
+        // state (init): we just found out we need to scan a number
+        switch (current)
+        {
+            case '-':
+            {
+                add(current);
+                goto scan_number_minus;
+            }
+
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            // all other characters are rejected outside scan_number()
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+scan_number_minus:
+        // state: we just parsed a leading minus sign
+        number_type = token_type::value_integer;
+        switch (get())
+        {
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '-'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_zero:
+        // state: we just parse a zero (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_any1:
+        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_decimal1:
+        // state: we just parsed a decimal point
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '.'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_decimal2:
+        // we just parsed at least one number after a decimal point
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_exponent:
+        // we just parsed an exponent
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '+':
+            case '-':
+            {
+                add(current);
+                goto scan_number_sign;
+            }
+
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message =
+                    "invalid number; expected '+', '-', or digit after exponent";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_sign:
+        // we just parsed an exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after exponent sign";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_any2:
+        // we just parsed a number after the exponent or exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_done:
+        // unget the character after the number (we only read it to know that
+        // we are done scanning a number)
+        unget();
+
+        char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        errno = 0;
+
+        // try to parse integers first and fall back to floats
+        if (number_type == token_type::value_unsigned)
+        {
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_unsigned = static_cast<number_unsigned_t>(x);
+                if (value_unsigned == x)
+                {
+                    return token_type::value_unsigned;
+                }
+            }
+        }
+        else if (number_type == token_type::value_integer)
+        {
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_integer = static_cast<number_integer_t>(x);
+                if (value_integer == x)
+                {
+                    return token_type::value_integer;
+                }
+            }
+        }
+
+        // this code is reached if we parse a floating-point number or if an
+        // integer conversion above failed
+        strtof(value_float, token_buffer.data(), &endptr);
+
+        // we checked the number format before
+        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+        return token_type::value_float;
+    }
+
+    /*!
+    @param[in] literal_text  the literal text to expect
+    @param[in] length        the length of the passed literal text
+    @param[in] return_type   the token type to return on success
+    */
+    JSON_HEDLEY_NON_NULL(2)
+    token_type scan_literal(const char_type* literal_text, const std::size_t length,
+                            token_type return_type)
+    {
+        JSON_ASSERT(char_traits<char_type>::to_char_type(current) == literal_text[0]);
+        for (std::size_t i = 1; i < length; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(char_traits<char_type>::to_char_type(get()) != literal_text[i]))
+            {
+                error_message = "invalid literal";
+                return token_type::parse_error;
+            }
+        }
+        return return_type;
+    }
+
+    /////////////////////
+    // input management
+    /////////////////////
+
+    /// reset token_buffer; current character is beginning of token
+    void reset() noexcept
+    {
+        token_buffer.clear();
+        token_string.clear();
+        token_string.push_back(char_traits<char_type>::to_char_type(current));
+    }
+
+    /*
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a
+    `char_traits<char>::eof()` in that case.  Stores the scanned characters
+    for use in error messages.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++position.chars_read_total;
+        ++position.chars_read_current_line;
+
+        if (next_unget)
+        {
+            // just reset the next_unget variable and work with current
+            next_unget = false;
+        }
+        else
+        {
+            current = ia.get_character();
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
+        {
+            token_string.push_back(char_traits<char_type>::to_char_type(current));
+        }
+
+        if (current == '\n')
+        {
+            ++position.lines_read;
+            position.chars_read_current_line = 0;
+        }
+
+        return current;
+    }
+
+    /*!
+    @brief unget current character (read it again on next get)
+
+    We implement unget by setting variable next_unget to true. The input is not
+    changed - we just simulate ungetting by modifying chars_read_total,
+    chars_read_current_line, and token_string. The next call to get() will
+    behave as if the unget character is read again.
+    */
+    void unget()
+    {
+        next_unget = true;
+
+        --position.chars_read_total;
+
+        // in case we "unget" a newline, we have to also decrement the lines_read
+        if (position.chars_read_current_line == 0)
+        {
+            if (position.lines_read > 0)
+            {
+                --position.lines_read;
+            }
+        }
+        else
+        {
+            --position.chars_read_current_line;
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
+        {
+            JSON_ASSERT(!token_string.empty());
+            token_string.pop_back();
+        }
+    }
+
+    /// add a character to token_buffer
+    void add(char_int_type c)
+    {
+        token_buffer.push_back(static_cast<typename string_t::value_type>(c));
+    }
+
+  public:
+    /////////////////////
+    // value getters
+    /////////////////////
+
+    /// return integer value
+    constexpr number_integer_t get_number_integer() const noexcept
+    {
+        return value_integer;
+    }
+
+    /// return unsigned integer value
+    constexpr number_unsigned_t get_number_unsigned() const noexcept
+    {
+        return value_unsigned;
+    }
+
+    /// return floating-point value
+    constexpr number_float_t get_number_float() const noexcept
+    {
+        return value_float;
+    }
+
+    /// return current string value (implicitly resets the token; useful only once)
+    string_t& get_string()
+    {
+        return token_buffer;
+    }
+
+    /////////////////////
+    // diagnostics
+    /////////////////////
+
+    /// return position of last read token
+    constexpr position_t get_position() const noexcept
+    {
+        return position;
+    }
+
+    /// return the last read token (for errors only).  Will never contain EOF
+    /// (an arbitrary value that is not a valid char value, often -1), because
+    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
+    std::string get_token_string() const
+    {
+        // escape control characters
+        std::string result;
+        for (const auto c : token_string)
+        {
+            if (static_cast<unsigned char>(c) <= '\x1F')
+            {
+                // escape control characters
+                std::array<char, 9> cs{{}};
+                static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                result += cs.data();
+            }
+            else
+            {
+                // add character as is
+                result.push_back(static_cast<std::string::value_type>(c));
+            }
+        }
+
+        return result;
+    }
+
+    /// return syntax error message
+    JSON_HEDLEY_RETURNS_NON_NULL
+    constexpr const char* get_error_message() const noexcept
+    {
+        return error_message;
+    }
+
+    /////////////////////
+    // actual scanner
+    /////////////////////
+
+    /*!
+    @brief skip the UTF-8 byte order mark
+    @return true iff there is no BOM or the correct BOM has been skipped
+    */
+    bool skip_bom()
+    {
+        if (get() == 0xEF)
+        {
+            // check if we completely parse the BOM
+            return get() == 0xBB && get() == 0xBF;
+        }
+
+        // the first character is not the beginning of the BOM; unget it to
+        // process is later
+        unget();
+        return true;
+    }
+
+    void skip_whitespace()
+    {
+        do
+        {
+            get();
+        }
+        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
+    }
+
+    token_type scan()
+    {
+        // initially, skip the BOM
+        if (position.chars_read_total == 0 && !skip_bom())
+        {
+            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
+            return token_type::parse_error;
+        }
+
+        // read next character and ignore whitespace
+        skip_whitespace();
+
+        // ignore comments
+        while (ignore_comments && current == '/')
+        {
+            if (!scan_comment())
+            {
+                return token_type::parse_error;
+            }
+
+            // skip following whitespace
+            skip_whitespace();
+        }
+
+        switch (current)
+        {
+            // structural characters
+            case '[':
+                return token_type::begin_array;
+            case ']':
+                return token_type::end_array;
+            case '{':
+                return token_type::begin_object;
+            case '}':
+                return token_type::end_object;
+            case ':':
+                return token_type::name_separator;
+            case ',':
+                return token_type::value_separator;
+
+            // literals
+            case 't':
+            {
+                std::array<char_type, 4> true_literal = {{static_cast<char_type>('t'), static_cast<char_type>('r'), static_cast<char_type>('u'), static_cast<char_type>('e')}};
+                return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
+            }
+            case 'f':
+            {
+                std::array<char_type, 5> false_literal = {{static_cast<char_type>('f'), static_cast<char_type>('a'), static_cast<char_type>('l'), static_cast<char_type>('s'), static_cast<char_type>('e')}};
+                return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
+            }
+            case 'n':
+            {
+                std::array<char_type, 4> null_literal = {{static_cast<char_type>('n'), static_cast<char_type>('u'), static_cast<char_type>('l'), static_cast<char_type>('l')}};
+                return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
+            }
+
+            // string
+            case '\"':
+                return scan_string();
+
+            // number
+            case '-':
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                return scan_number();
+
+            // end of input (the null byte is needed when parsing from
+            // string literals)
+            case '\0':
+            case char_traits<char_type>::eof():
+                return token_type::end_of_input;
+
+            // error
+            default:
+                error_message = "invalid literal";
+                return token_type::parse_error;
+        }
+    }
+
+  private:
+    /// input adapter
+    InputAdapterType ia;
+
+    /// whether comments should be ignored (true) or signaled as errors (false)
+    const bool ignore_comments = false;
+
+    /// the current character
+    char_int_type current = char_traits<char_type>::eof();
+
+    /// whether the next get() call should just return current
+    bool next_unget = false;
+
+    /// the start position of the current token
+    position_t position {};
+
+    /// raw input token string (for error messages)
+    std::vector<char_type> token_string {};
+
+    /// buffer for variable-length tokens (numbers, strings)
+    string_t token_buffer {};
+
+    /// a description of occurred lexer errors
+    const char* error_message = "";
+
+    // number values
+    number_integer_t value_integer = 0;
+    number_unsigned_t value_unsigned = 0;
+    number_float_t value_float = 0;
+
+    /// the decimal point
+    const char_int_type decimal_point_char = '.';
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstdint> // size_t
+#include <utility> // declval
+#include <string> // string
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename T>
+using null_function_t = decltype(std::declval<T&>().null());
+
+template<typename T>
+using boolean_function_t =
+    decltype(std::declval<T&>().boolean(std::declval<bool>()));
+
+template<typename T, typename Integer>
+using number_integer_function_t =
+    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
+
+template<typename T, typename Unsigned>
+using number_unsigned_function_t =
+    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
+
+template<typename T, typename Float, typename String>
+using number_float_function_t = decltype(std::declval<T&>().number_float(
+                                    std::declval<Float>(), std::declval<const String&>()));
+
+template<typename T, typename String>
+using string_function_t =
+    decltype(std::declval<T&>().string(std::declval<String&>()));
+
+template<typename T, typename Binary>
+using binary_function_t =
+    decltype(std::declval<T&>().binary(std::declval<Binary&>()));
+
+template<typename T>
+using start_object_function_t =
+    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
+
+template<typename T, typename String>
+using key_function_t =
+    decltype(std::declval<T&>().key(std::declval<String&>()));
+
+template<typename T>
+using end_object_function_t = decltype(std::declval<T&>().end_object());
+
+template<typename T>
+using start_array_function_t =
+    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
+
+template<typename T>
+using end_array_function_t = decltype(std::declval<T&>().end_array());
+
+template<typename T, typename Exception>
+using parse_error_function_t = decltype(std::declval<T&>().parse_error(
+        std::declval<std::size_t>(), std::declval<const std::string&>(),
+        std::declval<const Exception&>()));
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static constexpr bool value =
+        is_detected_exact<bool, null_function_t, SAX>::value &&
+        is_detected_exact<bool, boolean_function_t, SAX>::value &&
+        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
+        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
+        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
+        is_detected_exact<bool, start_object_function_t, SAX>::value &&
+        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, end_object_function_t, SAX>::value &&
+        is_detected_exact<bool, start_array_function_t, SAX>::value &&
+        is_detected_exact<bool, end_array_function_t, SAX>::value &&
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
+};
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax_static_asserts
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
+                  "Missing/invalid function: bool null()");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(
+        is_detected_exact<bool, number_integer_function_t, SAX,
+        number_integer_t>::value,
+        "Missing/invalid function: bool number_integer(number_integer_t)");
+    static_assert(
+        is_detected_exact<bool, number_unsigned_function_t, SAX,
+        number_unsigned_t>::value,
+        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
+    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
+                  number_float_t, string_t>::value,
+                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
+    static_assert(
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
+        "Missing/invalid function: bool string(string_t&)");
+    static_assert(
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
+        "Missing/invalid function: bool binary(binary_t&)");
+    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_object(std::size_t)");
+    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
+                  "Missing/invalid function: bool key(string_t&)");
+    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_object()");
+    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_array(std::size_t)");
+    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_array()");
+    static_assert(
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
+        "Missing/invalid function: bool parse_error(std::size_t, const "
+        "std::string&, const exception&)");
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// how to treat CBOR tags
+enum class cbor_tag_handler_t
+{
+    error,   ///< throw a parse_error exception in case of a tag
+    ignore,  ///< ignore tags
+    store    ///< store tags as binary type
+};
+
+/*!
+@brief determine system byte order
+
+@return true if and only if system's byte order is little endian
+
+@note from https://stackoverflow.com/a/1001328/266378
+*/
+static inline bool little_endianness(int num = 1) noexcept
+{
+    return *reinterpret_cast<char*>(&num) == 1;
+}
+
+///////////////////
+// binary reader //
+///////////////////
+
+/*!
+@brief deserialization of CBOR, MessagePack, and UBJSON values
+*/
+template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
+class binary_reader
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using json_sax_t = SAX;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename char_traits<char_type>::int_type;
+
+  public:
+    /*!
+    @brief create a binary reader
+
+    @param[in] adapter  input adapter to read from
+    */
+    explicit binary_reader(InputAdapterType&& adapter, const input_format_t format = input_format_t::json) noexcept : ia(std::move(adapter)), input_format(format)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+    }
+
+    // make class move-only
+    binary_reader(const binary_reader&) = delete;
+    binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    binary_reader& operator=(const binary_reader&) = delete;
+    binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~binary_reader() = default;
+
+    /*!
+    @param[in] format  the binary format to parse
+    @param[in] sax_    a SAX event processor
+    @param[in] strict  whether to expect the input to be consumed completed
+    @param[in] tag_handler  how to treat CBOR tags
+
+    @return whether parsing was successful
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool sax_parse(const input_format_t format,
+                   json_sax_t* sax_,
+                   const bool strict = true,
+                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        sax = sax_;
+        bool result = false;
+
+        switch (format)
+        {
+            case input_format_t::bson:
+                result = parse_bson_internal();
+                break;
+
+            case input_format_t::cbor:
+                result = parse_cbor_internal(true, tag_handler);
+                break;
+
+            case input_format_t::msgpack:
+                result = parse_msgpack_internal();
+                break;
+
+            case input_format_t::ubjson:
+            case input_format_t::bjdata:
+                result = parse_ubjson_internal();
+                break;
+
+            case input_format_t::json: // LCOV_EXCL_LINE
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+        // strict mode: next byte must be EOF
+        if (result && strict)
+        {
+            if (input_format == input_format_t::ubjson || input_format == input_format_t::bjdata)
+            {
+                get_ignore_noop();
+            }
+            else
+            {
+                get();
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(current != char_traits<char_type>::eof()))
+            {
+                return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read,
+                                        exception_message(input_format, concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr));
+            }
+        }
+
+        return result;
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @brief Reads in a BSON-object and passes it to the SAX-parser.
+    @return whether a valid BSON-value was passed to the SAX parser
+    */
+    bool parse_bson_internal()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
+        {
+            return false;
+        }
+
+        return sax->end_object();
+    }
+
+    /*!
+    @brief Parses a C-style string from the BSON input.
+    @param[in,out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @return `true` if the \x00-byte indicating the end of the string was
+             encountered before the EOF; false` indicates an unexpected EOF.
+    */
+    bool get_bson_cstr(string_t& result)
+    {
+        auto out = std::back_inserter(result);
+        while (true)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
+            {
+                return false;
+            }
+            if (current == 0x00)
+            {
+                return true;
+            }
+            *out++ = static_cast<typename string_t::value_type>(current);
+        }
+    }
+
+    /*!
+    @brief Parses a zero-terminated string of length @a len from the BSON
+           input.
+    @param[in] len  The length (including the zero-byte at the end) of the
+                    string to be read.
+    @param[in,out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 1
+    @return `true` if the string was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_string(const NumberType len, string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 1))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr));
+        }
+
+        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != char_traits<char_type>::eof();
+    }
+
+    /*!
+    @brief Parses a byte array input of length @a len from the BSON input.
+    @param[in] len  The length of the byte array to be read.
+    @param[in,out] result  A reference to the binary variable where the read
+                            array is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 0
+    @return `true` if the byte array was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_binary(const NumberType len, binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 0))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr));
+        }
+
+        // All BSON binary values have a subtype
+        std::uint8_t subtype{};
+        get_number<std::uint8_t>(input_format_t::bson, subtype);
+        result.set_subtype(subtype);
+
+        return get_binary(input_format_t::bson, len, result);
+    }
+
+    /*!
+    @brief Read a BSON document element of the given @a element_type.
+    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
+    @param[in] element_type_parse_position The position in the input stream,
+               where the `element_type` was read.
+    @warning Not all BSON element types are supported yet. An unsupported
+             @a element_type will give rise to a parse_error.114:
+             Unsupported BSON record type 0x...
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_internal(const char_int_type element_type,
+                                     const std::size_t element_type_parse_position)
+    {
+        switch (element_type)
+        {
+            case 0x01: // double
+            {
+                double number{};
+                return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0x02: // string
+            {
+                std::int32_t len{};
+                string_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
+            }
+
+            case 0x03: // object
+            {
+                return parse_bson_internal();
+            }
+
+            case 0x04: // array
+            {
+                return parse_bson_array();
+            }
+
+            case 0x05: // binary
+            {
+                std::int32_t len{};
+                binary_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
+            }
+
+            case 0x08: // boolean
+            {
+                return sax->boolean(get() != 0);
+            }
+
+            case 0x0A: // null
+            {
+                return sax->null();
+            }
+
+            case 0x10: // int32
+            {
+                std::int32_t value{};
+                return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            case 0x12: // int64
+            {
+                std::int64_t value{};
+                return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            default: // anything else not supported (yet)
+            {
+                std::array<char, 3> cr{{}};
+                static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                const std::string cr_str{cr.data()};
+                return sax->parse_error(element_type_parse_position, cr_str,
+                                        parse_error::create(114, element_type_parse_position, concat("Unsupported BSON record type 0x", cr_str), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief Read a BSON element list (as specified in the BSON-spec)
+
+    The same binary layout is used for objects and arrays, hence it must be
+    indicated with the argument @a is_array which one is expected
+    (true --> array, false --> object).
+
+    @param[in] is_array Determines if the element list being read is to be
+                        treated as an object (@a is_array == false), or as an
+                        array (@a is_array == true).
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_list(const bool is_array)
+    {
+        string_t key;
+
+        while (auto element_type = get())
+        {
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
+            {
+                return false;
+            }
+
+            const std::size_t element_type_parse_position = chars_read;
+            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
+            {
+                return false;
+            }
+
+            if (!is_array && !sax->key(key))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
+            {
+                return false;
+            }
+
+            // get_bson_cstr only appends
+            key.clear();
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief Reads an array from the BSON input and passes it to the SAX-parser.
+    @return whether a valid BSON-array was passed to the SAX parser
+    */
+    bool parse_bson_array()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
+        {
+            return false;
+        }
+
+        return sax->end_array();
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true) or whether the last read character should
+                         be considered instead (false)
+    @param[in] tag_handler how CBOR tags should be treated
+
+    @return whether a valid CBOR value was passed to the SAX parser
+    */
+    bool parse_cbor_internal(const bool get_char,
+                             const cbor_tag_handler_t tag_handler)
+    {
+        switch (get_char ? get() : current)
+        {
+            // EOF
+            case char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::cbor, "value");
+
+            // Integer 0x00..0x17 (0..23)
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            case 0x18: // Unsigned integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x19: // Unsigned integer (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            // Negative integer -1-0x00..-1-0x17 (-1..-24)
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
+
+            case 0x38: // Negative integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
+                        - static_cast<number_integer_t>(number));
+            }
+
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            case 0x5F: // Binary data (indefinite length)
+            {
+                binary_t b;
+                return get_cbor_binary(b) && sax->binary(b);
+            }
+
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                string_t s;
+                return get_cbor_string(s) && sax->string(s);
+            }
+
+            // array (0x00..0x17 data items follow)
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+                return get_cbor_array(
+                           conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0x98: // array (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x99: // array (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9A: // array (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9B: // array (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9F: // array (indefinite length)
+                return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);
+
+            // map (0x00..0x17 pairs of data items follow)
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+                return get_cbor_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0xB8: // map (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xB9: // map (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBA: // map (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBB: // map (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBF: // map (indefinite length)
+                return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);
+
+            case 0xC6: // tagged item
+            case 0xC7:
+            case 0xC8:
+            case 0xC9:
+            case 0xCA:
+            case 0xCB:
+            case 0xCC:
+            case 0xCD:
+            case 0xCE:
+            case 0xCF:
+            case 0xD0:
+            case 0xD1:
+            case 0xD2:
+            case 0xD3:
+            case 0xD4:
+            case 0xD8: // tagged item (1 bytes follow)
+            case 0xD9: // tagged item (2 bytes follow)
+            case 0xDA: // tagged item (4 bytes follow)
+            case 0xDB: // tagged item (8 bytes follow)
+            {
+                switch (tag_handler)
+                {
+                    case cbor_tag_handler_t::error:
+                    {
+                        auto last_token = get_token_string();
+                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                                exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
+                    }
+
+                    case cbor_tag_handler_t::ignore:
+                    {
+                        // ignore binary subtype
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            default:
+                                break;
+                        }
+                        return parse_cbor_internal(true, tag_handler);
+                    }
+
+                    case cbor_tag_handler_t::store:
+                    {
+                        binary_t b;
+                        // use binary subtype and store in binary container
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            default:
+                                return parse_cbor_internal(true, tag_handler);
+                        }
+                        get();
+                        return get_cbor_binary(b) && sax->binary(b);
+                    }
+
+                    default:                 // LCOV_EXCL_LINE
+                        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+                        return false;        // LCOV_EXCL_LINE
+                }
+            }
+
+            case 0xF4: // false
+                return sax->boolean(false);
+
+            case 0xF5: // true
+                return sax->boolean(true);
+
+            case 0xF6: // null
+                return sax->null();
+
+            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
+            {
+                const auto byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+                const auto byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
+            {
+                float number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
+            {
+                double number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            default: // anything else (0xFF is handled inside the other types)
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+    Additionally, CBOR's strings with indefinite lengths are supported.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_cbor_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            {
+                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    string_t chunk;
+                    if (!get_cbor_string(chunk))
+                    {
+                        return false;
+                    }
+                    result.append(chunk);
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::cbor, concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into the byte array.
+    Additionally, CBOR's byte arrays with indefinite lengths are supported.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_cbor_binary(binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            {
+                return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5F: // Binary data (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    binary_t chunk;
+                    if (!get_cbor_binary(chunk))
+                    {
+                        return false;
+                    }
+                    result.insert(result.end(), chunk.begin(), chunk.end());
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::cbor, concat("expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x", last_token), "binary"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array or static_cast<std::size_t>(-1) for an
+                    array of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether array creation completed
+    */
+    bool get_cbor_array(const std::size_t len,
+                        const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        if (len != static_cast<std::size_t>(-1))
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object or static_cast<std::size_t>(-1) for an
+                    object of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether object creation completed
+    */
+    bool get_cbor_object(const std::size_t len,
+                         const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        if (len != 0)
+        {
+            string_t key;
+            if (len != static_cast<std::size_t>(-1))
+            {
+                for (std::size_t i = 0; i < len; ++i)
+                {
+                    get();
+                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                while (get() != 0xFF)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    /*!
+    @return whether a valid MessagePack value was passed to the SAX parser
+    */
+    bool parse_msgpack_internal()
+    {
+        switch (get())
+        {
+            // EOF
+            case char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::msgpack, "value");
+
+            // positive fixint
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+            case 0x18:
+            case 0x19:
+            case 0x1A:
+            case 0x1B:
+            case 0x1C:
+            case 0x1D:
+            case 0x1E:
+            case 0x1F:
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+            case 0x38:
+            case 0x39:
+            case 0x3A:
+            case 0x3B:
+            case 0x3C:
+            case 0x3D:
+            case 0x3E:
+            case 0x3F:
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58:
+            case 0x59:
+            case 0x5A:
+            case 0x5B:
+            case 0x5C:
+            case 0x5D:
+            case 0x5E:
+            case 0x5F:
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78:
+            case 0x79:
+            case 0x7A:
+            case 0x7B:
+            case 0x7C:
+            case 0x7D:
+            case 0x7E:
+            case 0x7F:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            // fixmap
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+                return get_msgpack_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixarray
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+            case 0x98:
+            case 0x99:
+            case 0x9A:
+            case 0x9B:
+            case 0x9C:
+            case 0x9D:
+            case 0x9E:
+            case 0x9F:
+                return get_msgpack_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            case 0xD9: // str 8
+            case 0xDA: // str 16
+            case 0xDB: // str 32
+            {
+                string_t s;
+                return get_msgpack_string(s) && sax->string(s);
+            }
+
+            case 0xC0: // nil
+                return sax->null();
+
+            case 0xC2: // false
+                return sax->boolean(false);
+
+            case 0xC3: // true
+                return sax->boolean(true);
+
+            case 0xC4: // bin 8
+            case 0xC5: // bin 16
+            case 0xC6: // bin 32
+            case 0xC7: // ext 8
+            case 0xC8: // ext 16
+            case 0xC9: // ext 32
+            case 0xD4: // fixext 1
+            case 0xD5: // fixext 2
+            case 0xD6: // fixext 4
+            case 0xD7: // fixext 8
+            case 0xD8: // fixext 16
+            {
+                binary_t b;
+                return get_msgpack_binary(b) && sax->binary(b);
+            }
+
+            case 0xCA: // float 32
+            {
+                float number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCB: // float 64
+            {
+                double number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCC: // uint 8
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCD: // uint 16
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCE: // uint 32
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCF: // uint 64
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xD0: // int 8
+            {
+                std::int8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD1: // int 16
+            {
+                std::int16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD2: // int 32
+            {
+                std::int32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD3: // int 64
+            {
+                std::int64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xDC: // array 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDD: // array 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(conditional_static_cast<std::size_t>(len));
+            }
+
+            case 0xDE: // map 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xDF: // map 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(conditional_static_cast<std::size_t>(len));
+            }
+
+            // negative fixint
+            case 0xE0:
+            case 0xE1:
+            case 0xE2:
+            case 0xE3:
+            case 0xE4:
+            case 0xE5:
+            case 0xE6:
+            case 0xE7:
+            case 0xE8:
+            case 0xE9:
+            case 0xEA:
+            case 0xEB:
+            case 0xEC:
+            case 0xED:
+            case 0xEE:
+            case 0xEF:
+            case 0xF0:
+            case 0xF1:
+            case 0xF2:
+            case 0xF3:
+            case 0xF4:
+            case 0xF5:
+            case 0xF6:
+            case 0xF7:
+            case 0xF8:
+            case 0xF9:
+            case 0xFA:
+            case 0xFB:
+            case 0xFC:
+            case 0xFD:
+            case 0xFE:
+            case 0xFF:
+                return sax->number_integer(static_cast<std::int8_t>(current));
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format_t::msgpack, concat("invalid byte: 0x", last_token), "value"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_msgpack_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            {
+                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0xD9: // str 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDA: // str 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDB: // str 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::msgpack, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into a byte array.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_msgpack_binary(binary_t& result)
+    {
+        // helper function to set the subtype
+        auto assign_and_return_true = [&result](std::int8_t subtype)
+        {
+            result.set_subtype(static_cast<std::uint8_t>(subtype));
+            return true;
+        };
+
+        switch (current)
+        {
+            case 0xC4: // bin 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC5: // bin 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC6: // bin 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC7: // ext 8
+            {
+                std::uint8_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC8: // ext 16
+            {
+                std::uint16_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC9: // ext 32
+            {
+                std::uint32_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD4: // fixext 1
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 1, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD5: // fixext 2
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 2, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD6: // fixext 4
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 4, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD7: // fixext 8
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 8, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD8: // fixext 16
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 16, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            default:           // LCOV_EXCL_LINE
+                return false;  // LCOV_EXCL_LINE
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array
+    @return whether array creation completed
+    */
+    bool get_msgpack_array(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object
+    @return whether object creation completed
+    */
+    bool get_msgpack_object(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+            key.clear();
+        }
+
+        return sax->end_object();
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether a valid UBJSON value was passed to the SAX parser
+    */
+    bool parse_ubjson_internal(const bool get_char = true)
+    {
+        return get_ubjson_value(get_char ? get_ignore_noop() : current);
+    }
+
+    /*!
+    @brief reads a UBJSON string
+
+    This function is either called after reading the 'S' byte explicitly
+    indicating a string, or in case of an object key where the 'S' byte can be
+    left out.
+
+    @param[out] result   created string
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether string creation completed
+    */
+    bool get_ubjson_string(string_t& result, const bool get_char = true)
+    {
+        if (get_char)
+        {
+            get();  // TODO(niels): may we ignore N here?
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            case 'U':
+            {
+                std::uint8_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'i':
+            {
+                std::int8_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'I':
+            {
+                std::int16_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'l':
+            {
+                std::int32_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'L':
+            {
+                std::int64_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            default:
+                break;
+        }
+        auto last_token = get_token_string();
+        std::string message;
+
+        if (input_format != input_format_t::bjdata)
+        {
+            message = "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token;
+        }
+        else
+        {
+            message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token;
+        }
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr));
+    }
+
+    /*!
+    @param[out] dim  an integer vector storing the ND array dimensions
+    @return whether reading ND array size vector is successful
+    */
+    bool get_ubjson_ndarray_size(std::vector<size_t>& dim)
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        size_t dimlen = 0;
+        bool no_ndarray = true;
+
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type, no_ndarray)))
+        {
+            return false;
+        }
+
+        if (size_and_type.first != npos)
+        {
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, size_and_type.second)))
+                        {
+                            return false;
+                        }
+                        dim.push_back(dimlen);
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray)))
+                    {
+                        return false;
+                    }
+                    dim.push_back(dimlen);
+                }
+            }
+        }
+        else
+        {
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, current)))
+                {
+                    return false;
+                }
+                dim.push_back(dimlen);
+                get_ignore_noop();
+            }
+        }
+        return true;
+    }
+
+    /*!
+    @param[out] result  determined size
+    @param[in,out] is_ndarray  for input, `true` means already inside an ndarray vector
+                               or ndarray dimension is not allowed; `false` means ndarray
+                               is allowed; for output, `true` means an ndarray is found;
+                               is_ndarray can only return `true` when its initial value
+                               is `false`
+    @param[in] prefix  type marker if already read, otherwise set to 0
+
+    @return whether size determination completed
+    */
+    bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0)
+    {
+        if (prefix == 0)
+        {
+            prefix = get_ignore_noop();
+        }
+
+        switch (prefix)
+        {
+            case 'U':
+            {
+                std::uint8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
+                return true;
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                if (!value_in_range_of<std::size_t>(number))
+                {
+                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
+                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = conditional_static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (!value_in_range_of<std::size_t>(number))
+                {
+                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
+                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
+                }
+                result = detail::conditional_static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case '[':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                if (is_ndarray) // ndarray dimensional vector can only contain integers, and can not embed another array
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message(input_format, "ndarray dimensional vector is not allowed", "size"), nullptr));
+                }
+                std::vector<size_t> dim;
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim)))
+                {
+                    return false;
+                }
+                if (dim.size() == 1 || (dim.size() == 2 && dim.at(0) == 1)) // return normal array size if 1D row vector
+                {
+                    result = dim.at(dim.size() - 1);
+                    return true;
+                }
+                if (!dim.empty())  // if ndarray, convert to an object in JData annotated array format
+                {
+                    for (auto i : dim) // test if any dimension in an ndarray is 0, if so, return a 1D empty container
+                    {
+                        if ( i == 0 )
+                        {
+                            result = 0;
+                            return true;
+                        }
+                    }
+
+                    string_t key = "_ArraySize_";
+                    if (JSON_HEDLEY_UNLIKELY(!sax->start_object(3) || !sax->key(key) || !sax->start_array(dim.size())))
+                    {
+                        return false;
+                    }
+                    result = 1;
+                    for (auto i : dim)
+                    {
+                        result *= i;
+                        if (result == 0 || result == npos) // because dim elements shall not have zeros, result = 0 means overflow happened; it also can't be npos as it is used to initialize size in get_ubjson_size_type()
+                        {
+                            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(static_cast<number_unsigned_t>(i))))
+                        {
+                            return false;
+                        }
+                    }
+                    is_ndarray = true;
+                    return sax->end_array();
+                }
+                result = 0;
+                return true;
+            }
+
+            default:
+                break;
+        }
+        auto last_token = get_token_string();
+        std::string message;
+
+        if (input_format != input_format_t::bjdata)
+        {
+            message = "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token;
+        }
+        else
+        {
+            message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token;
+        }
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr));
+    }
+
+    /*!
+    @brief determine the type and size for a container
+
+    In the optimized UBJSON format, a type and a size can be provided to allow
+    for a more compact representation.
+
+    @param[out] result  pair of the size and the type
+    @param[in] inside_ndarray  whether the parser is parsing an ND array dimensional vector
+
+    @return whether pair creation completed
+    */
+    bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result, bool inside_ndarray = false)
+    {
+        result.first = npos; // size
+        result.second = 0; // type
+        bool is_ndarray = false;
+
+        get_ignore_noop();
+
+        if (current == '$')
+        {
+            result.second = get();  // must not ignore 'N', because 'N' maybe the type
+            if (input_format == input_format_t::bjdata
+                    && JSON_HEDLEY_UNLIKELY(std::binary_search(bjd_optimized_type_markers.begin(), bjd_optimized_type_markers.end(), result.second)))
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr));
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type")))
+            {
+                return false;
+            }
+
+            get_ignore_noop();
+            if (JSON_HEDLEY_UNLIKELY(current != '#'))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
+                {
+                    return false;
+                }
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr));
+            }
+
+            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
+            if (input_format == input_format_t::bjdata && is_ndarray)
+            {
+                if (inside_ndarray)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
+                                            exception_message(input_format, "ndarray can not be recursive", "size"), nullptr));
+                }
+                result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON and BJData markers should be ASCII letters
+            }
+            return is_error;
+        }
+
+        if (current == '#')
+        {
+            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
+            if (input_format == input_format_t::bjdata && is_ndarray)
+            {
+                return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
+                                        exception_message(input_format, "ndarray requires both type and size", "size"), nullptr));
+            }
+            return is_error;
+        }
+
+        return true;
+    }
+
+    /*!
+    @param prefix  the previously read or set type prefix
+    @return whether value creation completed
+    */
+    bool get_ubjson_value(const char_int_type prefix)
+    {
+        switch (prefix)
+        {
+            case char_traits<char_type>::eof():  // EOF
+                return unexpect_eof(input_format, "value");
+
+            case 'T':  // true
+                return sax->boolean(true);
+            case 'F':  // false
+                return sax->boolean(false);
+
+            case 'Z':  // null
+                return sax->null();
+
+            case 'U':
+            {
+                std::uint8_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'h':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                const auto byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+                {
+                    return false;
+                }
+                const auto byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte2 << 8u) + byte1);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 'd':
+            {
+                float number{};
+                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'D':
+            {
+                double number{};
+                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'H':
+            {
+                return get_ubjson_high_precision_number();
+            }
+
+            case 'C':  // char
+            {
+                get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char")))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(current > 127))
+                {
+                    auto last_token = get_token_string();
+                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                            exception_message(input_format, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr));
+                }
+                string_t s(1, static_cast<typename string_t::value_type>(current));
+                return sax->string(s);
+            }
+
+            case 'S':  // string
+            {
+                string_t s;
+                return get_ubjson_string(s) && sax->string(s);
+            }
+
+            case '[':  // array
+                return get_ubjson_array();
+
+            case '{':  // object
+                return get_ubjson_object();
+
+            default: // anything else
+                break;
+        }
+        auto last_token = get_token_string();
+        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format, "invalid byte: 0x" + last_token, "value"), nullptr));
+    }
+
+    /*!
+    @return whether array creation completed
+    */
+    bool get_ubjson_array()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        // if bit-8 of size_and_type.second is set to 1, encode bjdata ndarray as an object in JData annotated array format (https://github.com/NeuroJSON/jdata):
+        // {"_ArrayType_" : "typeid", "_ArraySize_" : [n1, n2, ...], "_ArrayData_" : [v1, v2, ...]}
+
+        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
+        {
+            size_and_type.second &= ~(static_cast<char_int_type>(1) << 8);  // use bit 8 to indicate ndarray, here we remove the bit to restore the type marker
+            auto it = std::lower_bound(bjd_types_map.begin(), bjd_types_map.end(), size_and_type.second, [](const bjd_type & p, char_int_type t)
+            {
+                return p.first < t;
+            });
+            string_t key = "_ArrayType_";
+            if (JSON_HEDLEY_UNLIKELY(it == bjd_types_map.end() || it->first != size_and_type.second))
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, "invalid byte: 0x" + last_token, "type"), nullptr));
+            }
+
+            string_t type = it->second; // sax->string() takes a reference
+            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->string(type)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second == 'C')
+            {
+                size_and_type.second = 'U';
+            }
+
+            key = "_ArrayData_";
+            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->start_array(size_and_type.first) ))
+            {
+                return false;
+            }
+
+            for (std::size_t i = 0; i < size_and_type.first; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                {
+                    return false;
+                }
+            }
+
+            return (sax->end_array() && sax->end_object());
+        }
+
+        if (size_and_type.first != npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+            {
+                return false;
+            }
+
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @return whether object creation completed
+    */
+    bool get_ubjson_object()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        // do not accept ND-array size in objects in BJData
+        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format, "BJData object does not support ND-array size in optimized format", "object"), nullptr));
+        }
+
+        string_t key;
+        if (size_and_type.first != npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+            {
+                return false;
+            }
+
+            while (current != '}')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    // Note, no reader for UBJSON binary types is implemented because they do
+    // not exist
+
+    bool get_ubjson_high_precision_number()
+    {
+        // get size of following number string
+        std::size_t size{};
+        bool no_ndarray = true;
+        auto res = get_ubjson_size_value(size, no_ndarray);
+        if (JSON_HEDLEY_UNLIKELY(!res))
+        {
+            return res;
+        }
+
+        // get number string
+        std::vector<char> number_vector;
+        for (std::size_t i = 0; i < size; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+            {
+                return false;
+            }
+            number_vector.push_back(static_cast<char>(current));
+        }
+
+        // parse number string
+        using ia_type = decltype(detail::input_adapter(number_vector));
+        auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);
+        const auto result_number = number_lexer.scan();
+        const auto number_string = number_lexer.get_token_string();
+        const auto result_remainder = number_lexer.scan();
+
+        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
+
+        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
+        {
+            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
+                                    exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
+        }
+
+        switch (result_number)
+        {
+            case token_type::value_integer:
+                return sax->number_integer(number_lexer.get_number_integer());
+            case token_type::value_unsigned:
+                return sax->number_unsigned(number_lexer.get_number_unsigned());
+            case token_type::value_float:
+                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
+            case token_type::uninitialized:
+            case token_type::literal_true:
+            case token_type::literal_false:
+            case token_type::literal_null:
+            case token_type::value_string:
+            case token_type::begin_array:
+            case token_type::begin_object:
+            case token_type::end_array:
+            case token_type::end_object:
+            case token_type::name_separator:
+            case token_type::value_separator:
+            case token_type::parse_error:
+            case token_type::end_of_input:
+            case token_type::literal_or_value:
+            default:
+                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
+                                        exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
+        }
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*!
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a -'ve valued
+    `char_traits<char_type>::eof()` in that case.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++chars_read;
+        return current = ia.get_character();
+    }
+
+    /*!
+    @return character read from the input after ignoring all 'N' entries
+    */
+    char_int_type get_ignore_noop()
+    {
+        do
+        {
+            get();
+        }
+        while (current == 'N');
+
+        return current;
+    }
+
+    /*
+    @brief read a number from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format   the current format (for diagnostics)
+    @param[out] result  number of type @a NumberType
+
+    @return whether conversion completed
+
+    @note This function needs to respect the system's endianness, because
+          bytes in CBOR, MessagePack, and UBJSON are stored in network order
+          (big endian) and therefore need reordering on little endian systems.
+          On the other hand, BSON and BJData use little endian and should reorder
+          on big endian systems.
+    */
+    template<typename NumberType, bool InputIsLittleEndian = false>
+    bool get_number(const input_format_t format, NumberType& result)
+    {
+        // step 1: read input into array with system's byte order
+        std::array<std::uint8_t, sizeof(NumberType)> vec{};
+        for (std::size_t i = 0; i < sizeof(NumberType); ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
+            {
+                return false;
+            }
+
+            // reverse byte order prior to conversion if necessary
+            if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata))
+            {
+                vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
+            }
+            else
+            {
+                vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
+            }
+        }
+
+        // step 2: convert array into number of type T and return
+        std::memcpy(&result, vec.data(), sizeof(NumberType));
+        return true;
+    }
+
+    /*!
+    @brief create a string by reading characters from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of characters to read
+    @param[out] result string created by reading @a len bytes
+
+    @return whether string creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of string memory.
+    */
+    template<typename NumberType>
+    bool get_string(const input_format_t format,
+                    const NumberType len,
+                    string_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<typename string_t::value_type>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @brief create a byte array by reading bytes from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of bytes to read
+    @param[out] result byte array created by reading @a len bytes
+
+    @return whether byte array creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of memory.
+    */
+    template<typename NumberType>
+    bool get_binary(const input_format_t format,
+                    const NumberType len,
+                    binary_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<std::uint8_t>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @param[in] format   the current format (for diagnostics)
+    @param[in] context  further context information (for diagnostics)
+    @return whether the last read character is not EOF
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool unexpect_eof(const input_format_t format, const char* context) const
+    {
+        if (JSON_HEDLEY_UNLIKELY(current == char_traits<char_type>::eof()))
+        {
+            return sax->parse_error(chars_read, "<end of file>",
+                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr));
+        }
+        return true;
+    }
+
+    /*!
+    @return a string representation of the last read byte
+    */
+    std::string get_token_string() const
+    {
+        std::array<char, 3> cr{{}};
+        static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        return std::string{cr.data()};
+    }
+
+    /*!
+    @param[in] format   the current format
+    @param[in] detail   a detailed error message
+    @param[in] context  further context information
+    @return a message string to use in the parse_error exceptions
+    */
+    std::string exception_message(const input_format_t format,
+                                  const std::string& detail,
+                                  const std::string& context) const
+    {
+        std::string error_msg = "syntax error while parsing ";
+
+        switch (format)
+        {
+            case input_format_t::cbor:
+                error_msg += "CBOR";
+                break;
+
+            case input_format_t::msgpack:
+                error_msg += "MessagePack";
+                break;
+
+            case input_format_t::ubjson:
+                error_msg += "UBJSON";
+                break;
+
+            case input_format_t::bson:
+                error_msg += "BSON";
+                break;
+
+            case input_format_t::bjdata:
+                error_msg += "BJData";
+                break;
+
+            case input_format_t::json: // LCOV_EXCL_LINE
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+        return concat(error_msg, ' ', context, ": ", detail);
+    }
+
+  private:
+    static JSON_INLINE_VARIABLE constexpr std::size_t npos = static_cast<std::size_t>(-1);
+
+    /// input adapter
+    InputAdapterType ia;
+
+    /// the current character
+    char_int_type current = char_traits<char_type>::eof();
+
+    /// the number of characters read
+    std::size_t chars_read = 0;
+
+    /// whether we can assume little endianness
+    const bool is_little_endian = little_endianness();
+
+    /// input format
+    const input_format_t input_format = input_format_t::json;
+
+    /// the SAX parser
+    json_sax_t* sax = nullptr;
+
+    // excluded markers in bjdata optimized type
+#define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ \
+    make_array<char_int_type>('F', 'H', 'N', 'S', 'T', 'Z', '[', '{')
+
+#define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ \
+    make_array<bjd_type>(                      \
+    bjd_type{'C', "char"},                     \
+    bjd_type{'D', "double"},                   \
+    bjd_type{'I', "int16"},                    \
+    bjd_type{'L', "int64"},                    \
+    bjd_type{'M', "uint64"},                   \
+    bjd_type{'U', "uint8"},                    \
+    bjd_type{'d', "single"},                   \
+    bjd_type{'i', "int8"},                     \
+    bjd_type{'l', "int32"},                    \
+    bjd_type{'m', "uint32"},                   \
+    bjd_type{'u', "uint16"})
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // lookup tables
+    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
+    const decltype(JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_) bjd_optimized_type_markers =
+        JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_;
+
+    using bjd_type = std::pair<char_int_type, string_t>;
+    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
+    const decltype(JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_) bjd_types_map =
+        JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_;
+
+#undef JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_
+#undef JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_
+};
+
+#ifndef JSON_HAS_CPP_17
+    template<typename BasicJsonType, typename InputAdapterType, typename SAX>
+    constexpr std::size_t binary_reader<BasicJsonType, InputAdapterType, SAX>::npos;
+#endif
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/input/parser.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cmath> // isfinite
+#include <cstdint> // uint8_t
+#include <functional> // function
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+////////////
+// parser //
+////////////
+
+enum class parse_event_t : std::uint8_t
+{
+    /// the parser read `{` and started to process a JSON object
+    object_start,
+    /// the parser read `}` and finished processing a JSON object
+    object_end,
+    /// the parser read `[` and started to process a JSON array
+    array_start,
+    /// the parser read `]` and finished processing a JSON array
+    array_end,
+    /// the parser read a key of a value in an object
+    key,
+    /// the parser finished reading a JSON value
+    value
+};
+
+template<typename BasicJsonType>
+using parser_callback_t =
+    std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;
+
+/*!
+@brief syntax analysis
+
+This class implements a recursive descent parser.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class parser
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
+    using token_type = typename lexer_t::token_type;
+
+  public:
+    /// a parser reading from an input adapter
+    explicit parser(InputAdapterType&& adapter,
+                    const parser_callback_t<BasicJsonType> cb = nullptr,
+                    const bool allow_exceptions_ = true,
+                    const bool skip_comments = false)
+        : callback(cb)
+        , m_lexer(std::move(adapter), skip_comments)
+        , allow_exceptions(allow_exceptions_)
+    {
+        // read first token
+        get_token();
+    }
+
+    /*!
+    @brief public parser interface
+
+    @param[in] strict      whether to expect the last token to be EOF
+    @param[in,out] result  parsed JSON value
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+    */
+    void parse(const bool strict, BasicJsonType& result)
+    {
+        if (callback)
+        {
+            json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
+            sax_parse_internal(&sdp);
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value"), nullptr));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+
+            // set top-level value to null if it was discarded by the callback
+            // function
+            if (result.is_discarded())
+            {
+                result = nullptr;
+            }
+        }
+        else
+        {
+            json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
+            sax_parse_internal(&sdp);
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+        }
+
+        result.assert_invariant();
+    }
+
+    /*!
+    @brief public accept interface
+
+    @param[in] strict  whether to expect the last token to be EOF
+    @return whether the input is a proper JSON text
+    */
+    bool accept(const bool strict = true)
+    {
+        json_sax_acceptor<BasicJsonType> sax_acceptor;
+        return sax_parse(&sax_acceptor, strict);
+    }
+
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse(SAX* sax, const bool strict = true)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+        const bool result = sax_parse_internal(sax);
+
+        // strict mode: next byte must be EOF
+        if (result && strict && (get_token() != token_type::end_of_input))
+        {
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
+        }
+
+        return result;
+    }
+
+  private:
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse_internal(SAX* sax)
+    {
+        // stack to remember the hierarchy of structured values we are parsing
+        // true = array; false = object
+        std::vector<bool> states;
+        // value to avoid a goto (see comment where set to true)
+        bool skip_to_state_evaluation = false;
+
+        while (true)
+        {
+            if (!skip_to_state_evaluation)
+            {
+                // invariant: get_token() was called before each iteration
+                switch (last_token)
+                {
+                    case token_type::begin_object:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing } -> we are done
+                        if (get_token() == token_type::end_object)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // parse key
+                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        // parse separator (:)
+                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
+                        }
+
+                        // remember we are now inside an object
+                        states.push_back(false);
+
+                        // parse values
+                        get_token();
+                        continue;
+                    }
+
+                    case token_type::begin_array:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing ] -> we are done
+                        if (get_token() == token_type::end_array)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // remember we are now inside an array
+                        states.push_back(true);
+
+                        // parse values (no need to call get_token)
+                        continue;
+                    }
+
+                    case token_type::value_float:
+                    {
+                        const auto res = m_lexer.get_number_float();
+
+                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
+                        }
+
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        break;
+                    }
+
+                    case token_type::literal_false:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_null:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_true:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_integer:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_string:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_unsigned:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::parse_error:
+                    {
+                        // using "uninitialized" to avoid "expected" message
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr));
+                    }
+                    case token_type::end_of_input:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
+                        }
+
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
+                    }
+                    case token_type::uninitialized:
+                    case token_type::end_array:
+                    case token_type::end_object:
+                    case token_type::name_separator:
+                    case token_type::value_separator:
+                    case token_type::literal_or_value:
+                    default: // the last token was unexpected
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
+                    }
+                }
+            }
+            else
+            {
+                skip_to_state_evaluation = false;
+            }
+
+            // we reached this line after we successfully parsed a value
+            if (states.empty())
+            {
+                // empty stack: we reached the end of the hierarchy: done
+                return true;
+            }
+
+            if (states.back())  // array
+            {
+                // comma -> next value
+                if (get_token() == token_type::value_separator)
+                {
+                    // parse a new value
+                    get_token();
+                    continue;
+                }
+
+                // closing ]
+                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                    {
+                        return false;
+                    }
+
+                    // We are done with this array. Before we can parse a
+                    // new value, we need to evaluate the new state first.
+                    // By setting skip_to_state_evaluation to false, we
+                    // are effectively jumping to the beginning of this if.
+                    JSON_ASSERT(!states.empty());
+                    states.pop_back();
+                    skip_to_state_evaluation = true;
+                    continue;
+                }
+
+                return sax->parse_error(m_lexer.get_position(),
+                                        m_lexer.get_token_string(),
+                                        parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr));
+            }
+
+            // states.back() is false -> object
+
+            // comma -> next value
+            if (get_token() == token_type::value_separator)
+            {
+                // parse key
+                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
+                {
+                    return sax->parse_error(m_lexer.get_position(),
+                                            m_lexer.get_token_string(),
+                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
+                }
+
+                if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                {
+                    return false;
+                }
+
+                // parse separator (:)
+                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                {
+                    return sax->parse_error(m_lexer.get_position(),
+                                            m_lexer.get_token_string(),
+                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
+                }
+
+                // parse values
+                get_token();
+                continue;
+            }
+
+            // closing }
+            if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                {
+                    return false;
+                }
+
+                // We are done with this object. Before we can parse a
+                // new value, we need to evaluate the new state first.
+                // By setting skip_to_state_evaluation to false, we
+                // are effectively jumping to the beginning of this if.
+                JSON_ASSERT(!states.empty());
+                states.pop_back();
+                skip_to_state_evaluation = true;
+                continue;
+            }
+
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr));
+        }
+    }
+
+    /// get next token from lexer
+    token_type get_token()
+    {
+        return last_token = m_lexer.scan();
+    }
+
+    std::string exception_message(const token_type expected, const std::string& context)
+    {
+        std::string error_msg = "syntax error ";
+
+        if (!context.empty())
+        {
+            error_msg += concat("while parsing ", context, ' ');
+        }
+
+        error_msg += "- ";
+
+        if (last_token == token_type::parse_error)
+        {
+            error_msg += concat(m_lexer.get_error_message(), "; last read: '",
+                                m_lexer.get_token_string(), '\'');
+        }
+        else
+        {
+            error_msg += concat("unexpected ", lexer_t::token_type_name(last_token));
+        }
+
+        if (expected != token_type::uninitialized)
+        {
+            error_msg += concat("; expected ", lexer_t::token_type_name(expected));
+        }
+
+        return error_msg;
+    }
+
+  private:
+    /// callback function
+    const parser_callback_t<BasicJsonType> callback = nullptr;
+    /// the type of the last read token
+    token_type last_token = token_type::uninitialized;
+    /// the lexer
+    lexer_t m_lexer;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // ptrdiff_t
+#include <limits>  // numeric_limits
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*
+@brief an iterator for primitive JSON types
+
+This class models an iterator for primitive JSON types (boolean, number,
+string). It's only purpose is to allow the iterator/const_iterator classes
+to "iterate" over primitive values. Internally, the iterator is modeled by
+a `difference_type` variable. Value begin_value (`0`) models the begin,
+end_value (`1`) models past the end.
+*/
+class primitive_iterator_t
+{
+  private:
+    using difference_type = std::ptrdiff_t;
+    static constexpr difference_type begin_value = 0;
+    static constexpr difference_type end_value = begin_value + 1;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// iterator as signed integer type
+    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
+
+  public:
+    constexpr difference_type get_value() const noexcept
+    {
+        return m_it;
+    }
+
+    /// set iterator to a defined beginning
+    void set_begin() noexcept
+    {
+        m_it = begin_value;
+    }
+
+    /// set iterator to a defined past the end
+    void set_end() noexcept
+    {
+        m_it = end_value;
+    }
+
+    /// return whether the iterator can be dereferenced
+    constexpr bool is_begin() const noexcept
+    {
+        return m_it == begin_value;
+    }
+
+    /// return whether the iterator is at end
+    constexpr bool is_end() const noexcept
+    {
+        return m_it == end_value;
+    }
+
+    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it == rhs.m_it;
+    }
+
+    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it < rhs.m_it;
+    }
+
+    primitive_iterator_t operator+(difference_type n) noexcept
+    {
+        auto result = *this;
+        result += n;
+        return result;
+    }
+
+    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it - rhs.m_it;
+    }
+
+    primitive_iterator_t& operator++() noexcept
+    {
+        ++m_it;
+        return *this;
+    }
+
+    primitive_iterator_t operator++(int)& noexcept // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        ++m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator--() noexcept
+    {
+        --m_it;
+        return *this;
+    }
+
+    primitive_iterator_t operator--(int)& noexcept // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        --m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator+=(difference_type n) noexcept
+    {
+        m_it += n;
+        return *this;
+    }
+
+    primitive_iterator_t& operator-=(difference_type n) noexcept
+    {
+        m_it -= n;
+        return *this;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief an iterator value
+
+@note This structure could easily be a union, but MSVC currently does not allow
+unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
+*/
+template<typename BasicJsonType> struct internal_iterator
+{
+    /// iterator for JSON objects
+    typename BasicJsonType::object_t::iterator object_iterator {};
+    /// iterator for JSON arrays
+    typename BasicJsonType::array_t::iterator array_iterator {};
+    /// generic iterator for all other types
+    primitive_iterator_t primitive_iterator {};
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/iter_impl.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
+#include <type_traits> // conditional, is_const, remove_const
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// forward declare, to be able to friend it later on
+template<typename IteratorType> class iteration_proxy;
+template<typename IteratorType> class iteration_proxy_value;
+
+/*!
+@brief a template for a bidirectional iterator for the @ref basic_json class
+This class implements a both iterators (iterator and const_iterator) for the
+@ref basic_json class.
+@note An iterator is called *initialized* when a pointer to a JSON value has
+      been set (e.g., by a constructor or a copy assignment). If the iterator is
+      default-constructed, it is *uninitialized* and most methods are undefined.
+      **The library uses assertions to detect calls on uninitialized iterators.**
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
+       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
+*/
+template<typename BasicJsonType>
+class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+{
+    /// the iterator with BasicJsonType of different const-ness
+    using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
+    /// allow basic_json to access private members
+    friend other_iter_impl;
+    friend BasicJsonType;
+    friend iteration_proxy<iter_impl>;
+    friend iteration_proxy_value<iter_impl>;
+
+    using object_t = typename BasicJsonType::object_t;
+    using array_t = typename BasicJsonType::array_t;
+    // make sure BasicJsonType is basic_json or const basic_json
+    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
+                  "iter_impl only accepts (const) basic_json");
+    // superficial check for the LegacyBidirectionalIterator named requirement
+    static_assert(std::is_base_of<std::bidirectional_iterator_tag, std::bidirectional_iterator_tag>::value
+                  &&  std::is_base_of<std::bidirectional_iterator_tag, typename std::iterator_traits<typename array_t::iterator>::iterator_category>::value,
+                  "basic_json iterator assumes array and object type iterators satisfy the LegacyBidirectionalIterator named requirement.");
+
+  public:
+    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
+    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
+    /// A user-defined iterator should provide publicly accessible typedefs named
+    /// iterator_category, value_type, difference_type, pointer, and reference.
+    /// Note that value_type is required to be non-const, even for constant iterators.
+    using iterator_category = std::bidirectional_iterator_tag;
+
+    /// the type of the values when the iterator is dereferenced
+    using value_type = typename BasicJsonType::value_type;
+    /// a type to represent differences between iterators
+    using difference_type = typename BasicJsonType::difference_type;
+    /// defines a pointer to the type iterated over (value_type)
+    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
+          typename BasicJsonType::const_pointer,
+          typename BasicJsonType::pointer>::type;
+    /// defines a reference to the type iterated over (value_type)
+    using reference =
+        typename std::conditional<std::is_const<BasicJsonType>::value,
+        typename BasicJsonType::const_reference,
+        typename BasicJsonType::reference>::type;
+
+    iter_impl() = default;
+    ~iter_impl() = default;
+    iter_impl(iter_impl&&) noexcept = default;
+    iter_impl& operator=(iter_impl&&) noexcept = default;
+
+    /*!
+    @brief constructor for a given JSON instance
+    @param[in] object  pointer to a JSON object for this iterator
+    @pre object != nullptr
+    @post The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    explicit iter_impl(pointer object) noexcept : m_object(object)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = typename object_t::iterator();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = typename array_t::iterator();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator = primitive_iterator_t();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @note The conventional copy constructor and copy assignment are implicitly
+          defined. Combined with the following converting constructor and
+          assignment, they support: (1) copy from iterator to iterator, (2)
+          copy from const iterator to const iterator, and (3) conversion from
+          iterator to const iterator. However conversion from const iterator
+          to iterator is not defined.
+    */
+
+    /*!
+    @brief const copy constructor
+    @param[in] other const iterator to copy from
+    @note This copy constructor had to be defined explicitly to circumvent a bug
+          occurring on msvc v19.0 compiler (VS 2015) debug build. For more
+          information refer to: https://github.com/nlohmann/json/issues/1608
+    */
+    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
+    {
+        if (&other != this)
+        {
+            m_object = other.m_object;
+            m_it = other.m_it;
+        }
+        return *this;
+    }
+
+    /*!
+    @brief converting constructor
+    @param[in] other  non-const iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other  non-const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
+    {
+        m_object = other.m_object;
+        m_it = other.m_it;
+        return *this;
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief set the iterator to the first value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_begin() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_data.m_value.object->begin();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_data.m_value.array->begin();
+                break;
+            }
+
+            case value_t::null:
+            {
+                // set to end so begin()==end() is true: null is empty
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator.set_begin();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @brief set the iterator past the last value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_end() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_data.m_value.object->end();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_data.m_value.array->end();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+        }
+    }
+
+  public:
+    /*!
+    @brief return a reference to the value pointed to by the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator*() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
+                return m_it.object_iterator->second;
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
+                return *m_it.array_iterator;
+            }
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief dereference the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    pointer operator->() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
+                return &(m_it.object_iterator->second);
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
+                return &*m_it.array_iterator;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief post-increment (it++)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        ++(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-increment (++it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator++()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, 1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, 1);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                ++m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief post-decrement (it--)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator--(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        --(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-decrement (--it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator--()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, -1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, -1);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                --m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief comparison: equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
+    bool operator==(const IterImpl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                return (m_it.object_iterator == other.m_it.object_iterator);
+
+            case value_t::array:
+                return (m_it.array_iterator == other.m_it.array_iterator);
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief comparison: not equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
+    bool operator!=(const IterImpl& other) const
+    {
+        return !operator==(other);
+    }
+
+    /*!
+    @brief comparison: smaller
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", m_object));
+
+            case value_t::array:
+                return (m_it.array_iterator < other.m_it.array_iterator);
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<=(const iter_impl& other) const
+    {
+        return !other.operator < (*this);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>(const iter_impl& other) const
+    {
+        return !operator<=(other);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>=(const iter_impl& other) const
+    {
+        return !operator<(other);
+    }
+
+    /*!
+    @brief add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator+=(difference_type i)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, i);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator += i;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator-=(difference_type i)
+    {
+        return operator+=(-i);
+    }
+
+    /*!
+    @brief add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator+(difference_type i) const
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief addition of distance and iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    friend iter_impl operator+(difference_type i, const iter_impl& it)
+    {
+        auto result = it;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator-(difference_type i) const
+    {
+        auto result = *this;
+        result -= i;
+        return result;
+    }
+
+    /*!
+    @brief return difference
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    difference_type operator-(const iter_impl& other) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
+
+            case value_t::array:
+                return m_it.array_iterator - other.m_it.array_iterator;
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return m_it.primitive_iterator - other.m_it.primitive_iterator;
+        }
+    }
+
+    /*!
+    @brief access to successor
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator[](difference_type n) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", m_object));
+
+            case value_t::array:
+                return *std::next(m_it.array_iterator, n);
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief return the key of an object iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    const typename object_t::key_type& key() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
+        {
+            return m_it.object_iterator->first;
+        }
+
+        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
+    }
+
+    /*!
+    @brief return the value of an iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference value() const
+    {
+        return operator*();
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// associated JSON instance
+    pointer m_object = nullptr;
+    /// the actual iterator of the associated instance
+    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // ptrdiff_t
+#include <iterator> // reverse_iterator
+#include <utility> // declval
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+//////////////////////
+// reverse_iterator //
+//////////////////////
+
+/*!
+@brief a template for a reverse iterator class
+
+@tparam Base the base iterator type to reverse. Valid types are @ref
+iterator (to create @ref reverse_iterator) and @ref const_iterator (to
+create @ref const_reverse_iterator).
+
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
+  It is possible to write to the pointed-to element (only if @a Base is
+  @ref iterator).
+
+@since version 1.0.0
+*/
+template<typename Base>
+class json_reverse_iterator : public std::reverse_iterator<Base>
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    /// shortcut to the reverse iterator adapter
+    using base_iterator = std::reverse_iterator<Base>;
+    /// the reference type for the pointed-to element
+    using reference = typename Base::reference;
+
+    /// create reverse iterator from iterator
+    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
+        : base_iterator(it) {}
+
+    /// create reverse iterator from base class
+    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
+
+    /// post-increment (it++)
+    json_reverse_iterator operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
+    }
+
+    /// pre-increment (++it)
+    json_reverse_iterator& operator++()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
+    }
+
+    /// post-decrement (it--)
+    json_reverse_iterator operator--(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
+    }
+
+    /// pre-decrement (--it)
+    json_reverse_iterator& operator--()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
+    }
+
+    /// add to iterator
+    json_reverse_iterator& operator+=(difference_type i)
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
+    }
+
+    /// add to iterator
+    json_reverse_iterator operator+(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
+    }
+
+    /// subtract from iterator
+    json_reverse_iterator operator-(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
+    }
+
+    /// return difference
+    difference_type operator-(const json_reverse_iterator& other) const
+    {
+        return base_iterator(*this) - base_iterator(other);
+    }
+
+    /// access to successor
+    reference operator[](difference_type n) const
+    {
+        return *(this->operator+(n));
+    }
+
+    /// return the key of an object iterator
+    auto key() const -> decltype(std::declval<Base>().key())
+    {
+        auto it = --this->base();
+        return it.key();
+    }
+
+    /// return the value of an iterator
+    reference value() const
+    {
+        auto it = --this->base();
+        return it.operator * ();
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/json_custom_base_class.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <type_traits> // conditional, is_same
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief Default base class of the @ref basic_json class.
+
+So that the correct implementations of the copy / move ctors / assign operators
+of @ref basic_json do not require complex case distinctions
+(no base class / custom base class used as customization point),
+@ref basic_json always has a base class.
+By default, this class is used because it is empty and thus has no effect
+on the behavior of @ref basic_json.
+*/
+struct json_default_base {};
+
+template<class T>
+using json_base_class = typename std::conditional <
+                        std::is_same<T, void>::value,
+                        json_default_base,
+                        T
+                        >::type;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/json_pointer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // all_of
+#include <cctype> // isdigit
+#include <cerrno> // errno, ERANGE
+#include <cstdlib> // strtoull
+#ifndef JSON_NO_IO
+    #include <iosfwd> // ostream
+#endif  // JSON_NO_IO
+#include <limits> // max
+#include <numeric> // accumulate
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/string_escape.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+/// @sa https://json.nlohmann.me/api/json_pointer/
+template<typename RefStringType>
+class json_pointer
+{
+    // allow basic_json to access private members
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    friend class basic_json;
+
+    template<typename>
+    friend class json_pointer;
+
+    template<typename T>
+    struct string_t_helper
+    {
+        using type = T;
+    };
+
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    struct string_t_helper<NLOHMANN_BASIC_JSON_TPL>
+    {
+        using type = StringType;
+    };
+
+  public:
+    // for backwards compatibility accept BasicJsonType
+    using string_t = typename string_t_helper<RefStringType>::type;
+
+    /// @brief create JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/
+    explicit json_pointer(const string_t& s = "")
+        : reference_tokens(split(s))
+    {}
+
+    /// @brief return a string representation of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
+    string_t to_string() const
+    {
+        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
+                               string_t{},
+                               [](const string_t& a, const string_t& b)
+        {
+            return detail::concat(a, '/', detail::escape(b));
+        });
+    }
+
+    /// @brief return a string representation of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
+    operator string_t() const
+    {
+        return to_string();
+    }
+
+#ifndef JSON_NO_IO
+    /// @brief write string representation of the JSON pointer to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr)
+    {
+        o << ptr.to_string();
+        return o;
+    }
+#endif
+
+    /// @brief append another JSON pointer at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(const json_pointer& ptr)
+    {
+        reference_tokens.insert(reference_tokens.end(),
+                                ptr.reference_tokens.begin(),
+                                ptr.reference_tokens.end());
+        return *this;
+    }
+
+    /// @brief append an unescaped reference token at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(string_t token)
+    {
+        push_back(std::move(token));
+        return *this;
+    }
+
+    /// @brief append an array index at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(std::size_t array_idx)
+    {
+        return *this /= std::to_string(array_idx);
+    }
+
+    /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs,
+                                  const json_pointer& rhs)
+    {
+        return json_pointer(lhs) /= rhs;
+    }
+
+    /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs, string_t token) // NOLINT(performance-unnecessary-value-param)
+    {
+        return json_pointer(lhs) /= std::move(token);
+    }
+
+    /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
+    {
+        return json_pointer(lhs) /= array_idx;
+    }
+
+    /// @brief returns the parent of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/
+    json_pointer parent_pointer() const
+    {
+        if (empty())
+        {
+            return *this;
+        }
+
+        json_pointer res = *this;
+        res.pop_back();
+        return res;
+    }
+
+    /// @brief remove last reference token
+    /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/
+    void pop_back()
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        reference_tokens.pop_back();
+    }
+
+    /// @brief return last reference token
+    /// @sa https://json.nlohmann.me/api/json_pointer/back/
+    const string_t& back() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        return reference_tokens.back();
+    }
+
+    /// @brief append an unescaped token at the end of the reference pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
+    void push_back(const string_t& token)
+    {
+        reference_tokens.push_back(token);
+    }
+
+    /// @brief append an unescaped token at the end of the reference pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
+    void push_back(string_t&& token)
+    {
+        reference_tokens.push_back(std::move(token));
+    }
+
+    /// @brief return whether pointer points to the root document
+    /// @sa https://json.nlohmann.me/api/json_pointer/empty/
+    bool empty() const noexcept
+    {
+        return reference_tokens.empty();
+    }
+
+  private:
+    /*!
+    @param[in] s  reference token to be converted into an array index
+
+    @return integer representation of @a s
+
+    @throw parse_error.106  if an array index begins with '0'
+    @throw parse_error.109  if an array index begins not with a digit
+    @throw out_of_range.404 if string @a s could not be converted to an integer
+    @throw out_of_range.410 if an array index exceeds size_type
+    */
+    template<typename BasicJsonType>
+    static typename BasicJsonType::size_type array_index(const string_t& s)
+    {
+        using size_type = typename BasicJsonType::size_type;
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
+        {
+            JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr));
+        }
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
+        {
+            JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr));
+        }
+
+        const char* p = s.c_str();
+        char* p_end = nullptr;
+        errno = 0; // strtoull doesn't reset errno
+        const unsigned long long res = std::strtoull(p, &p_end, 10); // NOLINT(runtime/int)
+        if (p == p_end // invalid input or empty string
+                || errno == ERANGE // out of range
+                || JSON_HEDLEY_UNLIKELY(static_cast<std::size_t>(p_end - p) != s.size())) // incomplete read
+        {
+            JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr));
+        }
+
+        // only triggered on special platforms (like 32bit), see also
+        // https://github.com/nlohmann/json/pull/2203
+        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))  // NOLINT(runtime/int)
+        {
+            JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr));   // LCOV_EXCL_LINE
+        }
+
+        return static_cast<size_type>(res);
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    json_pointer top() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        json_pointer result = *this;
+        result.reference_tokens = {reference_tokens[0]};
+        return result;
+    }
+
+  private:
+    /*!
+    @brief create and return a reference to the pointed to value
+
+    @complexity Linear in the number of reference tokens.
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.313 if value cannot be unflattened
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_and_create(BasicJsonType& j) const
+    {
+        auto* result = &j;
+
+        // in case no reference tokens exist, return a reference to the JSON value
+        // j which will be overwritten by a primitive value
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (result->type())
+            {
+                case detail::value_t::null:
+                {
+                    if (reference_token == "0")
+                    {
+                        // start a new array if reference token is 0
+                        result = &result->operator[](0);
+                    }
+                    else
+                    {
+                        // start a new object otherwise
+                        result = &result->operator[](reference_token);
+                    }
+                    break;
+                }
+
+                case detail::value_t::object:
+                {
+                    // create an entry in the object
+                    result = &result->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    // create an entry in the array
+                    result = &result->operator[](array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                /*
+                The following code is only reached if there exists a reference
+                token _and_ the current value is primitive. In this case, we have
+                an error situation, because primitive values may only occur as
+                single value; that is, with an empty list of reference tokens.
+                */
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));
+            }
+        }
+
+        return *result;
+    }
+
+    /*!
+    @brief return a reference to the pointed to value
+
+    @note This version does not throw if a value is not present, but tries to
+          create nested values instead. For instance, calling this function
+          with pointer `"/this/that"` on a null value is equivalent to calling
+          `operator[]("this").operator[]("that")` on that value, effectively
+          changing the null value to an object.
+
+    @param[in] ptr  a JSON value
+
+    @return reference to the JSON value pointed to by the JSON pointer
+
+    @complexity Linear in the length of the JSON pointer.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            // convert null values to arrays or objects before continuing
+            if (ptr->is_null())
+            {
+                // check if reference token is a number
+                const bool nums =
+                    std::all_of(reference_token.begin(), reference_token.end(),
+                                [](const unsigned char x)
+                {
+                    return std::isdigit(x);
+                });
+
+                // change value to array for numbers or "-" or to object otherwise
+                *ptr = (nums || reference_token == "-")
+                       ? detail::value_t::array
+                       : detail::value_t::object;
+            }
+
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // explicitly treat "-" as index beyond the end
+                        ptr = &ptr->operator[](ptr->m_data.m_value.array->size());
+                    }
+                    else
+                    {
+                        // convert array index to number; unchecked access
+                        ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
+                    }
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_checked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
+                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
+                                ") is out of range"), ptr));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @brief return a const reference to the pointed to value
+
+    @param[in] ptr  a JSON value
+
+    @return const reference to the JSON value pointed to by the JSON
+    pointer
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" cannot be used for const access
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr));
+                    }
+
+                    // use unchecked array access
+                    ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
+                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
+                                ") is out of range"), ptr));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    */
+    template<typename BasicJsonType>
+    bool contains(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    if (!ptr->contains(reference_token))
+                    {
+                        // we did not find the key in the object
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
+                    {
+                        // invalid char
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
+                        {
+                            // first char should be between '1' and '9'
+                            return false;
+                        }
+                        for (std::size_t i = 1; i < reference_token.size(); i++)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
+                            {
+                                // other char should be between '0' and '9'
+                                return false;
+                            }
+                        }
+                    }
+
+                    const auto idx = array_index<BasicJsonType>(reference_token);
+                    if (idx >= ptr->size())
+                    {
+                        // index out of range
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](idx);
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                {
+                    // we do not expect primitive values if there is still a
+                    // reference token to process
+                    return false;
+                }
+            }
+        }
+
+        // no reference token left means we found a primitive value
+        return true;
+    }
+
+    /*!
+    @brief split the string input to reference tokens
+
+    @note This function is only called by the json_pointer constructor.
+          All exceptions below are documented there.
+
+    @throw parse_error.107  if the pointer is not empty or begins with '/'
+    @throw parse_error.108  if character '~' is not followed by '0' or '1'
+    */
+    static std::vector<string_t> split(const string_t& reference_string)
+    {
+        std::vector<string_t> result;
+
+        // special case: empty reference string -> no reference tokens
+        if (reference_string.empty())
+        {
+            return result;
+        }
+
+        // check if nonempty reference string begins with slash
+        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
+        {
+            JSON_THROW(detail::parse_error::create(107, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr));
+        }
+
+        // extract the reference tokens:
+        // - slash: position of the last read slash (or end of string)
+        // - start: position after the previous slash
+        for (
+            // search for the first slash after the first character
+            std::size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == 0 (if slash == string_t::npos)
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == string_t::npos)
+            start = (slash == string_t::npos) ? 0 : slash + 1,
+            // find next slash
+            slash = reference_string.find_first_of('/', start))
+        {
+            // use the text between the beginning of the reference token
+            // (start) and the last slash (slash).
+            auto reference_token = reference_string.substr(start, slash - start);
+
+            // check reference tokens are properly escaped
+            for (std::size_t pos = reference_token.find_first_of('~');
+                    pos != string_t::npos;
+                    pos = reference_token.find_first_of('~', pos + 1))
+            {
+                JSON_ASSERT(reference_token[pos] == '~');
+
+                // ~ must be followed by 0 or 1
+                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
+                                         (reference_token[pos + 1] != '0' &&
+                                          reference_token[pos + 1] != '1')))
+                {
+                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", nullptr));
+                }
+            }
+
+            // finally, store the reference token
+            detail::unescape(reference_token);
+            result.push_back(reference_token);
+        }
+
+        return result;
+    }
+
+  private:
+    /*!
+    @param[in] reference_string  the reference string to the current value
+    @param[in] value             the value to consider
+    @param[in,out] result        the result object to insert values to
+
+    @note Empty objects or arrays are flattened to `null`.
+    */
+    template<typename BasicJsonType>
+    static void flatten(const string_t& reference_string,
+                        const BasicJsonType& value,
+                        BasicJsonType& result)
+    {
+        switch (value.type())
+        {
+            case detail::value_t::array:
+            {
+                if (value.m_data.m_value.array->empty())
+                {
+                    // flatten empty array as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate array and use index as reference string
+                    for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i)
+                    {
+                        flatten(detail::concat(reference_string, '/', std::to_string(i)),
+                                value.m_data.m_value.array->operator[](i), result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::object:
+            {
+                if (value.m_data.m_value.object->empty())
+                {
+                    // flatten empty object as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate object and use keys as reference string
+                    for (const auto& element : *value.m_data.m_value.object)
+                    {
+                        flatten(detail::concat(reference_string, '/', detail::escape(element.first)), element.second, result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::null:
+            case detail::value_t::string:
+            case detail::value_t::boolean:
+            case detail::value_t::number_integer:
+            case detail::value_t::number_unsigned:
+            case detail::value_t::number_float:
+            case detail::value_t::binary:
+            case detail::value_t::discarded:
+            default:
+            {
+                // add primitive value with its reference string
+                result[reference_string] = value;
+                break;
+            }
+        }
+    }
+
+    /*!
+    @param[in] value  flattened JSON
+
+    @return unflattened JSON
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+    @throw type_error.313  if value cannot be unflattened
+    */
+    template<typename BasicJsonType>
+    static BasicJsonType
+    unflatten(const BasicJsonType& value)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
+        {
+            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", &value));
+        }
+
+        BasicJsonType result;
+
+        // iterate the JSON object values
+        for (const auto& element : *value.m_data.m_value.object)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
+            {
+                JSON_THROW(detail::type_error::create(315, "values in object must be primitive", &element.second));
+            }
+
+            // assign value to reference pointed to by JSON pointer; Note that if
+            // the JSON pointer is "" (i.e., points to the whole value), function
+            // get_and_create returns a reference to result itself. An assignment
+            // will then create a primitive value.
+            json_pointer(element.first).get_and_create(result) = element.second;
+        }
+
+        return result;
+    }
+
+    // can't use conversion operator because of ambiguity
+    json_pointer<string_t> convert() const&
+    {
+        json_pointer<string_t> result;
+        result.reference_tokens = reference_tokens;
+        return result;
+    }
+
+    json_pointer<string_t> convert()&&
+    {
+        json_pointer<string_t> result;
+        result.reference_tokens = std::move(reference_tokens);
+        return result;
+    }
+
+  public:
+#if JSON_HAS_THREE_WAY_COMPARISON
+    /// @brief compares two JSON pointers for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeRhs>
+    bool operator==(const json_pointer<RefStringTypeRhs>& rhs) const noexcept
+    {
+        return reference_tokens == rhs.reference_tokens;
+    }
+
+    /// @brief compares JSON pointer and string for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
+    bool operator==(const string_t& rhs) const
+    {
+        return *this == json_pointer(rhs);
+    }
+
+    /// @brief 3-way compares two JSON pointers
+    template<typename RefStringTypeRhs>
+    std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept // *NOPAD*
+    {
+        return  reference_tokens <=> rhs.reference_tokens; // *NOPAD*
+    }
+#else
+    /// @brief compares two JSON pointers for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+
+    /// @brief compares JSON pointer and string for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeLhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                           const StringType& rhs);
+
+    /// @brief compares string and JSON pointer for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeRhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const StringType& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs);
+
+    /// @brief compares two JSON pointers for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+
+    /// @brief compares JSON pointer and string for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeLhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                           const StringType& rhs);
+
+    /// @brief compares string and JSON pointer for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeRhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const StringType& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs);
+
+    /// @brief compares two JSON pointer for less-than
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
+                          const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+#endif
+
+  private:
+    /// the reference tokens
+    std::vector<string_t> reference_tokens;
+};
+
+#if !JSON_HAS_THREE_WAY_COMPARISON
+// functions cannot be defined inside class due to ODR violations
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return lhs.reference_tokens == rhs.reference_tokens;
+}
+
+template<typename RefStringTypeLhs,
+         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
+inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                       const StringType& rhs)
+{
+    return lhs == json_pointer<RefStringTypeLhs>(rhs);
+}
+
+template<typename RefStringTypeRhs,
+         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
+inline bool operator==(const StringType& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs)
+{
+    return json_pointer<RefStringTypeRhs>(lhs) == rhs;
+}
+
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeLhs,
+         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
+inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                       const StringType& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeRhs,
+         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
+inline bool operator!=(const StringType& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
+                      const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return lhs.reference_tokens < rhs.reference_tokens;
+}
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/json_ref.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <initializer_list>
+#include <utility>
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename BasicJsonType>
+class json_ref
+{
+  public:
+    using value_type = BasicJsonType;
+
+    json_ref(value_type&& value)
+        : owned_value(std::move(value))
+    {}
+
+    json_ref(const value_type& value)
+        : value_ref(&value)
+    {}
+
+    json_ref(std::initializer_list<json_ref> init)
+        : owned_value(init)
+    {}
+
+    template <
+        class... Args,
+        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
+    json_ref(Args && ... args)
+        : owned_value(std::forward<Args>(args)...)
+    {}
+
+    // class should be movable only
+    json_ref(json_ref&&) noexcept = default;
+    json_ref(const json_ref&) = delete;
+    json_ref& operator=(const json_ref&) = delete;
+    json_ref& operator=(json_ref&&) = delete;
+    ~json_ref() = default;
+
+    value_type moved_or_copied() const
+    {
+        if (value_ref == nullptr)
+        {
+            return std::move(owned_value);
+        }
+        return *value_ref;
+    }
+
+    value_type const& operator*() const
+    {
+        return value_ref ? *value_ref : owned_value;
+    }
+
+    value_type const* operator->() const
+    {
+        return &** this;
+    }
+
+  private:
+    mutable value_type owned_value = nullptr;
+    value_type const* value_ref = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/string_escape.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // reverse
+#include <array> // array
+#include <map> // map
+#include <cmath> // isnan, isinf
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstring> // memcpy
+#include <limits> // numeric_limits
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // copy
+#include <cstddef> // size_t
+#include <iterator> // back_inserter
+#include <memory> // shared_ptr, make_shared
+#include <string> // basic_string
+#include <vector> // vector
+
+#ifndef JSON_NO_IO
+    #include <ios>      // streamsize
+    #include <ostream>  // basic_ostream
+#endif  // JSON_NO_IO
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// abstract output adapter interface
+template<typename CharType> struct output_adapter_protocol
+{
+    virtual void write_character(CharType c) = 0;
+    virtual void write_characters(const CharType* s, std::size_t length) = 0;
+    virtual ~output_adapter_protocol() = default;
+
+    output_adapter_protocol() = default;
+    output_adapter_protocol(const output_adapter_protocol&) = default;
+    output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
+    output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
+    output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
+};
+
+/// a type to simplify interfaces
+template<typename CharType>
+using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
+
+/// output adapter for byte vectors
+template<typename CharType, typename AllocatorType = std::allocator<CharType>>
+class output_vector_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
+        : v(vec)
+    {}
+
+    void write_character(CharType c) override
+    {
+        v.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        v.insert(v.end(), s, s + length);
+    }
+
+  private:
+    std::vector<CharType, AllocatorType>& v;
+};
+
+#ifndef JSON_NO_IO
+/// output adapter for output streams
+template<typename CharType>
+class output_stream_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
+        : stream(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        stream.put(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        stream.write(s, static_cast<std::streamsize>(length));
+    }
+
+  private:
+    std::basic_ostream<CharType>& stream;
+};
+#endif  // JSON_NO_IO
+
+/// output adapter for basic_string
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_string_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_string_adapter(StringType& s) noexcept
+        : str(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        str.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        str.append(s, length);
+    }
+
+  private:
+    StringType& str;
+};
+
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_adapter
+{
+  public:
+    template<typename AllocatorType = std::allocator<CharType>>
+    output_adapter(std::vector<CharType, AllocatorType>& vec)
+        : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
+
+#ifndef JSON_NO_IO
+    output_adapter(std::basic_ostream<CharType>& s)
+        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
+#endif  // JSON_NO_IO
+
+    output_adapter(StringType& s)
+        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
+
+    operator output_adapter_t<CharType>()
+    {
+        return oa;
+    }
+
+  private:
+    output_adapter_t<CharType> oa = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////////////
+// binary writer //
+///////////////////
+
+/*!
+@brief serialization to CBOR and MessagePack values
+*/
+template<typename BasicJsonType, typename CharType>
+class binary_writer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+  public:
+    /*!
+    @brief create a binary writer
+
+    @param[in] adapter  output adapter to write to
+    */
+    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
+    {
+        JSON_ASSERT(oa);
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+            {
+                write_bson_object(*j.m_data.m_value.object);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::array:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                JSON_THROW(type_error::create(317, concat("to serialize to BSON, top-level type must be object, but is ", j.type_name()), &j));
+            }
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_cbor(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                oa->write_character(to_char_type(0xF6));
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                oa->write_character(j.m_data.m_value.boolean
+                                    ? to_char_type(0xF5)
+                                    : to_char_type(0xF4));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers. Therefore, we used the
+                    // code from the value_t::number_unsigned case here.
+                    if (j.m_data.m_value.number_integer <= 0x17)
+                    {
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x18));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x19));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x1A));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x1B));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    // The conversions below encode the sign in the first
+                    // byte, and the value is converted to a positive number.
+                    const auto positive_number = -1 - j.m_data.m_value.number_integer;
+                    if (j.m_data.m_value.number_integer >= -24)
+                    {
+                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x38));
+                        write_number(static_cast<std::uint8_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x39));
+                        write_number(static_cast<std::uint16_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x3A));
+                        write_number(static_cast<std::uint32_t>(positive_number));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x3B));
+                        write_number(static_cast<std::uint64_t>(positive_number));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x18));
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x19));
+                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x1A));
+                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_unsigned));
+                }
+                else
+                {
+                    oa->write_character(to_char_type(0x1B));
+                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                if (std::isnan(j.m_data.m_value.number_float))
+                {
+                    // NaN is 0xf97e00 in CBOR
+                    oa->write_character(to_char_type(0xF9));
+                    oa->write_character(to_char_type(0x7E));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else if (std::isinf(j.m_data.m_value.number_float))
+                {
+                    // Infinity is 0xf97c00, -Infinity is 0xf9fc00
+                    oa->write_character(to_char_type(0xf9));
+                    oa->write_character(j.m_data.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else
+                {
+                    write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::cbor);
+                }
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_data.m_value.string->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x60 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x78));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x79));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_data.m_value.array->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x80 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x98));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x99));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_cbor(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (j.m_data.m_value.binary->has_subtype())
+                {
+                    if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xd8));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xd9));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xda));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xdb));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                }
+
+                // step 1: write control byte and the binary array size
+                const auto N = j.m_data.m_value.binary->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x40 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x58));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x59));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_data.m_value.object->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0xA0 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB8));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB9));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBA));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBB));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_cbor(el.first);
+                    write_cbor(el.second);
+                }
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_msgpack(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null: // nil
+            {
+                oa->write_character(to_char_type(0xC0));
+                break;
+            }
+
+            case value_t::boolean: // true and false
+            {
+                oa->write_character(j.m_data.m_value.boolean
+                                    ? to_char_type(0xC3)
+                                    : to_char_type(0xC2));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers. Therefore, we used
+                    // the code from the value_t::number_unsigned case here.
+                    if (j.m_data.m_value.number_unsigned < 128)
+                    {
+                        // positive fixnum
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        // uint 8
+                        oa->write_character(to_char_type(0xCC));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        // uint 16
+                        oa->write_character(to_char_type(0xCD));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        // uint 32
+                        oa->write_character(to_char_type(0xCE));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        // uint 64
+                        oa->write_character(to_char_type(0xCF));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    if (j.m_data.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                    {
+                        // int 8
+                        oa->write_character(to_char_type(0xD0));
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                    {
+                        // int 16
+                        oa->write_character(to_char_type(0xD1));
+                        write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                    {
+                        // int 32
+                        oa->write_character(to_char_type(0xD2));
+                        write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                    {
+                        // int 64
+                        oa->write_character(to_char_type(0xD3));
+                        write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned < 128)
+                {
+                    // positive fixnum
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // uint 8
+                    oa->write_character(to_char_type(0xCC));
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // uint 16
+                    oa->write_character(to_char_type(0xCD));
+                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // uint 32
+                    oa->write_character(to_char_type(0xCE));
+                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    // uint 64
+                    oa->write_character(to_char_type(0xCF));
+                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::msgpack);
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_data.m_value.string->size();
+                if (N <= 31)
+                {
+                    // fixstr
+                    write_number(static_cast<std::uint8_t>(0xA0 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // str 8
+                    oa->write_character(to_char_type(0xD9));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // str 16
+                    oa->write_character(to_char_type(0xDA));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // str 32
+                    oa->write_character(to_char_type(0xDB));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_data.m_value.array->size();
+                if (N <= 15)
+                {
+                    // fixarray
+                    write_number(static_cast<std::uint8_t>(0x90 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // array 16
+                    oa->write_character(to_char_type(0xDC));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // array 32
+                    oa->write_character(to_char_type(0xDD));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_msgpack(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                // step 0: determine if the binary type has a set subtype to
+                // determine whether or not to use the ext or fixext types
+                const bool use_ext = j.m_data.m_value.binary->has_subtype();
+
+                // step 1: write control byte and the byte string length
+                const auto N = j.m_data.m_value.binary->size();
+                if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    std::uint8_t output_type{};
+                    bool fixed = true;
+                    if (use_ext)
+                    {
+                        switch (N)
+                        {
+                            case 1:
+                                output_type = 0xD4; // fixext 1
+                                break;
+                            case 2:
+                                output_type = 0xD5; // fixext 2
+                                break;
+                            case 4:
+                                output_type = 0xD6; // fixext 4
+                                break;
+                            case 8:
+                                output_type = 0xD7; // fixext 8
+                                break;
+                            case 16:
+                                output_type = 0xD8; // fixext 16
+                                break;
+                            default:
+                                output_type = 0xC7; // ext 8
+                                fixed = false;
+                                break;
+                        }
+
+                    }
+                    else
+                    {
+                        output_type = 0xC4; // bin 8
+                        fixed = false;
+                    }
+
+                    oa->write_character(to_char_type(output_type));
+                    if (!fixed)
+                    {
+                        write_number(static_cast<std::uint8_t>(N));
+                    }
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    const std::uint8_t output_type = use_ext
+                                                     ? 0xC8 // ext 16
+                                                     : 0xC5; // bin 16
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    const std::uint8_t output_type = use_ext
+                                                     ? 0xC9 // ext 32
+                                                     : 0xC6; // bin 32
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 1.5: if this is an ext type, write the subtype
+                if (use_ext)
+                {
+                    write_number(static_cast<std::int8_t>(j.m_data.m_value.binary->subtype()));
+                }
+
+                // step 2: write the byte string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_data.m_value.object->size();
+                if (N <= 15)
+                {
+                    // fixmap
+                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // map 16
+                    oa->write_character(to_char_type(0xDE));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // map 32
+                    oa->write_character(to_char_type(0xDF));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_msgpack(el.first);
+                    write_msgpack(el.second);
+                }
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @param[in] use_count   whether to use '#' prefixes (optimized format)
+    @param[in] use_type    whether to use '$' prefixes (optimized format)
+    @param[in] add_prefix  whether prefixes need to be used for this value
+    @param[in] use_bjdata  whether write in BJData format, default is false
+    */
+    void write_ubjson(const BasicJsonType& j, const bool use_count,
+                      const bool use_type, const bool add_prefix = true,
+                      const bool use_bjdata = false)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('Z'));
+                }
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(j.m_data.m_value.boolean
+                                        ? to_char_type('T')
+                                        : to_char_type('F'));
+                }
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_integer, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_unsigned, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_float, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::string:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('S'));
+                }
+                write_number_with_ubjson_prefix(j.m_data.m_value.string->size(), true, use_bjdata);
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_data.m_value.array->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
+                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
+                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v, use_bjdata) == first_prefix;
+                    });
+
+                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
+
+                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.array->size(), true, use_bjdata);
+                }
+
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_ubjson(el, use_count, use_type, prefix_required, use_bjdata);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                if (use_type && !j.m_data.m_value.binary->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    oa->write_character(to_char_type('$'));
+                    oa->write_character('U');
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.binary->size(), true, use_bjdata);
+                }
+
+                if (use_type)
+                {
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                        j.m_data.m_value.binary->size());
+                }
+                else
+                {
+                    for (size_t i = 0; i < j.m_data.m_value.binary->size(); ++i)
+                    {
+                        oa->write_character(to_char_type('U'));
+                        oa->write_character(j.m_data.m_value.binary->data()[i]);
+                    }
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                if (use_bjdata && j.m_data.m_value.object->size() == 3 && j.m_data.m_value.object->find("_ArrayType_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArraySize_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArrayData_") != j.m_data.m_value.object->end())
+                {
+                    if (!write_bjdata_ndarray(*j.m_data.m_value.object, use_count, use_type))  // decode bjdata ndarray in the JData format (https://github.com/NeuroJSON/jdata)
+                    {
+                        break;
+                    }
+                }
+
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('{'));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_data.m_value.object->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
+                    const bool same_prefix = std::all_of(j.begin(), j.end(),
+                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v, use_bjdata) == first_prefix;
+                    });
+
+                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
+
+                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.object->size(), true, use_bjdata);
+                }
+
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata);
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(el.first.c_str()),
+                        el.first.size());
+                    write_ubjson(el.second, use_count, use_type, prefix_required, use_bjdata);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type('}'));
+                }
+
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @return The size of a BSON document entry header, including the id marker
+            and the entry name size (and its null-terminator).
+    */
+    static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
+    {
+        const auto it = name.find(static_cast<typename string_t::value_type>(0));
+        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
+        {
+            JSON_THROW(out_of_range::create(409, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j));
+            static_cast<void>(j);
+        }
+
+        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
+    }
+
+    /*!
+    @brief Writes the given @a element_type and @a name to the output adapter
+    */
+    void write_bson_entry_header(const string_t& name,
+                                 const std::uint8_t element_type)
+    {
+        oa->write_character(to_char_type(element_type)); // boolean
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(name.c_str()),
+            name.size() + 1u);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and boolean value @a value
+    */
+    void write_bson_boolean(const string_t& name,
+                            const bool value)
+    {
+        write_bson_entry_header(name, 0x08);
+        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and double value @a value
+    */
+    void write_bson_double(const string_t& name,
+                           const double value)
+    {
+        write_bson_entry_header(name, 0x01);
+        write_number<double>(value, true);
+    }
+
+    /*!
+    @return The size of the BSON-encoded string in @a value
+    */
+    static std::size_t calc_bson_string_size(const string_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and string value @a value
+    */
+    void write_bson_string(const string_t& name,
+                           const string_t& value)
+    {
+        write_bson_entry_header(name, 0x02);
+
+        write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul), true);
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(value.c_str()),
+            value.size() + 1);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and null value
+    */
+    void write_bson_null(const string_t& name)
+    {
+        write_bson_entry_header(name, 0x0A);
+    }
+
+    /*!
+    @return The size of the BSON-encoded integer @a value
+    */
+    static std::size_t calc_bson_integer_size(const std::int64_t value)
+    {
+        return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and integer @a value
+    */
+    void write_bson_integer(const string_t& name,
+                            const std::int64_t value)
+    {
+        if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            write_bson_entry_header(name, 0x10); // int32
+            write_number<std::int32_t>(static_cast<std::int32_t>(value), true);
+        }
+        else
+        {
+            write_bson_entry_header(name, 0x12); // int64
+            write_number<std::int64_t>(static_cast<std::int64_t>(value), true);
+        }
+    }
+
+    /*!
+    @return The size of the BSON-encoded unsigned integer in @a j
+    */
+    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
+    {
+        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and unsigned @a value
+    */
+    void write_bson_unsigned(const string_t& name,
+                             const BasicJsonType& j)
+    {
+        if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x10 /* int32 */);
+            write_number<std::int32_t>(static_cast<std::int32_t>(j.m_data.m_value.number_unsigned), true);
+        }
+        else if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x12 /* int64 */);
+            write_number<std::int64_t>(static_cast<std::int64_t>(j.m_data.m_value.number_unsigned), true);
+        }
+        else
+        {
+            JSON_THROW(out_of_range::create(407, concat("integer number ", std::to_string(j.m_data.m_value.number_unsigned), " cannot be represented by BSON as it does not fit int64"), &j));
+        }
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and object @a value
+    */
+    void write_bson_object_entry(const string_t& name,
+                                 const typename BasicJsonType::object_t& value)
+    {
+        write_bson_entry_header(name, 0x03); // object
+        write_bson_object(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded array @a value
+    */
+    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
+    {
+        std::size_t array_index = 0ul;
+
+        const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
+        {
+            return result + calc_bson_element_size(std::to_string(array_index++), el);
+        });
+
+        return sizeof(std::int32_t) + embedded_document_size + 1ul;
+    }
+
+    /*!
+    @return The size of the BSON-encoded binary array @a value
+    */
+    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and array @a value
+    */
+    void write_bson_array(const string_t& name,
+                          const typename BasicJsonType::array_t& value)
+    {
+        write_bson_entry_header(name, 0x04); // array
+        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_array_size(value)), true);
+
+        std::size_t array_index = 0ul;
+
+        for (const auto& el : value)
+        {
+            write_bson_element(std::to_string(array_index++), el);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and binary value @a value
+    */
+    void write_bson_binary(const string_t& name,
+                           const binary_t& value)
+    {
+        write_bson_entry_header(name, 0x05);
+
+        write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true);
+        write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
+
+        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
+    }
+
+    /*!
+    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
+    @return The calculated size for the BSON document entry for @a j with the given @a name.
+    */
+    static std::size_t calc_bson_element_size(const string_t& name,
+            const BasicJsonType& j)
+    {
+        const auto header_size = calc_bson_entry_header_size(name, j);
+        switch (j.type())
+        {
+            case value_t::object:
+                return header_size + calc_bson_object_size(*j.m_data.m_value.object);
+
+            case value_t::array:
+                return header_size + calc_bson_array_size(*j.m_data.m_value.array);
+
+            case value_t::binary:
+                return header_size + calc_bson_binary_size(*j.m_data.m_value.binary);
+
+            case value_t::boolean:
+                return header_size + 1ul;
+
+            case value_t::number_float:
+                return header_size + 8ul;
+
+            case value_t::number_integer:
+                return header_size + calc_bson_integer_size(j.m_data.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return header_size + calc_bson_unsigned_size(j.m_data.m_value.number_unsigned);
+
+            case value_t::string:
+                return header_size + calc_bson_string_size(*j.m_data.m_value.string);
+
+            case value_t::null:
+                return header_size + 0ul;
+
+            // LCOV_EXCL_START
+            case value_t::discarded:
+            default:
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+                return 0ul;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Serializes the JSON value @a j to BSON and associates it with the
+           key @a name.
+    @param name The name to associate with the JSON entity @a j within the
+                current BSON document
+    */
+    void write_bson_element(const string_t& name,
+                            const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+                return write_bson_object_entry(name, *j.m_data.m_value.object);
+
+            case value_t::array:
+                return write_bson_array(name, *j.m_data.m_value.array);
+
+            case value_t::binary:
+                return write_bson_binary(name, *j.m_data.m_value.binary);
+
+            case value_t::boolean:
+                return write_bson_boolean(name, j.m_data.m_value.boolean);
+
+            case value_t::number_float:
+                return write_bson_double(name, j.m_data.m_value.number_float);
+
+            case value_t::number_integer:
+                return write_bson_integer(name, j.m_data.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return write_bson_unsigned(name, j);
+
+            case value_t::string:
+                return write_bson_string(name, *j.m_data.m_value.string);
+
+            case value_t::null:
+                return write_bson_null(name);
+
+            // LCOV_EXCL_START
+            case value_t::discarded:
+            default:
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+                return;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Calculates the size of the BSON serialization of the given
+           JSON-object @a j.
+    @param[in] value  JSON value to serialize
+    @pre       value.type() == value_t::object
+    */
+    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
+    {
+        const std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
+                                          [](size_t result, const typename BasicJsonType::object_t::value_type & el)
+        {
+            return result += calc_bson_element_size(el.first, el.second);
+        });
+
+        return sizeof(std::int32_t) + document_size + 1ul;
+    }
+
+    /*!
+    @param[in] value  JSON value to serialize
+    @pre       value.type() == value_t::object
+    */
+    void write_bson_object(const typename BasicJsonType::object_t& value)
+    {
+        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_object_size(value)), true);
+
+        for (const auto& el : value)
+        {
+            write_bson_element(el.first, el.second);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xFA);  // Single-Precision Float
+    }
+
+    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xFB);  // Double-Precision Float
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xCA);  // float 32
+    }
+
+    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xCB);  // float 64
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    // UBJSON: write number (floating point)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_floating_point<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if (add_prefix)
+        {
+            oa->write_character(get_ubjson_float_prefix(n));
+        }
+        write_number(n, use_bjdata);
+    }
+
+    // UBJSON: write number (unsigned integer)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_unsigned<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if (n <= (std::numeric_limits<std::uint8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
+            }
+            write_number(static_cast<std::uint16_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
+            }
+            write_number(static_cast<std::uint32_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= (std::numeric_limits<uint64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('M'));  // uint64 - bjdata only
+            }
+            write_number(static_cast<std::uint64_t>(n), use_bjdata);
+        }
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+    }
+
+    // UBJSON: write number (signed integer)
+    template < typename NumberType, typename std::enable_if <
+                   std::is_signed<NumberType>::value&&
+                   !std::is_floating_point<NumberType>::value, int >::type = 0 >
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::int8_t>(n), use_bjdata);
+        }
+        else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::max)())))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
+            }
+            write_number(static_cast<uint16_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::max)())))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
+            }
+            write_number(static_cast<uint32_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n), use_bjdata);
+        }
+        // LCOV_EXCL_START
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+        // LCOV_EXCL_STOP
+    }
+
+    /*!
+    @brief determine the type prefix of container values
+    */
+    CharType ubjson_prefix(const BasicJsonType& j, const bool use_bjdata) const noexcept
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+                return 'Z';
+
+            case value_t::boolean:
+                return j.m_data.m_value.boolean ? 'T' : 'F';
+
+            case value_t::number_integer:
+            {
+                if ((std::numeric_limits<std::int8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                {
+                    return 'i';
+                }
+                if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    return 'U';
+                }
+                if ((std::numeric_limits<std::int16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                {
+                    return 'I';
+                }
+                if (use_bjdata && ((std::numeric_limits<std::uint16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)()))
+                {
+                    return 'u';
+                }
+                if ((std::numeric_limits<std::int32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                {
+                    return 'l';
+                }
+                if (use_bjdata && ((std::numeric_limits<std::uint32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)()))
+                {
+                    return 'm';
+                }
+                if ((std::numeric_limits<std::int64_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                {
+                    return 'L';
+                }
+                // anything else is treated as high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+                {
+                    return 'i';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
+                {
+                    return 'U';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+                {
+                    return 'I';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint16_t>::max)()))
+                {
+                    return 'u';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+                {
+                    return 'l';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)()))
+                {
+                    return 'm';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+                {
+                    return 'L';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    return 'M';
+                }
+                // anything else is treated as high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_float:
+                return get_ubjson_float_prefix(j.m_data.m_value.number_float);
+
+            case value_t::string:
+                return 'S';
+
+            case value_t::array: // fallthrough
+            case value_t::binary:
+                return '[';
+
+            case value_t::object:
+                return '{';
+
+            case value_t::discarded:
+            default:  // discarded values
+                return 'N';
+        }
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
+    {
+        return 'd';  // float 32
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
+    {
+        return 'D';  // float 64
+    }
+
+    /*!
+    @return false if the object is successfully converted to a bjdata ndarray, true if the type or size is invalid
+    */
+    bool write_bjdata_ndarray(const typename BasicJsonType::object_t& value, const bool use_count, const bool use_type)
+    {
+        std::map<string_t, CharType> bjdtype = {{"uint8", 'U'},  {"int8", 'i'},  {"uint16", 'u'}, {"int16", 'I'},
+            {"uint32", 'm'}, {"int32", 'l'}, {"uint64", 'M'}, {"int64", 'L'}, {"single", 'd'}, {"double", 'D'}, {"char", 'C'}
+        };
+
+        string_t key = "_ArrayType_";
+        auto it = bjdtype.find(static_cast<string_t>(value.at(key)));
+        if (it == bjdtype.end())
+        {
+            return true;
+        }
+        CharType dtype = it->second;
+
+        key = "_ArraySize_";
+        std::size_t len = (value.at(key).empty() ? 0 : 1);
+        for (const auto& el : value.at(key))
+        {
+            len *= static_cast<std::size_t>(el.m_data.m_value.number_unsigned);
+        }
+
+        key = "_ArrayData_";
+        if (value.at(key).size() != len)
+        {
+            return true;
+        }
+
+        oa->write_character('[');
+        oa->write_character('$');
+        oa->write_character(dtype);
+        oa->write_character('#');
+
+        key = "_ArraySize_";
+        write_ubjson(value.at(key), use_count, use_type, true,  true);
+
+        key = "_ArrayData_";
+        if (dtype == 'U' || dtype == 'C')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint8_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'i')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int8_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'u')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint16_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'I')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int16_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'm')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint32_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'l')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int32_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'M')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint64_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'L')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int64_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'd')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<float>(el.m_data.m_value.number_float), true);
+            }
+        }
+        else if (dtype == 'D')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<double>(el.m_data.m_value.number_float), true);
+            }
+        }
+        return false;
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*
+    @brief write a number to output input
+    @param[in] n number of type @a NumberType
+    @param[in] OutputIsLittleEndian Set to true if output data is
+                                 required to be little endian
+    @tparam NumberType the type of the number
+
+    @note This function needs to respect the system's endianness, because bytes
+          in CBOR, MessagePack, and UBJSON are stored in network order (big
+          endian) and therefore need reordering on little endian systems.
+          On the other hand, BSON and BJData use little endian and should reorder
+          on big endian systems.
+    */
+    template<typename NumberType>
+    void write_number(const NumberType n, const bool OutputIsLittleEndian = false)
+    {
+        // step 1: write number to array of length NumberType
+        std::array<CharType, sizeof(NumberType)> vec{};
+        std::memcpy(vec.data(), &n, sizeof(NumberType));
+
+        // step 2: write array to output (with possible reordering)
+        if (is_little_endian != OutputIsLittleEndian)
+        {
+            // reverse byte order prior to conversion if necessary
+            std::reverse(vec.begin(), vec.end());
+        }
+
+        oa->write_characters(vec.data(), sizeof(NumberType));
+    }
+
+    void write_compact_float(const number_float_t n, detail::input_format_t format)
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
+                static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
+                static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(static_cast<float>(n))
+                                : get_msgpack_float_prefix(static_cast<float>(n)));
+            write_number(static_cast<float>(n));
+        }
+        else
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(n)
+                                : get_msgpack_float_prefix(n));
+            write_number(n);
+        }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+  public:
+    // The following to_char_type functions are implement the conversion
+    // between uint8_t and CharType. In case CharType is not unsigned,
+    // such a conversion is required to allow values greater than 128.
+    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return *reinterpret_cast<char*>(&x);
+    }
+
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
+    static CharType to_char_type(std::uint8_t x) noexcept
+    {
+        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
+        static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
+        CharType result;
+        std::memcpy(&result, &x, sizeof(x));
+        return result;
+    }
+
+    template<typename C = CharType,
+             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return x;
+    }
+
+    template < typename InputCharType, typename C = CharType,
+               enable_if_t <
+                   std::is_signed<C>::value &&
+                   std::is_signed<char>::value &&
+                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
+                   > * = nullptr >
+    static constexpr CharType to_char_type(InputCharType x) noexcept
+    {
+        return x;
+    }
+
+  private:
+    /// whether we can assume little endianness
+    const bool is_little_endian = little_endianness();
+
+    /// the output
+    output_adapter_t<CharType> oa = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/output/serializer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2008-2009 Björn Hoehrmann <bjoern@hoehrmann.de>
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // reverse, remove, fill, find, none_of
+#include <array> // array
+#include <clocale> // localeconv, lconv
+#include <cmath> // labs, isfinite, isnan, signbit
+#include <cstddef> // size_t, ptrdiff_t
+#include <cstdint> // uint8_t
+#include <cstdio> // snprintf
+#include <limits> // numeric_limits
+#include <string> // string, char_traits
+#include <iomanip> // setfill, setw
+#include <type_traits> // is_same
+#include <utility> // move
+
+// #include <nlohmann/detail/conversions/to_chars.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2009 Florian Loitsch <https://florian.loitsch.com/>
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cmath>   // signbit, isfinite
+#include <cstdint> // intN_t, uintN_t
+#include <cstring> // memcpy, memmove
+#include <limits> // numeric_limits
+#include <type_traits> // conditional
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief implements the Grisu2 algorithm for binary to decimal floating-point
+conversion.
+
+This implementation is a slightly modified version of the reference
+implementation which may be obtained from
+http://florian.loitsch.com/publications (bench.tar.gz).
+
+The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
+
+For a detailed description of the algorithm see:
+
+[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
+    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
+    Language Design and Implementation, PLDI 2010
+[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
+    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
+    Design and Implementation, PLDI 1996
+*/
+namespace dtoa_impl
+{
+
+template<typename Target, typename Source>
+Target reinterpret_bits(const Source source)
+{
+    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
+
+    Target target;
+    std::memcpy(&target, &source, sizeof(Source));
+    return target;
+}
+
+struct diyfp // f * 2^e
+{
+    static constexpr int kPrecision = 64; // = q
+
+    std::uint64_t f = 0;
+    int e = 0;
+
+    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
+
+    /*!
+    @brief returns x - y
+    @pre x.e == y.e and x.f >= y.f
+    */
+    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
+    {
+        JSON_ASSERT(x.e == y.e);
+        JSON_ASSERT(x.f >= y.f);
+
+        return {x.f - y.f, x.e};
+    }
+
+    /*!
+    @brief returns x * y
+    @note The result is rounded. (Only the upper q bits are returned.)
+    */
+    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
+    {
+        static_assert(kPrecision == 64, "internal error");
+
+        // Computes:
+        //  f = round((x.f * y.f) / 2^q)
+        //  e = x.e + y.e + q
+
+        // Emulate the 64-bit * 64-bit multiplication:
+        //
+        // p = u * v
+        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
+        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
+        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
+        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
+        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
+        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
+        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
+        //
+        // (Since Q might be larger than 2^32 - 1)
+        //
+        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
+        //
+        // (Q_hi + H does not overflow a 64-bit int)
+        //
+        //   = p_lo + 2^64 p_hi
+
+        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
+        const std::uint64_t u_hi = x.f >> 32u;
+        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
+        const std::uint64_t v_hi = y.f >> 32u;
+
+        const std::uint64_t p0 = u_lo * v_lo;
+        const std::uint64_t p1 = u_lo * v_hi;
+        const std::uint64_t p2 = u_hi * v_lo;
+        const std::uint64_t p3 = u_hi * v_hi;
+
+        const std::uint64_t p0_hi = p0 >> 32u;
+        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
+        const std::uint64_t p1_hi = p1 >> 32u;
+        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
+        const std::uint64_t p2_hi = p2 >> 32u;
+
+        std::uint64_t Q = p0_hi + p1_lo + p2_lo;
+
+        // The full product might now be computed as
+        //
+        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
+        // p_lo = p0_lo + (Q << 32)
+        //
+        // But in this particular case here, the full p_lo is not required.
+        // Effectively we only need to add the highest bit in p_lo to p_hi (and
+        // Q_hi + 1 does not overflow).
+
+        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
+
+        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
+
+        return {h, x.e + y.e + 64};
+    }
+
+    /*!
+    @brief normalize x such that the significand is >= 2^(q-1)
+    @pre x.f != 0
+    */
+    static diyfp normalize(diyfp x) noexcept
+    {
+        JSON_ASSERT(x.f != 0);
+
+        while ((x.f >> 63u) == 0)
+        {
+            x.f <<= 1u;
+            x.e--;
+        }
+
+        return x;
+    }
+
+    /*!
+    @brief normalize x such that the result has the exponent E
+    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
+    */
+    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
+    {
+        const int delta = x.e - target_exponent;
+
+        JSON_ASSERT(delta >= 0);
+        JSON_ASSERT(((x.f << delta) >> delta) == x.f);
+
+        return {x.f << delta, target_exponent};
+    }
+};
+
+struct boundaries
+{
+    diyfp w;
+    diyfp minus;
+    diyfp plus;
+};
+
+/*!
+Compute the (normalized) diyfp representing the input number 'value' and its
+boundaries.
+
+@pre value must be finite and positive
+*/
+template<typename FloatType>
+boundaries compute_boundaries(FloatType value)
+{
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // Convert the IEEE representation into a diyfp.
+    //
+    // If v is denormal:
+    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
+    // If v is normalized:
+    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
+
+    static_assert(std::numeric_limits<FloatType>::is_iec559,
+                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
+
+    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
+    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
+    constexpr int      kMinExp    = 1 - kBias;
+    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
+
+    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
+
+    const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
+    const std::uint64_t E = bits >> (kPrecision - 1);
+    const std::uint64_t F = bits & (kHiddenBit - 1);
+
+    const bool is_denormal = E == 0;
+    const diyfp v = is_denormal
+                    ? diyfp(F, kMinExp)
+                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
+
+    // Compute the boundaries m- and m+ of the floating-point value
+    // v = f * 2^e.
+    //
+    // Determine v- and v+, the floating-point predecessor and successor if v,
+    // respectively.
+    //
+    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
+    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
+    //
+    //      v+ = v + 2^e
+    //
+    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
+    // between m- and m+ round to v, regardless of how the input rounding
+    // algorithm breaks ties.
+    //
+    //      ---+-------------+-------------+-------------+-------------+---  (A)
+    //         v-            m-            v             m+            v+
+    //
+    //      -----------------+------+------+-------------+-------------+---  (B)
+    //                       v-     m-     v             m+            v+
+
+    const bool lower_boundary_is_closer = F == 0 && E > 1;
+    const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
+    const diyfp m_minus = lower_boundary_is_closer
+                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)
+                          : diyfp(2 * v.f - 1, v.e - 1); // (A)
+
+    // Determine the normalized w+ = m+.
+    const diyfp w_plus = diyfp::normalize(m_plus);
+
+    // Determine w- = m- such that e_(w-) = e_(w+).
+    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
+
+    return {diyfp::normalize(v), w_minus, w_plus};
+}
+
+// Given normalized diyfp w, Grisu needs to find a (normalized) cached
+// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
+// within a certain range [alpha, gamma] (Definition 3.2 from [1])
+//
+//      alpha <= e = e_c + e_w + q <= gamma
+//
+// or
+//
+//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
+//                          <= f_c * f_w * 2^gamma
+//
+// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
+//
+//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
+//
+// or
+//
+//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
+//
+// The choice of (alpha,gamma) determines the size of the table and the form of
+// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
+// in practice:
+//
+// The idea is to cut the number c * w = f * 2^e into two parts, which can be
+// processed independently: An integral part p1, and a fractional part p2:
+//
+//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
+//              = (f div 2^-e) + (f mod 2^-e) * 2^e
+//              = p1 + p2 * 2^e
+//
+// The conversion of p1 into decimal form requires a series of divisions and
+// modulos by (a power of) 10. These operations are faster for 32-bit than for
+// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
+// achieved by choosing
+//
+//      -e >= 32   or   e <= -32 := gamma
+//
+// In order to convert the fractional part
+//
+//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
+//
+// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
+// d[-i] are extracted in order:
+//
+//      (10 * p2) div 2^-e = d[-1]
+//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
+//
+// The multiplication by 10 must not overflow. It is sufficient to choose
+//
+//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
+//
+// Since p2 = f mod 2^-e < 2^-e,
+//
+//      -e <= 60   or   e >= -60 := alpha
+
+constexpr int kAlpha = -60;
+constexpr int kGamma = -32;
+
+struct cached_power // c = f * 2^e ~= 10^k
+{
+    std::uint64_t f;
+    int e;
+    int k;
+};
+
+/*!
+For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
+power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
+satisfies (Definition 3.2 from [1])
+
+     alpha <= e_c + e + q <= gamma.
+*/
+inline cached_power get_cached_power_for_binary_exponent(int e)
+{
+    // Now
+    //
+    //      alpha <= e_c + e + q <= gamma                                    (1)
+    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
+    //
+    // and since the c's are normalized, 2^(q-1) <= f_c,
+    //
+    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
+    //      ==> 2^(alpha - e - 1) <= c
+    //
+    // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
+    //
+    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
+    //        = ceil( (alpha - e - 1) * log_10(2) )
+    //
+    // From the paper:
+    // "In theory the result of the procedure could be wrong since c is rounded,
+    //  and the computation itself is approximated [...]. In practice, however,
+    //  this simple function is sufficient."
+    //
+    // For IEEE double precision floating-point numbers converted into
+    // normalized diyfp's w = f * 2^e, with q = 64,
+    //
+    //      e >= -1022      (min IEEE exponent)
+    //           -52        (p - 1)
+    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
+    //           -11        (normalize the diyfp)
+    //         = -1137
+    //
+    // and
+    //
+    //      e <= +1023      (max IEEE exponent)
+    //           -52        (p - 1)
+    //           -11        (normalize the diyfp)
+    //         = 960
+    //
+    // This binary exponent range [-1137,960] results in a decimal exponent
+    // range [-307,324]. One does not need to store a cached power for each
+    // k in this range. For each such k it suffices to find a cached power
+    // such that the exponent of the product lies in [alpha,gamma].
+    // This implies that the difference of the decimal exponents of adjacent
+    // table entries must be less than or equal to
+    //
+    //      floor( (gamma - alpha) * log_10(2) ) = 8.
+    //
+    // (A smaller distance gamma-alpha would require a larger table.)
+
+    // NB:
+    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
+
+    constexpr int kCachedPowersMinDecExp = -300;
+    constexpr int kCachedPowersDecStep = 8;
+
+    static constexpr std::array<cached_power, 79> kCachedPowers =
+    {
+        {
+            { 0xAB70FE17C79AC6CA, -1060, -300 },
+            { 0xFF77B1FCBEBCDC4F, -1034, -292 },
+            { 0xBE5691EF416BD60C, -1007, -284 },
+            { 0x8DD01FAD907FFC3C,  -980, -276 },
+            { 0xD3515C2831559A83,  -954, -268 },
+            { 0x9D71AC8FADA6C9B5,  -927, -260 },
+            { 0xEA9C227723EE8BCB,  -901, -252 },
+            { 0xAECC49914078536D,  -874, -244 },
+            { 0x823C12795DB6CE57,  -847, -236 },
+            { 0xC21094364DFB5637,  -821, -228 },
+            { 0x9096EA6F3848984F,  -794, -220 },
+            { 0xD77485CB25823AC7,  -768, -212 },
+            { 0xA086CFCD97BF97F4,  -741, -204 },
+            { 0xEF340A98172AACE5,  -715, -196 },
+            { 0xB23867FB2A35B28E,  -688, -188 },
+            { 0x84C8D4DFD2C63F3B,  -661, -180 },
+            { 0xC5DD44271AD3CDBA,  -635, -172 },
+            { 0x936B9FCEBB25C996,  -608, -164 },
+            { 0xDBAC6C247D62A584,  -582, -156 },
+            { 0xA3AB66580D5FDAF6,  -555, -148 },
+            { 0xF3E2F893DEC3F126,  -529, -140 },
+            { 0xB5B5ADA8AAFF80B8,  -502, -132 },
+            { 0x87625F056C7C4A8B,  -475, -124 },
+            { 0xC9BCFF6034C13053,  -449, -116 },
+            { 0x964E858C91BA2655,  -422, -108 },
+            { 0xDFF9772470297EBD,  -396, -100 },
+            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
+            { 0xF8A95FCF88747D94,  -343,  -84 },
+            { 0xB94470938FA89BCF,  -316,  -76 },
+            { 0x8A08F0F8BF0F156B,  -289,  -68 },
+            { 0xCDB02555653131B6,  -263,  -60 },
+            { 0x993FE2C6D07B7FAC,  -236,  -52 },
+            { 0xE45C10C42A2B3B06,  -210,  -44 },
+            { 0xAA242499697392D3,  -183,  -36 },
+            { 0xFD87B5F28300CA0E,  -157,  -28 },
+            { 0xBCE5086492111AEB,  -130,  -20 },
+            { 0x8CBCCC096F5088CC,  -103,  -12 },
+            { 0xD1B71758E219652C,   -77,   -4 },
+            { 0x9C40000000000000,   -50,    4 },
+            { 0xE8D4A51000000000,   -24,   12 },
+            { 0xAD78EBC5AC620000,     3,   20 },
+            { 0x813F3978F8940984,    30,   28 },
+            { 0xC097CE7BC90715B3,    56,   36 },
+            { 0x8F7E32CE7BEA5C70,    83,   44 },
+            { 0xD5D238A4ABE98068,   109,   52 },
+            { 0x9F4F2726179A2245,   136,   60 },
+            { 0xED63A231D4C4FB27,   162,   68 },
+            { 0xB0DE65388CC8ADA8,   189,   76 },
+            { 0x83C7088E1AAB65DB,   216,   84 },
+            { 0xC45D1DF942711D9A,   242,   92 },
+            { 0x924D692CA61BE758,   269,  100 },
+            { 0xDA01EE641A708DEA,   295,  108 },
+            { 0xA26DA3999AEF774A,   322,  116 },
+            { 0xF209787BB47D6B85,   348,  124 },
+            { 0xB454E4A179DD1877,   375,  132 },
+            { 0x865B86925B9BC5C2,   402,  140 },
+            { 0xC83553C5C8965D3D,   428,  148 },
+            { 0x952AB45CFA97A0B3,   455,  156 },
+            { 0xDE469FBD99A05FE3,   481,  164 },
+            { 0xA59BC234DB398C25,   508,  172 },
+            { 0xF6C69A72A3989F5C,   534,  180 },
+            { 0xB7DCBF5354E9BECE,   561,  188 },
+            { 0x88FCF317F22241E2,   588,  196 },
+            { 0xCC20CE9BD35C78A5,   614,  204 },
+            { 0x98165AF37B2153DF,   641,  212 },
+            { 0xE2A0B5DC971F303A,   667,  220 },
+            { 0xA8D9D1535CE3B396,   694,  228 },
+            { 0xFB9B7CD9A4A7443C,   720,  236 },
+            { 0xBB764C4CA7A44410,   747,  244 },
+            { 0x8BAB8EEFB6409C1A,   774,  252 },
+            { 0xD01FEF10A657842C,   800,  260 },
+            { 0x9B10A4E5E9913129,   827,  268 },
+            { 0xE7109BFBA19C0C9D,   853,  276 },
+            { 0xAC2820D9623BF429,   880,  284 },
+            { 0x80444B5E7AA7CF85,   907,  292 },
+            { 0xBF21E44003ACDD2D,   933,  300 },
+            { 0x8E679C2F5E44FF8F,   960,  308 },
+            { 0xD433179D9C8CB841,   986,  316 },
+            { 0x9E19DB92B4E31BA9,  1013,  324 },
+        }
+    };
+
+    // This computation gives exactly the same results for k as
+    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
+    // for |e| <= 1500, but doesn't require floating-point operations.
+    // NB: log_10(2) ~= 78913 / 2^18
+    JSON_ASSERT(e >= -1500);
+    JSON_ASSERT(e <=  1500);
+    const int f = kAlpha - e - 1;
+    const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
+
+    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
+    JSON_ASSERT(index >= 0);
+    JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
+
+    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
+    JSON_ASSERT(kAlpha <= cached.e + e + 64);
+    JSON_ASSERT(kGamma >= cached.e + e + 64);
+
+    return cached;
+}
+
+/*!
+For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
+For n == 0, returns 1 and sets pow10 := 1.
+*/
+inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
+{
+    // LCOV_EXCL_START
+    if (n >= 1000000000)
+    {
+        pow10 = 1000000000;
+        return 10;
+    }
+    // LCOV_EXCL_STOP
+    if (n >= 100000000)
+    {
+        pow10 = 100000000;
+        return  9;
+    }
+    if (n >= 10000000)
+    {
+        pow10 = 10000000;
+        return  8;
+    }
+    if (n >= 1000000)
+    {
+        pow10 = 1000000;
+        return  7;
+    }
+    if (n >= 100000)
+    {
+        pow10 = 100000;
+        return  6;
+    }
+    if (n >= 10000)
+    {
+        pow10 = 10000;
+        return  5;
+    }
+    if (n >= 1000)
+    {
+        pow10 = 1000;
+        return  4;
+    }
+    if (n >= 100)
+    {
+        pow10 = 100;
+        return  3;
+    }
+    if (n >= 10)
+    {
+        pow10 = 10;
+        return  2;
+    }
+
+    pow10 = 1;
+    return 1;
+}
+
+inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
+                         std::uint64_t rest, std::uint64_t ten_k)
+{
+    JSON_ASSERT(len >= 1);
+    JSON_ASSERT(dist <= delta);
+    JSON_ASSERT(rest <= delta);
+    JSON_ASSERT(ten_k > 0);
+
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    //                                  ten_k
+    //                                <------>
+    //                                       <---- rest ---->
+    // --------------[------------------+----+--------------]--------------
+    //                                  w    V
+    //                                       = buf * 10^k
+    //
+    // ten_k represents a unit-in-the-last-place in the decimal representation
+    // stored in buf.
+    // Decrement buf by ten_k while this takes buf closer to w.
+
+    // The tests are written in this order to avoid overflow in unsigned
+    // integer arithmetic.
+
+    while (rest < dist
+            && delta - rest >= ten_k
+            && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
+    {
+        JSON_ASSERT(buf[len - 1] != '0');
+        buf[len - 1]--;
+        rest += ten_k;
+    }
+}
+
+/*!
+Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
+M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
+*/
+inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
+                             diyfp M_minus, diyfp w, diyfp M_plus)
+{
+    static_assert(kAlpha >= -60, "internal error");
+    static_assert(kGamma <= -32, "internal error");
+
+    // Generates the digits (and the exponent) of a decimal floating-point
+    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
+    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
+    //
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    // Grisu2 generates the digits of M+ from left to right and stops as soon as
+    // V is in [M-,M+].
+
+    JSON_ASSERT(M_plus.e >= kAlpha);
+    JSON_ASSERT(M_plus.e <= kGamma);
+
+    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
+    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
+
+    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
+    //
+    //      M+ = f * 2^e
+    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
+    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
+    //         = p1 + p2 * 2^e
+
+    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
+
+    auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
+    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
+
+    // 1)
+    //
+    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
+
+    JSON_ASSERT(p1 > 0);
+
+    std::uint32_t pow10{};
+    const int k = find_largest_pow10(p1, pow10);
+
+    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
+    //
+    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
+    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
+    //
+    //      M+ = p1                                             + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
+    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
+    //
+    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
+    //
+    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
+    //
+    // but stop as soon as
+    //
+    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
+
+    int n = k;
+    while (n > 0)
+    {
+        // Invariants:
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        //
+        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
+        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
+        //
+        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
+        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
+        //
+        p1 = r;
+        n--;
+        //
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
+        //      pow10 = 10^n
+        //
+
+        // Now check if enough digits have been generated.
+        // Compute
+        //
+        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
+        //
+        // Note:
+        // Since rest and delta share the same exponent e, it suffices to
+        // compare the significands.
+        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
+        if (rest <= delta)
+        {
+            // V = buffer * 10^n, with M- <= V <= M+.
+
+            decimal_exponent += n;
+
+            // We may now just stop. But instead look if the buffer could be
+            // decremented to bring V closer to w.
+            //
+            // pow10 = 10^n is now 1 ulp in the decimal representation V.
+            // The rounding procedure works with diyfp's with an implicit
+            // exponent of e.
+            //
+            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
+            //
+            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
+            grisu2_round(buffer, length, dist, delta, rest, ten_n);
+
+            return;
+        }
+
+        pow10 /= 10;
+        //
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        // Invariants restored.
+    }
+
+    // 2)
+    //
+    // The digits of the integral part have been generated:
+    //
+    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
+    //         = buffer            + p2 * 2^e
+    //
+    // Now generate the digits of the fractional part p2 * 2^e.
+    //
+    // Note:
+    // No decimal point is generated: the exponent is adjusted instead.
+    //
+    // p2 actually represents the fraction
+    //
+    //      p2 * 2^e
+    //          = p2 / 2^-e
+    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
+    //
+    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
+    //
+    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
+    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
+    //
+    // using
+    //
+    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
+    //                = (                   d) * 2^-e + (                   r)
+    //
+    // or
+    //      10^m * p2 * 2^e = d + r * 2^e
+    //
+    // i.e.
+    //
+    //      M+ = buffer + p2 * 2^e
+    //         = buffer + 10^-m * (d + r * 2^e)
+    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
+    //
+    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
+
+    JSON_ASSERT(p2 > delta);
+
+    int m = 0;
+    for (;;)
+    {
+        // Invariant:
+        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
+        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
+        //
+        JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
+        p2 *= 10;
+        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
+        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
+        //
+        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
+        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        p2 = r;
+        m++;
+        //
+        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
+        // Invariant restored.
+
+        // Check if enough digits have been generated.
+        //
+        //      10^-m * p2 * 2^e <= delta * 2^e
+        //              p2 * 2^e <= 10^m * delta * 2^e
+        //                    p2 <= 10^m * delta
+        delta *= 10;
+        dist  *= 10;
+        if (p2 <= delta)
+        {
+            break;
+        }
+    }
+
+    // V = buffer * 10^-m, with M- <= V <= M+.
+
+    decimal_exponent -= m;
+
+    // 1 ulp in the decimal representation is now 10^-m.
+    // Since delta and dist are now scaled by 10^m, we need to do the
+    // same with ulp in order to keep the units in sync.
+    //
+    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
+    //
+    const std::uint64_t ten_m = one.f;
+    grisu2_round(buffer, length, dist, delta, p2, ten_m);
+
+    // By construction this algorithm generates the shortest possible decimal
+    // number (Loitsch, Theorem 6.2) which rounds back to w.
+    // For an input number of precision p, at least
+    //
+    //      N = 1 + ceil(p * log_10(2))
+    //
+    // decimal digits are sufficient to identify all binary floating-point
+    // numbers (Matula, "In-and-Out conversions").
+    // This implies that the algorithm does not produce more than N decimal
+    // digits.
+    //
+    //      N = 17 for p = 53 (IEEE double precision)
+    //      N = 9  for p = 24 (IEEE single precision)
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline void grisu2(char* buf, int& len, int& decimal_exponent,
+                   diyfp m_minus, diyfp v, diyfp m_plus)
+{
+    JSON_ASSERT(m_plus.e == m_minus.e);
+    JSON_ASSERT(m_plus.e == v.e);
+
+    //  --------(-----------------------+-----------------------)--------    (A)
+    //          m-                      v                       m+
+    //
+    //  --------------------(-----------+-----------------------)--------    (B)
+    //                      m-          v                       m+
+    //
+    // First scale v (and m- and m+) such that the exponent is in the range
+    // [alpha, gamma].
+
+    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
+
+    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
+
+    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
+    const diyfp w       = diyfp::mul(v,       c_minus_k);
+    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
+    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
+
+    //  ----(---+---)---------------(---+---)---------------(---+---)----
+    //          w-                      w                       w+
+    //          = c*m-                  = c*v                   = c*m+
+    //
+    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
+    // w+ are now off by a small amount.
+    // In fact:
+    //
+    //      w - v * 10^k < 1 ulp
+    //
+    // To account for this inaccuracy, add resp. subtract 1 ulp.
+    //
+    //  --------+---[---------------(---+---)---------------]---+--------
+    //          w-  M-                  w                   M+  w+
+    //
+    // Now any number in [M-, M+] (bounds included) will round to w when input,
+    // regardless of how the input rounding algorithm breaks ties.
+    //
+    // And digit_gen generates the shortest possible such number in [M-, M+].
+    // Note that this does not mean that Grisu2 always generates the shortest
+    // possible number in the interval (m-, m+).
+    const diyfp M_minus(w_minus.f + 1, w_minus.e);
+    const diyfp M_plus (w_plus.f  - 1, w_plus.e );
+
+    decimal_exponent = -cached.k; // = -(-k) = k
+
+    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1)
+void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
+{
+    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
+                  "internal error: not enough precision");
+
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
+    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
+    // decimal representations are not exactly "short".
+    //
+    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
+    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
+    // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
+    // does.
+    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
+    // representation using the corresponding std::from_chars function recovers value exactly". That
+    // indicates that single precision floating-point numbers should be recovered using
+    // 'std::strtof'.
+    //
+    // NB: If the neighbors are computed for single-precision numbers, there is a single float
+    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
+    //     value is off by 1 ulp.
+#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
+    const boundaries w = compute_boundaries(static_cast<double>(value));
+#else
+    const boundaries w = compute_boundaries(value);
+#endif
+
+    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
+}
+
+/*!
+@brief appends a decimal representation of e to buf
+@return a pointer to the element following the exponent.
+@pre -1000 < e < 1000
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* append_exponent(char* buf, int e)
+{
+    JSON_ASSERT(e > -1000);
+    JSON_ASSERT(e <  1000);
+
+    if (e < 0)
+    {
+        e = -e;
+        *buf++ = '-';
+    }
+    else
+    {
+        *buf++ = '+';
+    }
+
+    auto k = static_cast<std::uint32_t>(e);
+    if (k < 10)
+    {
+        // Always print at least two digits in the exponent.
+        // This is for compatibility with printf("%g").
+        *buf++ = '0';
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else if (k < 100)
+    {
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else
+    {
+        *buf++ = static_cast<char>('0' + k / 100);
+        k %= 100;
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+
+    return buf;
+}
+
+/*!
+@brief prettify v = buf * 10^decimal_exponent
+
+If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
+notation. Otherwise it will be printed in exponential notation.
+
+@pre min_exp < 0
+@pre max_exp > 0
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* format_buffer(char* buf, int len, int decimal_exponent,
+                           int min_exp, int max_exp)
+{
+    JSON_ASSERT(min_exp < 0);
+    JSON_ASSERT(max_exp > 0);
+
+    const int k = len;
+    const int n = len + decimal_exponent;
+
+    // v = buf * 10^(n-k)
+    // k is the length of the buffer (number of decimal digits)
+    // n is the position of the decimal point relative to the start of the buffer.
+
+    if (k <= n && n <= max_exp)
+    {
+        // digits[000]
+        // len <= max_exp + 2
+
+        std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
+        // Make it look like a floating-point number (#362, #378)
+        buf[n + 0] = '.';
+        buf[n + 1] = '0';
+        return buf + (static_cast<size_t>(n) + 2);
+    }
+
+    if (0 < n && n <= max_exp)
+    {
+        // dig.its
+        // len <= max_digits10 + 1
+
+        JSON_ASSERT(k > n);
+
+        std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
+        buf[n] = '.';
+        return buf + (static_cast<size_t>(k) + 1U);
+    }
+
+    if (min_exp < n && n <= 0)
+    {
+        // 0.[000]digits
+        // len <= 2 + (-min_exp - 1) + max_digits10
+
+        std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
+        buf[0] = '0';
+        buf[1] = '.';
+        std::memset(buf + 2, '0', static_cast<size_t>(-n));
+        return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
+    }
+
+    if (k == 1)
+    {
+        // dE+123
+        // len <= 1 + 5
+
+        buf += 1;
+    }
+    else
+    {
+        // d.igitsE+123
+        // len <= max_digits10 + 1 + 5
+
+        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
+        buf[1] = '.';
+        buf += 1 + static_cast<size_t>(k);
+    }
+
+    *buf++ = 'e';
+    return append_exponent(buf, n - 1);
+}
+
+}  // namespace dtoa_impl
+
+/*!
+@brief generates a decimal representation of the floating-point number value in [first, last).
+
+The format of the resulting decimal representation is similar to printf's %g
+format. Returns an iterator pointing past-the-end of the decimal representation.
+
+@note The input number must be finite, i.e. NaN's and Inf's are not supported.
+@note The buffer must be large enough.
+@note The result is NOT null-terminated.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1, 2)
+JSON_HEDLEY_RETURNS_NON_NULL
+char* to_chars(char* first, const char* last, FloatType value)
+{
+    static_cast<void>(last); // maybe unused - fix warning
+    JSON_ASSERT(std::isfinite(value));
+
+    // Use signbit(value) instead of (value < 0) since signbit works for -0.
+    if (std::signbit(value))
+    {
+        value = -value;
+        *first++ = '-';
+    }
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+    if (value == 0) // +-0
+    {
+        *first++ = '0';
+        // Make it look like a floating-point number (#362, #378)
+        *first++ = '.';
+        *first++ = '0';
+        return first;
+    }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
+
+    // Compute v = buffer * 10^decimal_exponent.
+    // The decimal digits are stored in the buffer, which needs to be interpreted
+    // as an unsigned decimal integer.
+    // len is the length of the buffer, i.e. the number of decimal digits.
+    int len = 0;
+    int decimal_exponent = 0;
+    dtoa_impl::grisu2(first, len, decimal_exponent, value);
+
+    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
+
+    // Format the buffer like printf("%.*g", prec, value)
+    constexpr int kMinExp = -4;
+    // Use digits10 here to increase compatibility with version 2.
+    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
+
+    JSON_ASSERT(last - first >= kMaxExp + 2);
+    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
+
+    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////////////
+// serialization //
+///////////////////
+
+/// how to treat decoding errors
+enum class error_handler_t
+{
+    strict,  ///< throw a type_error exception in case of invalid UTF-8
+    replace, ///< replace invalid UTF-8 sequences with U+FFFD
+    ignore   ///< ignore invalid UTF-8 sequences
+};
+
+template<typename BasicJsonType>
+class serializer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using binary_char_t = typename BasicJsonType::binary_t::value_type;
+    static constexpr std::uint8_t UTF8_ACCEPT = 0;
+    static constexpr std::uint8_t UTF8_REJECT = 1;
+
+  public:
+    /*!
+    @param[in] s  output stream to serialize to
+    @param[in] ichar  indentation character to use
+    @param[in] error_handler_  how to react on decoding errors
+    */
+    serializer(output_adapter_t<char> s, const char ichar,
+               error_handler_t error_handler_ = error_handler_t::strict)
+        : o(std::move(s))
+        , loc(std::localeconv())
+        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
+        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
+        , indent_char(ichar)
+        , indent_string(512, indent_char)
+        , error_handler(error_handler_)
+    {}
+
+    // delete because of pointer members
+    serializer(const serializer&) = delete;
+    serializer& operator=(const serializer&) = delete;
+    serializer(serializer&&) = delete;
+    serializer& operator=(serializer&&) = delete;
+    ~serializer() = default;
+
+    /*!
+    @brief internal implementation of the serialization function
+
+    This function is called by the public member function dump and organizes
+    the serialization internally. The indentation level is propagated as
+    additional parameter. In case of arrays and objects, the function is
+    called recursively.
+
+    - strings and object keys are escaped using `escape_string()`
+    - integer numbers are converted implicitly via `operator<<`
+    - floating-point numbers are converted to a string using `"%g"` format
+    - binary values are serialized as objects containing the subtype and the
+      byte array
+
+    @param[in] val               value to serialize
+    @param[in] pretty_print      whether the output shall be pretty-printed
+    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
+    in the output are escaped with `\uXXXX` sequences, and the result consists
+    of ASCII characters only.
+    @param[in] indent_step       the indent level
+    @param[in] current_indent    the current indent level (only used internally)
+    */
+    void dump(const BasicJsonType& val,
+              const bool pretty_print,
+              const bool ensure_ascii,
+              const unsigned int indent_step,
+              const unsigned int current_indent = 0)
+    {
+        switch (val.m_data.m_type)
+        {
+            case value_t::object:
+            {
+                if (val.m_data.m_value.object->empty())
+                {
+                    o->write_characters("{}", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    auto i = val.m_data.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\": ", 3);
+                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\": ", 3);
+                    dump(i->second, true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_character('{');
+
+                    // first n-1 elements
+                    auto i = val.m_data.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\":", 2);
+                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\":", 2);
+                    dump(i->second, false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character('}');
+                }
+
+                return;
+            }
+
+            case value_t::array:
+            {
+                if (val.m_data.m_value.array->empty())
+                {
+                    o->write_characters("[]", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("[\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    for (auto i = val.m_data.m_value.array->cbegin();
+                            i != val.m_data.m_value.array->cend() - 1; ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        dump(*i, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_data.m_value.array->empty());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    dump(val.m_data.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character(']');
+                }
+                else
+                {
+                    o->write_character('[');
+
+                    // first n-1 elements
+                    for (auto i = val.m_data.m_value.array->cbegin();
+                            i != val.m_data.m_value.array->cend() - 1; ++i)
+                    {
+                        dump(*i, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_data.m_value.array->empty());
+                    dump(val.m_data.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character(']');
+                }
+
+                return;
+            }
+
+            case value_t::string:
+            {
+                o->write_character('\"');
+                dump_escaped(*val.m_data.m_value.string, ensure_ascii);
+                o->write_character('\"');
+                return;
+            }
+
+            case value_t::binary:
+            {
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"bytes\": [", 10);
+
+                    if (!val.m_data.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_data.m_value.binary->cbegin();
+                                i != val.m_data.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_characters(", ", 2);
+                        }
+                        dump_integer(val.m_data.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\n", 3);
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"subtype\": ", 11);
+                    if (val.m_data.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_data.m_value.binary->subtype());
+                    }
+                    else
+                    {
+                        o->write_characters("null", 4);
+                    }
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_characters("{\"bytes\":[", 10);
+
+                    if (!val.m_data.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_data.m_value.binary->cbegin();
+                                i != val.m_data.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_character(',');
+                        }
+                        dump_integer(val.m_data.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\"subtype\":", 12);
+                    if (val.m_data.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_data.m_value.binary->subtype());
+                        o->write_character('}');
+                    }
+                    else
+                    {
+                        o->write_characters("null}", 5);
+                    }
+                }
+                return;
+            }
+
+            case value_t::boolean:
+            {
+                if (val.m_data.m_value.boolean)
+                {
+                    o->write_characters("true", 4);
+                }
+                else
+                {
+                    o->write_characters("false", 5);
+                }
+                return;
+            }
+
+            case value_t::number_integer:
+            {
+                dump_integer(val.m_data.m_value.number_integer);
+                return;
+            }
+
+            case value_t::number_unsigned:
+            {
+                dump_integer(val.m_data.m_value.number_unsigned);
+                return;
+            }
+
+            case value_t::number_float:
+            {
+                dump_float(val.m_data.m_value.number_float);
+                return;
+            }
+
+            case value_t::discarded:
+            {
+                o->write_characters("<discarded>", 11);
+                return;
+            }
+
+            case value_t::null:
+            {
+                o->write_characters("null", 4);
+                return;
+            }
+
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief dump escaped string
+
+    Escape a string by replacing certain special characters by a sequence of an
+    escape character (backslash) and another character and other control
+    characters by a sequence of "\u" followed by a four-digit hex
+    representation. The escaped string is written to output stream @a o.
+
+    @param[in] s  the string to escape
+    @param[in] ensure_ascii  whether to escape non-ASCII characters with
+                             \uXXXX sequences
+
+    @complexity Linear in the length of string @a s.
+    */
+    void dump_escaped(const string_t& s, const bool ensure_ascii)
+    {
+        std::uint32_t codepoint{};
+        std::uint8_t state = UTF8_ACCEPT;
+        std::size_t bytes = 0;  // number of bytes written to string_buffer
+
+        // number of bytes written at the point of the last valid byte
+        std::size_t bytes_after_last_accept = 0;
+        std::size_t undumped_chars = 0;
+
+        for (std::size_t i = 0; i < s.size(); ++i)
+        {
+            const auto byte = static_cast<std::uint8_t>(s[i]);
+
+            switch (decode(state, codepoint, byte))
+            {
+                case UTF8_ACCEPT:  // decode found a new code point
+                {
+                    switch (codepoint)
+                    {
+                        case 0x08: // backspace
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'b';
+                            break;
+                        }
+
+                        case 0x09: // horizontal tab
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 't';
+                            break;
+                        }
+
+                        case 0x0A: // newline
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'n';
+                            break;
+                        }
+
+                        case 0x0C: // formfeed
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'f';
+                            break;
+                        }
+
+                        case 0x0D: // carriage return
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'r';
+                            break;
+                        }
+
+                        case 0x22: // quotation mark
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\"';
+                            break;
+                        }
+
+                        case 0x5C: // reverse solidus
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\\';
+                            break;
+                        }
+
+                        default:
+                        {
+                            // escape control characters (0x00..0x1F) or, if
+                            // ensure_ascii parameter is used, non-ASCII characters
+                            if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
+                            {
+                                if (codepoint <= 0xFFFF)
+                                {
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                                      static_cast<std::uint16_t>(codepoint)));
+                                    bytes += 6;
+                                }
+                                else
+                                {
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
+                                    bytes += 12;
+                                }
+                            }
+                            else
+                            {
+                                // copy byte to buffer (all previous bytes
+                                // been copied have in default case above)
+                                string_buffer[bytes++] = s[i];
+                            }
+                            break;
+                        }
+                    }
+
+                    // write buffer and reset index; there must be 13 bytes
+                    // left, as this is the maximal number of bytes to be
+                    // written ("\uxxxx\uxxxx\0") for one code point
+                    if (string_buffer.size() - bytes < 13)
+                    {
+                        o->write_characters(string_buffer.data(), bytes);
+                        bytes = 0;
+                    }
+
+                    // remember the byte position of this accept
+                    bytes_after_last_accept = bytes;
+                    undumped_chars = 0;
+                    break;
+                }
+
+                case UTF8_REJECT:  // decode found invalid UTF-8 byte
+                {
+                    switch (error_handler)
+                    {
+                        case error_handler_t::strict:
+                        {
+                            JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", hex_bytes(byte | 0)), nullptr));
+                        }
+
+                        case error_handler_t::ignore:
+                        case error_handler_t::replace:
+                        {
+                            // in case we saw this character the first time, we
+                            // would like to read it again, because the byte
+                            // may be OK for itself, but just not OK for the
+                            // previous sequence
+                            if (undumped_chars > 0)
+                            {
+                                --i;
+                            }
+
+                            // reset length buffer to the last accepted index;
+                            // thus removing/ignoring the invalid characters
+                            bytes = bytes_after_last_accept;
+
+                            if (error_handler == error_handler_t::replace)
+                            {
+                                // add a replacement character
+                                if (ensure_ascii)
+                                {
+                                    string_buffer[bytes++] = '\\';
+                                    string_buffer[bytes++] = 'u';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'd';
+                                }
+                                else
+                                {
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
+                                }
+
+                                // write buffer and reset index; there must be 13 bytes
+                                // left, as this is the maximal number of bytes to be
+                                // written ("\uxxxx\uxxxx\0") for one code point
+                                if (string_buffer.size() - bytes < 13)
+                                {
+                                    o->write_characters(string_buffer.data(), bytes);
+                                    bytes = 0;
+                                }
+
+                                bytes_after_last_accept = bytes;
+                            }
+
+                            undumped_chars = 0;
+
+                            // continue processing the string
+                            state = UTF8_ACCEPT;
+                            break;
+                        }
+
+                        default:            // LCOV_EXCL_LINE
+                            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+
+                default:  // decode found yet incomplete multi-byte code point
+                {
+                    if (!ensure_ascii)
+                    {
+                        // code point will not be escaped - copy byte to buffer
+                        string_buffer[bytes++] = s[i];
+                    }
+                    ++undumped_chars;
+                    break;
+                }
+            }
+        }
+
+        // we finished processing the string
+        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
+        {
+            // write buffer
+            if (bytes > 0)
+            {
+                o->write_characters(string_buffer.data(), bytes);
+            }
+        }
+        else
+        {
+            // we finish reading, but do not accept: string was incomplete
+            switch (error_handler)
+            {
+                case error_handler_t::strict:
+                {
+                    JSON_THROW(type_error::create(316, concat("incomplete UTF-8 string; last byte: 0x", hex_bytes(static_cast<std::uint8_t>(s.back() | 0))), nullptr));
+                }
+
+                case error_handler_t::ignore:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    break;
+                }
+
+                case error_handler_t::replace:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    // add a replacement character
+                    if (ensure_ascii)
+                    {
+                        o->write_characters("\\ufffd", 6);
+                    }
+                    else
+                    {
+                        o->write_characters("\xEF\xBF\xBD", 3);
+                    }
+                    break;
+                }
+
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            }
+        }
+    }
+
+  private:
+    /*!
+    @brief count digits
+
+    Count the number of decimal (base 10) digits for an input unsigned integer.
+
+    @param[in] x  unsigned integer number to count its digits
+    @return    number of decimal digits
+    */
+    inline unsigned int count_digits(number_unsigned_t x) noexcept
+    {
+        unsigned int n_digits = 1;
+        for (;;)
+        {
+            if (x < 10)
+            {
+                return n_digits;
+            }
+            if (x < 100)
+            {
+                return n_digits + 1;
+            }
+            if (x < 1000)
+            {
+                return n_digits + 2;
+            }
+            if (x < 10000)
+            {
+                return n_digits + 3;
+            }
+            x = x / 10000u;
+            n_digits += 4;
+        }
+    }
+
+    /*!
+     * @brief convert a byte to a uppercase hex representation
+     * @param[in] byte byte to represent
+     * @return representation ("00".."FF")
+     */
+    static std::string hex_bytes(std::uint8_t byte)
+    {
+        std::string result = "FF";
+        constexpr const char* nibble_to_hex = "0123456789ABCDEF";
+        result[0] = nibble_to_hex[byte / 16];
+        result[1] = nibble_to_hex[byte % 16];
+        return result;
+    }
+
+    // templates to avoid warnings about useless casts
+    template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
+    bool is_negative_number(NumberType x)
+    {
+        return x < 0;
+    }
+
+    template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >
+    bool is_negative_number(NumberType /*unused*/)
+    {
+        return false;
+    }
+
+    /*!
+    @brief dump an integer
+
+    Dump a given integer to output stream @a o. Works internally with
+    @a number_buffer.
+
+    @param[in] x  integer number (signed or unsigned) to dump
+    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
+    */
+    template < typename NumberType, detail::enable_if_t <
+                   std::is_integral<NumberType>::value ||
+                   std::is_same<NumberType, number_unsigned_t>::value ||
+                   std::is_same<NumberType, number_integer_t>::value ||
+                   std::is_same<NumberType, binary_char_t>::value,
+                   int > = 0 >
+    void dump_integer(NumberType x)
+    {
+        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
+        {
+            {
+                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
+                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
+                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
+                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
+                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
+                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
+                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
+                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
+                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
+                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
+            }
+        };
+
+        // special case for "0"
+        if (x == 0)
+        {
+            o->write_character('0');
+            return;
+        }
+
+        // use a pointer to fill the buffer
+        auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+
+        number_unsigned_t abs_value;
+
+        unsigned int n_chars{};
+
+        if (is_negative_number(x))
+        {
+            *buffer_ptr = '-';
+            abs_value = remove_sign(static_cast<number_integer_t>(x));
+
+            // account one more byte for the minus sign
+            n_chars = 1 + count_digits(abs_value);
+        }
+        else
+        {
+            abs_value = static_cast<number_unsigned_t>(x);
+            n_chars = count_digits(abs_value);
+        }
+
+        // spare 1 byte for '\0'
+        JSON_ASSERT(n_chars < number_buffer.size() - 1);
+
+        // jump to the end to generate the string from backward,
+        // so we later avoid reversing the result
+        buffer_ptr += n_chars;
+
+        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
+        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
+        while (abs_value >= 100)
+        {
+            const auto digits_index = static_cast<unsigned>((abs_value % 100));
+            abs_value /= 100;
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+
+        if (abs_value >= 10)
+        {
+            const auto digits_index = static_cast<unsigned>(abs_value);
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+        else
+        {
+            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
+        }
+
+        o->write_characters(number_buffer.data(), n_chars);
+    }
+
+    /*!
+    @brief dump a floating-point number
+
+    Dump a given floating-point number to output stream @a o. Works internally
+    with @a number_buffer.
+
+    @param[in] x  floating-point number to dump
+    */
+    void dump_float(number_float_t x)
+    {
+        // NaN / inf
+        if (!std::isfinite(x))
+        {
+            o->write_characters("null", 4);
+            return;
+        }
+
+        // If number_float_t is an IEEE-754 single or double precision number,
+        // use the Grisu2 algorithm to produce short numbers which are
+        // guaranteed to round-trip, using strtof and strtod, resp.
+        //
+        // NB: The test below works if <long double> == <double>.
+        static constexpr bool is_ieee_single_or_double
+            = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
+              (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
+
+        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
+    }
+
+    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
+    {
+        auto* begin = number_buffer.data();
+        auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
+
+        o->write_characters(begin, static_cast<size_t>(end - begin));
+    }
+
+    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
+    {
+        // get number of digits for a float -> text -> float round-trip
+        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
+
+        // the actual conversion
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
+
+        // negative value indicates an error
+        JSON_ASSERT(len > 0);
+        // check if buffer was large enough
+        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
+
+        // erase thousands separator
+        if (thousands_sep != '\0')
+        {
+            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081
+            const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
+            std::fill(end, number_buffer.end(), '\0');
+            JSON_ASSERT((end - number_buffer.begin()) <= len);
+            len = (end - number_buffer.begin());
+        }
+
+        // convert decimal point to '.'
+        if (decimal_point != '\0' && decimal_point != '.')
+        {
+            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081
+            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
+            if (dec_pos != number_buffer.end())
+            {
+                *dec_pos = '.';
+            }
+        }
+
+        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
+
+        // determine if we need to append ".0"
+        const bool value_is_int_like =
+            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
+                         [](char c)
+        {
+            return c == '.' || c == 'e';
+        });
+
+        if (value_is_int_like)
+        {
+            o->write_characters(".0", 2);
+        }
+    }
+
+    /*!
+    @brief check whether a string is UTF-8 encoded
+
+    The function checks each byte of a string whether it is UTF-8 encoded. The
+    result of the check is stored in the @a state parameter. The function must
+    be called initially with state 0 (accept). State 1 means the string must
+    be rejected, because the current byte is not allowed. If the string is
+    completely processed, but the state is non-zero, the string ended
+    prematurely; that is, the last byte indicated more bytes should have
+    followed.
+
+    @param[in,out] state  the state of the decoding
+    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
+    @param[in] byte       next byte to decode
+    @return               new state
+
+    @note The function has been edited: a std::array is used.
+
+    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+    */
+    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
+    {
+        static const std::array<std::uint8_t, 400> utf8d =
+        {
+            {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
+                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
+                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
+                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
+                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
+                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
+                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
+                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
+                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
+            }
+        };
+
+        JSON_ASSERT(byte < utf8d.size());
+        const std::uint8_t type = utf8d[byte];
+
+        codep = (state != UTF8_ACCEPT)
+                ? (byte & 0x3fu) | (codep << 6u)
+                : (0xFFu >> type) & (byte);
+
+        const std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
+        JSON_ASSERT(index < utf8d.size());
+        state = utf8d[index];
+        return state;
+    }
+
+    /*
+     * Overload to make the compiler happy while it is instantiating
+     * dump_integer for number_unsigned_t.
+     * Must never be called.
+     */
+    number_unsigned_t remove_sign(number_unsigned_t x)
+    {
+        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        return x; // LCOV_EXCL_LINE
+    }
+
+    /*
+     * Helper function for dump_integer
+     *
+     * This function takes a negative signed integer and returns its absolute
+     * value as unsigned integer. The plus/minus shuffling is necessary as we can
+     * not directly remove the sign of an arbitrary signed integer as the
+     * absolute values of INT_MIN and INT_MAX are usually not the same. See
+     * #1708 for details.
+     */
+    inline number_unsigned_t remove_sign(number_integer_t x) noexcept
+    {
+        JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
+        return static_cast<number_unsigned_t>(-(x + 1)) + 1;
+    }
+
+  private:
+    /// the output of the serializer
+    output_adapter_t<char> o = nullptr;
+
+    /// a (hopefully) large enough character buffer
+    std::array<char, 64> number_buffer{{}};
+
+    /// the locale
+    const std::lconv* loc = nullptr;
+    /// the locale's thousand separator character
+    const char thousands_sep = '\0';
+    /// the locale's decimal point character
+    const char decimal_point = '\0';
+
+    /// string buffer
+    std::array<char, 512> string_buffer{{}};
+
+    /// the indentation character
+    const char indent_char;
+    /// the indentation string
+    string_t indent_string;
+
+    /// error_handler how to react on decoding errors
+    const error_handler_t error_handler;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/value_t.hpp>
+
+// #include <nlohmann/json_fwd.hpp>
+
+// #include <nlohmann/ordered_map.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <functional> // equal_to, less
+#include <initializer_list> // initializer_list
+#include <iterator> // input_iterator_tag, iterator_traits
+#include <memory> // allocator
+#include <stdexcept> // for out_of_range
+#include <type_traits> // enable_if, is_convertible
+#include <utility> // pair
+#include <vector> // vector
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// ordered_map: a minimal map-like container that preserves insertion order
+/// for use within nlohmann::basic_json<ordered_map>
+template <class Key, class T, class IgnoredLess = std::less<Key>,
+          class Allocator = std::allocator<std::pair<const Key, T>>>
+                  struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
+{
+    using key_type = Key;
+    using mapped_type = T;
+    using Container = std::vector<std::pair<const Key, T>, Allocator>;
+    using iterator = typename Container::iterator;
+    using const_iterator = typename Container::const_iterator;
+    using size_type = typename Container::size_type;
+    using value_type = typename Container::value_type;
+#ifdef JSON_HAS_CPP_14
+    using key_compare = std::equal_to<>;
+#else
+    using key_compare = std::equal_to<Key>;
+#endif
+
+    // Explicit constructors instead of `using Container::Container`
+    // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
+    ordered_map() noexcept(noexcept(Container())) : Container{} {}
+    explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container(alloc))) : Container{alloc} {}
+    template <class It>
+    ordered_map(It first, It last, const Allocator& alloc = Allocator())
+        : Container{first, last, alloc} {}
+    ordered_map(std::initializer_list<value_type> init, const Allocator& alloc = Allocator() )
+        : Container{init, alloc} {}
+
+    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return {it, false};
+            }
+        }
+        Container::emplace_back(key, std::forward<T>(t));
+        return {std::prev(this->end()), true};
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    std::pair<iterator, bool> emplace(KeyType && key, T && t)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return {it, false};
+            }
+        }
+        Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
+        return {std::prev(this->end()), true};
+    }
+
+    T& operator[](const key_type& key)
+    {
+        return emplace(key, T{}).first->second;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    T & operator[](KeyType && key)
+    {
+        return emplace(std::forward<KeyType>(key), T{}).first->second;
+    }
+
+    const T& operator[](const key_type& key) const
+    {
+        return at(key);
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    const T & operator[](KeyType && key) const
+    {
+        return at(std::forward<KeyType>(key));
+    }
+
+    T& at(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    T & at(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    const T& at(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    const T & at(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    size_type erase(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator erase(iterator pos)
+    {
+        return erase(pos, std::next(pos));
+    }
+
+    iterator erase(iterator first, iterator last)
+    {
+        if (first == last)
+        {
+            return first;
+        }
+
+        const auto elements_affected = std::distance(first, last);
+        const auto offset = std::distance(Container::begin(), first);
+
+        // This is the start situation. We need to delete elements_affected
+        // elements (3 in this example: e, f, g), and need to return an
+        // iterator past the last deleted element (h in this example).
+        // Note that offset is the distance from the start of the vector
+        // to first. We will need this later.
+
+        // [ a, b, c, d, e, f, g, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // Since we cannot move const Keys, we re-construct them in place.
+        // We start at first and re-construct (viz. copy) the elements from
+        // the back of the vector. Example for first iteration:
+
+        //               ,--------.
+        //               v        |   destroy e and re-construct with h
+        // [ a, b, c, d, e, f, g, h, i, j ]
+        //               ^        ^
+        //               it       it + elements_affected
+
+        for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
+        {
+            it->~value_type(); // destroy but keep allocation
+            new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
+        }
+
+        // [ a, b, c, d, h, i, j, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // remove the unneeded elements at the end of the vector
+        Container::resize(this->size() - static_cast<size_type>(elements_affected));
+
+        // [ a, b, c, d, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // first is now pointing past the last deleted element, but we cannot
+        // use this iterator, because it may have been invalidated by the
+        // resize call. Instead, we can return begin() + offset.
+        return Container::begin() + offset;
+    }
+
+    size_type count(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    size_type count(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator find(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    const_iterator find(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    std::pair<iterator, bool> insert( value_type&& value )
+    {
+        return emplace(value.first, std::move(value.second));
+    }
+
+    std::pair<iterator, bool> insert( const value_type& value )
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, value.first))
+            {
+                return {it, false};
+            }
+        }
+        Container::push_back(value);
+        return {--this->end(), true};
+    }
+
+    template<typename InputIt>
+    using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
+            std::input_iterator_tag>::value>::type;
+
+    template<typename InputIt, typename = require_input_iter<InputIt>>
+    void insert(InputIt first, InputIt last)
+    {
+        for (auto it = first; it != last; ++it)
+        {
+            insert(*it);
+        }
+    }
+
+private:
+    JSON_NO_UNIQUE_ADDRESS key_compare m_compare = key_compare();
+};
+
+NLOHMANN_JSON_NAMESPACE_END
+
+
+#if defined(JSON_HAS_CPP_17)
+    #if JSON_HAS_STATIC_RTTI
+        #include <any>
+    #endif
+    #include <string_view>
+#endif
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/*!
+@brief a class to store JSON values
+
+@internal
+@invariant The member variables @a m_value and @a m_type have the following
+relationship:
+- If `m_type == value_t::object`, then `m_value.object != nullptr`.
+- If `m_type == value_t::array`, then `m_value.array != nullptr`.
+- If `m_type == value_t::string`, then `m_value.string != nullptr`.
+The invariants are checked by member function assert_invariant().
+
+@note ObjectType trick from https://stackoverflow.com/a/9860911
+@endinternal
+
+@since version 1.0.0
+
+@nosubgrouping
+*/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+    : public ::nlohmann::detail::json_base_class<CustomBaseClass>
+{
+  private:
+    template<detail::value_t> friend struct detail::external_constructor;
+
+    template<typename>
+    friend class ::nlohmann::json_pointer;
+    // can be restored when json_pointer backwards compatibility is removed
+    // friend ::nlohmann::json_pointer<StringType>;
+
+    template<typename BasicJsonType, typename InputType>
+    friend class ::nlohmann::detail::parser;
+    friend ::nlohmann::detail::serializer<basic_json>;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::iter_impl;
+    template<typename BasicJsonType, typename CharType>
+    friend class ::nlohmann::detail::binary_writer;
+    template<typename BasicJsonType, typename InputType, typename SAX>
+    friend class ::nlohmann::detail::binary_reader;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_parser;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
+    friend class ::nlohmann::detail::exception;
+
+    /// workaround type for MSVC
+    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
+    using json_base_class_t = ::nlohmann::detail::json_base_class<CustomBaseClass>;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // convenience aliases for types residing in namespace detail;
+    using lexer = ::nlohmann::detail::lexer_base<basic_json>;
+
+    template<typename InputAdapterType>
+    static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
+        InputAdapterType adapter,
+        detail::parser_callback_t<basic_json>cb = nullptr,
+        const bool allow_exceptions = true,
+        const bool ignore_comments = false
+                                 )
+    {
+        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
+                std::move(cb), allow_exceptions, ignore_comments);
+    }
+
+  private:
+    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
+    template<typename BasicJsonType>
+    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
+    template<typename BasicJsonType>
+    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
+    template<typename Iterator>
+    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
+    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
+
+    template<typename CharType>
+    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
+
+    template<typename InputType>
+    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
+    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    using serializer = ::nlohmann::detail::serializer<basic_json>;
+
+  public:
+    using value_t = detail::value_t;
+    /// JSON Pointer, see @ref nlohmann::json_pointer
+    using json_pointer = ::nlohmann::json_pointer<StringType>;
+    template<typename T, typename SFINAE>
+    using json_serializer = JSONSerializer<T, SFINAE>;
+    /// how to treat decoding errors
+    using error_handler_t = detail::error_handler_t;
+    /// how to treat CBOR tags
+    using cbor_tag_handler_t = detail::cbor_tag_handler_t;
+    /// helper type for initializer lists of basic_json values
+    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
+
+    using input_format_t = detail::input_format_t;
+    /// SAX interface type, see @ref nlohmann::json_sax
+    using json_sax_t = json_sax<basic_json>;
+
+    ////////////////
+    // exceptions //
+    ////////////////
+
+    /// @name exceptions
+    /// Classes to implement user-defined exceptions.
+    /// @{
+
+    using exception = detail::exception;
+    using parse_error = detail::parse_error;
+    using invalid_iterator = detail::invalid_iterator;
+    using type_error = detail::type_error;
+    using out_of_range = detail::out_of_range;
+    using other_error = detail::other_error;
+
+    /// @}
+
+    /////////////////////
+    // container types //
+    /////////////////////
+
+    /// @name container types
+    /// The canonic container types to use @ref basic_json like any other STL
+    /// container.
+    /// @{
+
+    /// the type of elements in a basic_json container
+    using value_type = basic_json;
+
+    /// the type of an element reference
+    using reference = value_type&;
+    /// the type of an element const reference
+    using const_reference = const value_type&;
+
+    /// a type to represent differences between iterators
+    using difference_type = std::ptrdiff_t;
+    /// a type to represent container sizes
+    using size_type = std::size_t;
+
+    /// the allocator type
+    using allocator_type = AllocatorType<basic_json>;
+
+    /// the type of an element pointer
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    /// the type of an element const pointer
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+
+    /// an iterator for a basic_json container
+    using iterator = iter_impl<basic_json>;
+    /// a const iterator for a basic_json container
+    using const_iterator = iter_impl<const basic_json>;
+    /// a reverse iterator for a basic_json container
+    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
+    /// a const reverse iterator for a basic_json container
+    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
+
+    /// @}
+
+    /// @brief returns the allocator associated with the container
+    /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
+    static allocator_type get_allocator()
+    {
+        return allocator_type();
+    }
+
+    /// @brief returns version information on the library
+    /// @sa https://json.nlohmann.me/api/basic_json/meta/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json meta()
+    {
+        basic_json result;
+
+        result["copyright"] = "(C) 2013-2023 Niels Lohmann";
+        result["name"] = "JSON for Modern C++";
+        result["url"] = "https://github.com/nlohmann/json";
+        result["version"]["string"] =
+            detail::concat(std::to_string(NLOHMANN_JSON_VERSION_MAJOR), '.',
+                           std::to_string(NLOHMANN_JSON_VERSION_MINOR), '.',
+                           std::to_string(NLOHMANN_JSON_VERSION_PATCH));
+        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
+        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
+        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
+
+#ifdef _WIN32
+        result["platform"] = "win32";
+#elif defined __linux__
+        result["platform"] = "linux";
+#elif defined __APPLE__
+        result["platform"] = "apple";
+#elif defined __unix__
+        result["platform"] = "unix";
+#else
+        result["platform"] = "unknown";
+#endif
+
+#if defined(__ICC) || defined(__INTEL_COMPILER)
+        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
+#elif defined(__clang__)
+        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
+#elif defined(__GNUC__) || defined(__GNUG__)
+        result["compiler"] = {{"family", "gcc"}, {"version", detail::concat(
+                    std::to_string(__GNUC__), '.',
+                    std::to_string(__GNUC_MINOR__), '.',
+                    std::to_string(__GNUC_PATCHLEVEL__))
+            }
+        };
+#elif defined(__HP_cc) || defined(__HP_aCC)
+        result["compiler"] = "hp"
+#elif defined(__IBMCPP__)
+        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
+#elif defined(_MSC_VER)
+        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
+#elif defined(__PGI)
+        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
+#elif defined(__SUNPRO_CC)
+        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
+#else
+        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
+#endif
+
+#if defined(_MSVC_LANG)
+        result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
+#elif defined(__cplusplus)
+        result["compiler"]["c++"] = std::to_string(__cplusplus);
+#else
+        result["compiler"]["c++"] = "unknown";
+#endif
+        return result;
+    }
+
+    ///////////////////////////
+    // JSON value data types //
+    ///////////////////////////
+
+    /// @name JSON value data types
+    /// The data types to store a JSON value. These types are derived from
+    /// the template arguments passed to class @ref basic_json.
+    /// @{
+
+    /// @brief default object key comparator type
+    /// The actual object key comparator type (@ref object_comparator_t) may be
+    /// different.
+    /// @sa https://json.nlohmann.me/api/basic_json/default_object_comparator_t/
+#if defined(JSON_HAS_CPP_14)
+    // use of transparent comparator avoids unnecessary repeated construction of temporaries
+    // in functions involving lookup by key with types other than object_t::key_type (aka. StringType)
+    using default_object_comparator_t = std::less<>;
+#else
+    using default_object_comparator_t = std::less<StringType>;
+#endif
+
+    /// @brief a type for an object
+    /// @sa https://json.nlohmann.me/api/basic_json/object_t/
+    using object_t = ObjectType<StringType,
+          basic_json,
+          default_object_comparator_t,
+          AllocatorType<std::pair<const StringType,
+          basic_json>>>;
+
+    /// @brief a type for an array
+    /// @sa https://json.nlohmann.me/api/basic_json/array_t/
+    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
+
+    /// @brief a type for a string
+    /// @sa https://json.nlohmann.me/api/basic_json/string_t/
+    using string_t = StringType;
+
+    /// @brief a type for a boolean
+    /// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
+    using boolean_t = BooleanType;
+
+    /// @brief a type for a number (integer)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
+    using number_integer_t = NumberIntegerType;
+
+    /// @brief a type for a number (unsigned)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
+    using number_unsigned_t = NumberUnsignedType;
+
+    /// @brief a type for a number (floating-point)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
+    using number_float_t = NumberFloatType;
+
+    /// @brief a type for a packed binary type
+    /// @sa https://json.nlohmann.me/api/basic_json/binary_t/
+    using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
+
+    /// @brief object key comparator type
+    /// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
+    using object_comparator_t = detail::actual_object_comparator_t<basic_json>;
+
+    /// @}
+
+  private:
+
+    /// helper for exception-safe object creation
+    template<typename T, typename... Args>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    static T* create(Args&& ... args)
+    {
+        AllocatorType<T> alloc;
+        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
+
+        auto deleter = [&](T * obj)
+        {
+            AllocatorTraits::deallocate(alloc, obj, 1);
+        };
+        std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
+        AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
+        JSON_ASSERT(obj != nullptr);
+        return obj.release();
+    }
+
+    ////////////////////////
+    // JSON value storage //
+    ////////////////////////
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief a JSON value
+
+    The actual storage for a JSON value of the @ref basic_json class. This
+    union combines the different storage types for the JSON value types
+    defined in @ref value_t.
+
+    JSON type | value_t type    | used type
+    --------- | --------------- | ------------------------
+    object    | object          | pointer to @ref object_t
+    array     | array           | pointer to @ref array_t
+    string    | string          | pointer to @ref string_t
+    boolean   | boolean         | @ref boolean_t
+    number    | number_integer  | @ref number_integer_t
+    number    | number_unsigned | @ref number_unsigned_t
+    number    | number_float    | @ref number_float_t
+    binary    | binary          | pointer to @ref binary_t
+    null      | null            | *no value is stored*
+
+    @note Variable-length types (objects, arrays, and strings) are stored as
+    pointers. The size of the union should not exceed 64 bits if the default
+    value types are used.
+
+    @since version 1.0.0
+    */
+    union json_value
+    {
+        /// object (stored with pointer to save storage)
+        object_t* object;
+        /// array (stored with pointer to save storage)
+        array_t* array;
+        /// string (stored with pointer to save storage)
+        string_t* string;
+        /// binary (stored with pointer to save storage)
+        binary_t* binary;
+        /// boolean
+        boolean_t boolean;
+        /// number (integer)
+        number_integer_t number_integer;
+        /// number (unsigned integer)
+        number_unsigned_t number_unsigned;
+        /// number (floating-point)
+        number_float_t number_float;
+
+        /// default constructor (for null values)
+        json_value() = default;
+        /// constructor for booleans
+        json_value(boolean_t v) noexcept : boolean(v) {}
+        /// constructor for numbers (integer)
+        json_value(number_integer_t v) noexcept : number_integer(v) {}
+        /// constructor for numbers (unsigned)
+        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
+        /// constructor for numbers (floating-point)
+        json_value(number_float_t v) noexcept : number_float(v) {}
+        /// constructor for empty values of a given type
+        json_value(value_t t)
+        {
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    object = create<object_t>();
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    array = create<array_t>();
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    string = create<string_t>("");
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    binary = create<binary_t>();
+                    break;
+                }
+
+                case value_t::boolean:
+                {
+                    boolean = static_cast<boolean_t>(false);
+                    break;
+                }
+
+                case value_t::number_integer:
+                {
+                    number_integer = static_cast<number_integer_t>(0);
+                    break;
+                }
+
+                case value_t::number_unsigned:
+                {
+                    number_unsigned = static_cast<number_unsigned_t>(0);
+                    break;
+                }
+
+                case value_t::number_float:
+                {
+                    number_float = static_cast<number_float_t>(0.0);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    break;
+                }
+
+                case value_t::discarded:
+                default:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
+                    {
+                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.11.3", nullptr)); // LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+            }
+        }
+
+        /// constructor for strings
+        json_value(const string_t& value) : string(create<string_t>(value)) {}
+
+        /// constructor for rvalue strings
+        json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
+
+        /// constructor for objects
+        json_value(const object_t& value) : object(create<object_t>(value)) {}
+
+        /// constructor for rvalue objects
+        json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
+
+        /// constructor for arrays
+        json_value(const array_t& value) : array(create<array_t>(value)) {}
+
+        /// constructor for rvalue arrays
+        json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
+
+        /// constructor for binary arrays
+        json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
+
+        /// constructor for rvalue binary arrays
+        json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
+
+        /// constructor for binary arrays (internal type)
+        json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
+
+        /// constructor for rvalue binary arrays (internal type)
+        json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
+
+        void destroy(value_t t)
+        {
+            if (
+                (t == value_t::object && object == nullptr) ||
+                (t == value_t::array && array == nullptr) ||
+                (t == value_t::string && string == nullptr) ||
+                (t == value_t::binary && binary == nullptr)
+            )
+            {
+                //not initialized (e.g. due to exception in the ctor)
+                return;
+            }
+            if (t == value_t::array || t == value_t::object)
+            {
+                // flatten the current json_value to a heap-allocated stack
+                std::vector<basic_json> stack;
+
+                // move the top-level items to stack
+                if (t == value_t::array)
+                {
+                    stack.reserve(array->size());
+                    std::move(array->begin(), array->end(), std::back_inserter(stack));
+                }
+                else
+                {
+                    stack.reserve(object->size());
+                    for (auto&& it : *object)
+                    {
+                        stack.push_back(std::move(it.second));
+                    }
+                }
+
+                while (!stack.empty())
+                {
+                    // move the last item to local variable to be processed
+                    basic_json current_item(std::move(stack.back()));
+                    stack.pop_back();
+
+                    // if current_item is array/object, move
+                    // its children to the stack to be processed later
+                    if (current_item.is_array())
+                    {
+                        std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
+
+                        current_item.m_data.m_value.array->clear();
+                    }
+                    else if (current_item.is_object())
+                    {
+                        for (auto&& it : *current_item.m_data.m_value.object)
+                        {
+                            stack.push_back(std::move(it.second));
+                        }
+
+                        current_item.m_data.m_value.object->clear();
+                    }
+
+                    // it's now safe that current_item get destructed
+                    // since it doesn't have any children
+                }
+            }
+
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    AllocatorType<object_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    AllocatorType<array_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
+                    break;
+                }
+
+                case value_t::null:
+                case value_t::boolean:
+                case value_t::number_integer:
+                case value_t::number_unsigned:
+                case value_t::number_float:
+                case value_t::discarded:
+                default:
+                {
+                    break;
+                }
+            }
+        }
+    };
+
+  private:
+    /*!
+    @brief checks the class invariants
+
+    This function asserts the class invariants. It needs to be called at the
+    end of every constructor to make sure that created objects respect the
+    invariant. Furthermore, it has to be called each time the type of a JSON
+    value is changed, because the invariant expresses a relationship between
+    @a m_type and @a m_value.
+
+    Furthermore, the parent relation is checked for arrays and objects: If
+    @a check_parents true and the value is an array or object, then the
+    container's elements must have the current value as parent.
+
+    @param[in] check_parents  whether the parent relation should be checked.
+               The value is true by default and should only be set to false
+               during destruction of objects when the invariant does not
+               need to hold.
+    */
+    void assert_invariant(bool check_parents = true) const noexcept
+    {
+        JSON_ASSERT(m_data.m_type != value_t::object || m_data.m_value.object != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::array || m_data.m_value.array != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::string || m_data.m_value.string != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::binary || m_data.m_value.binary != nullptr);
+
+#if JSON_DIAGNOSTICS
+        JSON_TRY
+        {
+            // cppcheck-suppress assertWithSideEffect
+            JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
+            {
+                return j.m_parent == this;
+            }));
+        }
+        JSON_CATCH(...) {} // LCOV_EXCL_LINE
+#endif
+        static_cast<void>(check_parents);
+    }
+
+    void set_parents()
+    {
+#if JSON_DIAGNOSTICS
+        switch (m_data.m_type)
+        {
+            case value_t::array:
+            {
+                for (auto& element : *m_data.m_value.array)
+                {
+                    element.m_parent = this;
+                }
+                break;
+            }
+
+            case value_t::object:
+            {
+                for (auto& element : *m_data.m_value.object)
+                {
+                    element.second.m_parent = this;
+                }
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                break;
+        }
+#endif
+    }
+
+    iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
+    {
+#if JSON_DIAGNOSTICS
+        for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)
+        {
+            (it + i)->m_parent = this;
+        }
+#else
+        static_cast<void>(count_set_parents);
+#endif
+        return it;
+    }
+
+    reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))
+    {
+#if JSON_DIAGNOSTICS
+        if (old_capacity != static_cast<std::size_t>(-1))
+        {
+            // see https://github.com/nlohmann/json/issues/2838
+            JSON_ASSERT(type() == value_t::array);
+            if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
+            {
+                // capacity has changed: update all parents
+                set_parents();
+                return j;
+            }
+        }
+
+        // ordered_json uses a vector internally, so pointers could have
+        // been invalidated; see https://github.com/nlohmann/json/issues/2962
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning(push )
+#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
+#endif
+        if (detail::is_ordered_map<object_t>::value)
+        {
+            set_parents();
+            return j;
+        }
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning( pop )
+#endif
+
+        j.m_parent = this;
+#else
+        static_cast<void>(j);
+        static_cast<void>(old_capacity);
+#endif
+        return j;
+    }
+
+  public:
+    //////////////////////////
+    // JSON parser callback //
+    //////////////////////////
+
+    /// @brief parser event types
+    /// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
+    using parse_event_t = detail::parse_event_t;
+
+    /// @brief per-element parser callback type
+    /// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
+    using parser_callback_t = detail::parser_callback_t<basic_json>;
+
+    //////////////////
+    // constructors //
+    //////////////////
+
+    /// @name constructors and destructors
+    /// Constructors of class @ref basic_json, copy/move constructor, copy
+    /// assignment, static functions creating objects, and the destructor.
+    /// @{
+
+    /// @brief create an empty value with a given type
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(const value_t v)
+        : m_data(v)
+    {
+        assert_invariant();
+    }
+
+    /// @brief create a null object
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-exception-escape)
+        : basic_json(value_t::null)
+    {
+        assert_invariant();
+    }
+
+    /// @brief create a JSON value from compatible types
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename CompatibleType,
+               typename U = detail::uncvref_t<CompatibleType>,
+               detail::enable_if_t <
+                   !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
+    basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
+                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
+                                           std::forward<CompatibleType>(val))))
+    {
+        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief create a JSON value from an existing one
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
+    basic_json(const BasicJsonType& val)
+    {
+        using other_boolean_t = typename BasicJsonType::boolean_t;
+        using other_number_float_t = typename BasicJsonType::number_float_t;
+        using other_number_integer_t = typename BasicJsonType::number_integer_t;
+        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+        using other_string_t = typename BasicJsonType::string_t;
+        using other_object_t = typename BasicJsonType::object_t;
+        using other_array_t = typename BasicJsonType::array_t;
+        using other_binary_t = typename BasicJsonType::binary_t;
+
+        switch (val.type())
+        {
+            case value_t::boolean:
+                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
+                break;
+            case value_t::number_float:
+                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
+                break;
+            case value_t::number_integer:
+                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
+                break;
+            case value_t::number_unsigned:
+                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
+                break;
+            case value_t::string:
+                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
+                break;
+            case value_t::object:
+                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
+                break;
+            case value_t::array:
+                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
+                break;
+            case value_t::binary:
+                JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
+                break;
+            case value_t::null:
+                *this = nullptr;
+                break;
+            case value_t::discarded:
+                m_data.m_type = value_t::discarded;
+                break;
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+        JSON_ASSERT(m_data.m_type == val.type());
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief create a container (array or object) from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(initializer_list_t init,
+               bool type_deduction = true,
+               value_t manual_type = value_t::array)
+    {
+        // check if each element is an array with two elements whose first
+        // element is a string
+        bool is_an_object = std::all_of(init.begin(), init.end(),
+                                        [](const detail::json_ref<basic_json>& element_ref)
+        {
+            // The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
+            // (many string types can be constructed from 0 via its null-pointer guise, so we get a
+            // broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
+            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
+        });
+
+        // adjust type if type deduction is not wanted
+        if (!type_deduction)
+        {
+            // if array is wanted, do not create an object though possible
+            if (manual_type == value_t::array)
+            {
+                is_an_object = false;
+            }
+
+            // if object is wanted but impossible, throw an exception
+            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
+            {
+                JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
+            }
+        }
+
+        if (is_an_object)
+        {
+            // the initializer list is a list of pairs -> create object
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+
+            for (auto& element_ref : init)
+            {
+                auto element = element_ref.moved_or_copied();
+                m_data.m_value.object->emplace(
+                    std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
+                    std::move((*element.m_data.m_value.array)[1]));
+            }
+        }
+        else
+        {
+            // the initializer list describes an array -> create array
+            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>(init.begin(), init.end());
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief explicitly create a binary array (without subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = init;
+        return res;
+    }
+
+    /// @brief explicitly create a binary array (with subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(init, subtype);
+        return res;
+    }
+
+    /// @brief explicitly create a binary array
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = std::move(init);
+        return res;
+    }
+
+    /// @brief explicitly create a binary array (with subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(std::move(init), subtype);
+        return res;
+    }
+
+    /// @brief explicitly create an array from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/array/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json array(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::array);
+    }
+
+    /// @brief explicitly create an object from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/object/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json object(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::object);
+    }
+
+    /// @brief construct an array with count copies of given value
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(size_type cnt, const basic_json& val):
+        m_data{cnt, val}
+    {
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief construct a JSON container given an iterator range
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < class InputIT, typename std::enable_if <
+                   std::is_same<InputIT, typename basic_json_t::iterator>::value ||
+                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
+    basic_json(InputIT first, InputIT last)
+    {
+        JSON_ASSERT(first.m_object != nullptr);
+        JSON_ASSERT(last.m_object != nullptr);
+
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", nullptr));
+        }
+
+        // copy type from first iterator
+        m_data.m_type = first.m_object->m_data.m_type;
+
+        // check if iterator range is complete for primitive values
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
+                                         || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", first.m_object));
+                }
+                break;
+            }
+
+            case value_t::null:
+            case value_t::object:
+            case value_t::array:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                break;
+        }
+
+        switch (m_data.m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_data.m_value.number_integer = first.m_object->m_data.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value.number_unsigned = first.m_object->m_data.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value.number_float = first.m_object->m_data.m_value.number_float;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value.boolean = first.m_object->m_data.m_value.boolean;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value = *first.m_object->m_data.m_value.string;
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_data.m_value.object = create<object_t>(first.m_it.object_iterator,
+                                        last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value.array = create<array_t>(first.m_it.array_iterator,
+                                                       last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value = *first.m_object->m_data.m_value.binary;
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(invalid_iterator::create(206, detail::concat("cannot construct with iterators from ", first.m_object->type_name()), first.m_object));
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    ///////////////////////////////////////
+    // other constructors and destructor //
+    ///////////////////////////////////////
+
+    template<typename JsonRef,
+             detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
+                                 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
+    basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
+
+    /// @brief copy constructor
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(const basic_json& other)
+        : json_base_class_t(other)
+    {
+        m_data.m_type = other.m_data.m_type;
+        // check of passed value is valid
+        other.assert_invariant();
+
+        switch (m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_data.m_value = *other.m_data.m_value.object;
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value = *other.m_data.m_value.array;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value = *other.m_data.m_value.string;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value = other.m_data.m_value.boolean;
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                m_data.m_value = other.m_data.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value = other.m_data.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value = other.m_data.m_value.number_float;
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value = *other.m_data.m_value.binary;
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                break;
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief move constructor
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(basic_json&& other) noexcept
+        : json_base_class_t(std::forward<json_base_class_t>(other)),
+          m_data(std::move(other.m_data))
+    {
+        // check that passed value is valid
+        other.assert_invariant(false);
+
+        // invalidate payload
+        other.m_data.m_type = value_t::null;
+        other.m_data.m_value = {};
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief copy assignment
+    /// @sa https://json.nlohmann.me/api/basic_json/operator=/
+    basic_json& operator=(basic_json other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value&&
+        std::is_nothrow_move_assignable<json_base_class_t>::value
+    )
+    {
+        // check that passed value is valid
+        other.assert_invariant();
+
+        using std::swap;
+        swap(m_data.m_type, other.m_data.m_type);
+        swap(m_data.m_value, other.m_data.m_value);
+        json_base_class_t::operator=(std::move(other));
+
+        set_parents();
+        assert_invariant();
+        return *this;
+    }
+
+    /// @brief destructor
+    /// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
+    ~basic_json() noexcept
+    {
+        assert_invariant(false);
+    }
+
+    /// @}
+
+  public:
+    ///////////////////////
+    // object inspection //
+    ///////////////////////
+
+    /// @name object inspection
+    /// Functions to inspect the type of a JSON value.
+    /// @{
+
+    /// @brief serialization
+    /// @sa https://json.nlohmann.me/api/basic_json/dump/
+    string_t dump(const int indent = -1,
+                  const char indent_char = ' ',
+                  const bool ensure_ascii = false,
+                  const error_handler_t error_handler = error_handler_t::strict) const
+    {
+        string_t result;
+        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
+
+        if (indent >= 0)
+        {
+            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
+        }
+        else
+        {
+            s.dump(*this, false, ensure_ascii, 0);
+        }
+
+        return result;
+    }
+
+    /// @brief return the type of the JSON value (explicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/type/
+    constexpr value_t type() const noexcept
+    {
+        return m_data.m_type;
+    }
+
+    /// @brief return whether type is primitive
+    /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
+    constexpr bool is_primitive() const noexcept
+    {
+        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
+    }
+
+    /// @brief return whether type is structured
+    /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
+    constexpr bool is_structured() const noexcept
+    {
+        return is_array() || is_object();
+    }
+
+    /// @brief return whether value is null
+    /// @sa https://json.nlohmann.me/api/basic_json/is_null/
+    constexpr bool is_null() const noexcept
+    {
+        return m_data.m_type == value_t::null;
+    }
+
+    /// @brief return whether value is a boolean
+    /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
+    constexpr bool is_boolean() const noexcept
+    {
+        return m_data.m_type == value_t::boolean;
+    }
+
+    /// @brief return whether value is a number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number/
+    constexpr bool is_number() const noexcept
+    {
+        return is_number_integer() || is_number_float();
+    }
+
+    /// @brief return whether value is an integer number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
+    constexpr bool is_number_integer() const noexcept
+    {
+        return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
+    }
+
+    /// @brief return whether value is an unsigned integer number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
+    constexpr bool is_number_unsigned() const noexcept
+    {
+        return m_data.m_type == value_t::number_unsigned;
+    }
+
+    /// @brief return whether value is a floating-point number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
+    constexpr bool is_number_float() const noexcept
+    {
+        return m_data.m_type == value_t::number_float;
+    }
+
+    /// @brief return whether value is an object
+    /// @sa https://json.nlohmann.me/api/basic_json/is_object/
+    constexpr bool is_object() const noexcept
+    {
+        return m_data.m_type == value_t::object;
+    }
+
+    /// @brief return whether value is an array
+    /// @sa https://json.nlohmann.me/api/basic_json/is_array/
+    constexpr bool is_array() const noexcept
+    {
+        return m_data.m_type == value_t::array;
+    }
+
+    /// @brief return whether value is a string
+    /// @sa https://json.nlohmann.me/api/basic_json/is_string/
+    constexpr bool is_string() const noexcept
+    {
+        return m_data.m_type == value_t::string;
+    }
+
+    /// @brief return whether value is a binary array
+    /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
+    constexpr bool is_binary() const noexcept
+    {
+        return m_data.m_type == value_t::binary;
+    }
+
+    /// @brief return whether value is discarded
+    /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
+    constexpr bool is_discarded() const noexcept
+    {
+        return m_data.m_type == value_t::discarded;
+    }
+
+    /// @brief return the type of the JSON value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
+    constexpr operator value_t() const noexcept
+    {
+        return m_data.m_type;
+    }
+
+    /// @}
+
+  private:
+    //////////////////
+    // value access //
+    //////////////////
+
+    /// get a boolean (explicit)
+    boolean_t get_impl(boolean_t* /*unused*/) const
+    {
+        if (JSON_HEDLEY_LIKELY(is_boolean()))
+        {
+            return m_data.m_value.boolean;
+        }
+
+        JSON_THROW(type_error::create(302, detail::concat("type must be boolean, but is ", type_name()), this));
+    }
+
+    /// get a pointer to the value (object)
+    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
+    {
+        return is_object() ? m_data.m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (object)
+    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
+    {
+        return is_object() ? m_data.m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
+    {
+        return is_array() ? m_data.m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
+    {
+        return is_array() ? m_data.m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
+    {
+        return is_string() ? m_data.m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
+    {
+        return is_string() ? m_data.m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
+    {
+        return is_boolean() ? &m_data.m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
+    {
+        return is_boolean() ? &m_data.m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
+    {
+        return is_number_integer() ? &m_data.m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
+    {
+        return is_number_integer() ? &m_data.m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
+    {
+        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
+    {
+        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
+    {
+        return is_number_float() ? &m_data.m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
+    {
+        return is_number_float() ? &m_data.m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
+    {
+        return is_binary() ? m_data.m_value.binary : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
+    {
+        return is_binary() ? m_data.m_value.binary : nullptr;
+    }
+
+    /*!
+    @brief helper function to implement get_ref()
+
+    This function helps to implement get_ref() without code duplication for
+    const and non-const overloads
+
+    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
+
+    @throw type_error.303 if ReferenceType does not match underlying value
+    type of the current JSON
+    */
+    template<typename ReferenceType, typename ThisType>
+    static ReferenceType get_ref_impl(ThisType& obj)
+    {
+        // delegate the call to get_ptr<>()
+        auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
+
+        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
+        {
+            return *ptr;
+        }
+
+        JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
+    }
+
+  public:
+    /// @name value access
+    /// Direct access to the stored value of a JSON value.
+    /// @{
+
+    /// @brief get a pointer value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>()
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /// @brief get a pointer value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
+    template < typename PointerType, typename std::enable_if <
+                   std::is_pointer<PointerType>::value&&
+                   std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
+    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>() const
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+  private:
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType ret;
+    JSONSerializer<ValueType>::from_json(*this, ret);
+    return ret;
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+    - @ref json_serializer<ValueType> does not have a `from_json()` method of
+      the form `ValueType from_json(const basic_json&)`
+
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get__ValueType_const}
+
+    @since version 2.1.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   detail::is_default_constructible<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
+    {
+        auto ret = ValueType();
+        JSONSerializer<ValueType>::from_json(*this, ret);
+        return ret;
+    }
+
+    /*!
+    @brief get a value (explicit); special case
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    return JSONSerializer<ValueType>::from_json(*this);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json and
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `ValueType from_json(const basic_json&)`
+
+    @note If @ref json_serializer<ValueType> has both overloads of
+    `from_json()`, this one is chosen.
+
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @since version 2.1.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
+    {
+        return JSONSerializer<ValueType>::from_json(*this);
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads converts the current @ref basic_json in a different
+    @ref basic_json type
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this, converted into @a BasicJsonType
+
+    @complexity Depending on the implementation of the called `from_json()`
+                method.
+
+    @since version 3.2.0
+    */
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value,
+                   int > = 0 >
+    BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads avoids a lot of template boilerplate, it can be seen as the
+    identity method
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this
+
+    @complexity Constant.
+
+    @since version 2.1.0
+    */
+    template<typename BasicJsonType,
+             detail::enable_if_t<
+                 std::is_same<BasicJsonType, basic_json_t>::value,
+                 int> = 0>
+    basic_json get_impl(detail::priority_tag<3> /*unused*/) const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+    @copydoc get()
+    */
+    template<typename PointerType,
+             detail::enable_if_t<
+                 std::is_pointer<PointerType>::value,
+                 int> = 0>
+    constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
+    -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+  public:
+    /*!
+    @brief get a (pointer) value (explicit)
+
+    Performs explicit type conversion between the JSON value and a compatible value if required.
+
+    - If the requested type is a pointer to the internally stored JSON value that pointer is returned.
+    No copies are made.
+
+    - If the requested type is the current @ref basic_json, or a different @ref basic_json convertible
+    from the current @ref basic_json.
+
+    - Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`
+    method.
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @tparam ValueType if necessary
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required
+
+    @since version 2.1.0
+    */
+    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
+#if defined(JSON_HAS_CPP_14)
+    constexpr
+#endif
+    auto get() const noexcept(
+    noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
+    -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
+    {
+        // we cannot static_assert on ValueTypeCV being non-const, because
+        // there is support for get<const basic_json_t>(), which is why we
+        // still need the uncvref
+        static_assert(!std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        return get_impl<ValueType>(detail::priority_tag<4> {});
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+
+    Explicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning The pointer becomes invalid if the underlying JSON object
+    changes.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get__PointerType}
+
+    @sa see @ref get_ptr() for explicit pointer-member access
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /// @brief get a value (explicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_to/
+    template < typename ValueType,
+               detail::enable_if_t <
+                   !detail::is_basic_json<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType & get_to(ValueType& v) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<ValueType>::from_json(*this, v);
+        return v;
+    }
+
+    // specialization to allow calling get_to with a basic_json value
+    // see https://github.com/nlohmann/json/issues/2175
+    template<typename ValueType,
+             detail::enable_if_t <
+                 detail::is_basic_json<ValueType>::value,
+                 int> = 0>
+    ValueType & get_to(ValueType& v) const
+    {
+        v = *this;
+        return v;
+    }
+
+    template <
+        typename T, std::size_t N,
+        typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+        detail::enable_if_t <
+            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
+    Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+    noexcept(noexcept(JSONSerializer<Array>::from_json(
+                          std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<Array>::from_json(*this, v);
+        return v;
+    }
+
+    /// @brief get a reference value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
+    template<typename ReferenceType, typename std::enable_if<
+                 std::is_reference<ReferenceType>::value, int>::type = 0>
+    ReferenceType get_ref()
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /// @brief get a reference value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
+    template < typename ReferenceType, typename std::enable_if <
+                   std::is_reference<ReferenceType>::value&&
+                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
+    ReferenceType get_ref() const
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a value (implicit)
+
+    Implicit type conversion between the JSON value and a compatible value.
+    The call is realized by calling @ref get() const.
+
+    @tparam ValueType non-pointer type compatible to the JSON value, for
+    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+    `std::vector` types for JSON arrays. The character type of @ref string_t
+    as well as an initializer list of this type is excluded to avoid
+    ambiguities as these types implicitly convert to `std::string`.
+
+    @return copy of the JSON value, converted to type @a ValueType
+
+    @throw type_error.302 in case passed type @a ValueType is incompatible
+    to the JSON value type (e.g., the JSON value is of type boolean, but a
+    string is requested); see example below
+
+    @complexity Linear in the size of the JSON value.
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,operator__ValueType}
+
+    @since version 1.0.0
+    */
+    template < typename ValueType, typename std::enable_if <
+                   detail::conjunction <
+                       detail::negation<std::is_pointer<ValueType>>,
+                       detail::negation<std::is_same<ValueType, std::nullptr_t>>,
+                       detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
+                                        detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
+                                        detail::negation<detail::is_basic_json<ValueType>>,
+                                        detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
+#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
+                                                detail::negation<std::is_same<ValueType, std::string_view>>,
+#endif
+#if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
+                                                detail::negation<std::is_same<ValueType, std::any>>,
+#endif
+                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
+                                                >::value, int >::type = 0 >
+                                        JSON_EXPLICIT operator ValueType() const
+    {
+        // delegate the call to get<>() const
+        return get<ValueType>();
+    }
+
+    /// @brief get a binary value
+    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
+    binary_t& get_binary()
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
+        }
+
+        return *get_ptr<binary_t*>();
+    }
+
+    /// @brief get a binary value
+    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
+    const binary_t& get_binary() const
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
+        }
+
+        return *get_ptr<const binary_t*>();
+    }
+
+    /// @}
+
+    ////////////////////
+    // element access //
+    ////////////////////
+
+    /// @name element access
+    /// Access to the JSON value.
+    /// @{
+
+    /// @brief access specified array element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(size_type idx)
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return set_parent(m_data.m_value.array->at(idx));
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+    }
+
+    /// @brief access specified array element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(size_type idx) const
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_data.m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(const typename object_t::key_type& key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(key);
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
+        }
+        return set_parent(it->second);
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    reference at(KeyType && key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
+        }
+        return set_parent(it->second);
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(const typename object_t::key_type& key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(key);
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
+        }
+        return it->second;
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    const_reference at(KeyType && key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
+        }
+        return it->second;
+    }
+
+    /// @brief access specified array element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](size_type idx)
+    {
+        // implicitly convert null value to an empty array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // fill up array with null values if given idx is outside range
+            if (idx >= m_data.m_value.array->size())
+            {
+#if JSON_DIAGNOSTICS
+                // remember array size & capacity before resizing
+                const auto old_size = m_data.m_value.array->size();
+                const auto old_capacity = m_data.m_value.array->capacity();
+#endif
+                m_data.m_value.array->resize(idx + 1);
+
+#if JSON_DIAGNOSTICS
+                if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
+                {
+                    // capacity has changed: update all parents
+                    set_parents();
+                }
+                else
+                {
+                    // set parent for values added above
+                    set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
+                }
+#endif
+                assert_invariant();
+            }
+
+            return m_data.m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
+    }
+
+    /// @brief access specified array element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](size_type idx) const
+    {
+        // const operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            return m_data.m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](typename object_t::key_type key)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
+            return set_parent(result.first->second);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](const typename object_t::key_type& key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto it = m_data.m_value.object->find(key);
+            JSON_ASSERT(it != m_data.m_value.object->end());
+            return it->second;
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    // these two functions resolve a (const) char * ambiguity affecting Clang and MSVC
+    // (they seemingly cannot be constrained to resolve the ambiguity)
+    template<typename T>
+    reference operator[](T* key)
+    {
+        return operator[](typename object_t::key_type(key));
+    }
+
+    template<typename T>
+    const_reference operator[](T* key) const
+    {
+        return operator[](typename object_t::key_type(key));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    reference operator[](KeyType && key)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto result = m_data.m_value.object->emplace(std::forward<KeyType>(key), nullptr);
+            return set_parent(result.first->second);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    const_reference operator[](KeyType && key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+            JSON_ASSERT(it != m_data.m_value.object->end());
+            return it->second;
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+  private:
+    template<typename KeyType>
+    using is_comparable_with_object_key = detail::is_comparable <
+        object_comparator_t, const typename object_t::key_type&, KeyType >;
+
+    template<typename ValueType>
+    using value_return_type = std::conditional <
+        detail::is_c_string_uncvref<ValueType>::value,
+        string_t, typename std::decay<ValueType>::type >;
+
+  public:
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, detail::enable_if_t <
+                   !detail::is_transparent<object_comparator_t>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(key);
+            if (it != end())
+            {
+                return it->template get<ValueType>();
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   !detail::is_transparent<object_comparator_t>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(const typename object_t::key_type& key, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(key);
+            if (it != end())
+            {
+                return it->template get<ReturnType>();
+            }
+
+            return std::forward<ValueType>(default_value);
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class KeyType, detail::enable_if_t <
+                   detail::is_transparent<object_comparator_t>::value
+                   && !detail::is_json_pointer<KeyType>::value
+                   && is_comparable_with_object_key<KeyType>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(KeyType && key, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(std::forward<KeyType>(key));
+            if (it != end())
+            {
+                return it->template get<ValueType>();
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class KeyType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_transparent<object_comparator_t>::value
+                   && !detail::is_json_pointer<KeyType>::value
+                   && is_comparable_with_object_key<KeyType>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(KeyType && key, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(std::forward<KeyType>(key));
+            if (it != end())
+            {
+                return it->template get<ReturnType>();
+            }
+
+            return std::forward<ValueType>(default_value);
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, detail::enable_if_t <
+                   detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if pointer resolves a value, return it or use default value
+            JSON_TRY
+            {
+                return ptr.get_checked(this).template get<ValueType>();
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return default_value;
+            }
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(const json_pointer& ptr, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if pointer resolves a value, return it or use default value
+            JSON_TRY
+            {
+                return ptr.get_checked(this).template get<ReturnType>();
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return std::forward<ValueType>(default_value);
+            }
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    template < class ValueType, class BasicJsonType, detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const
+    {
+        return value(ptr.convert(), default_value);
+    }
+
+    template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const
+    {
+        return value(ptr.convert(), std::forward<ValueType>(default_value));
+    }
+
+    /// @brief access the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/front/
+    reference front()
+    {
+        return *begin();
+    }
+
+    /// @brief access the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/front/
+    const_reference front() const
+    {
+        return *cbegin();
+    }
+
+    /// @brief access the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/back/
+    reference back()
+    {
+        auto tmp = end();
+        --tmp;
+        return *tmp;
+    }
+
+    /// @brief access the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/back/
+    const_reference back() const
+    {
+        auto tmp = cend();
+        --tmp;
+        return *tmp;
+    }
+
+    /// @brief remove element given an iterator
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template < class IteratorType, detail::enable_if_t <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
+    IteratorType erase(IteratorType pos)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        IteratorType result = end();
+
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
+                {
+                    JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
+                    m_data.m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
+                    m_data.m_value.binary = nullptr;
+                }
+
+                m_data.m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return result;
+    }
+
+    /// @brief remove elements given an iterator range
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template < class IteratorType, detail::enable_if_t <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
+    IteratorType erase(IteratorType first, IteratorType last)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", this));
+        }
+
+        IteratorType result = end();
+
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
+                                       || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", this));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
+                    m_data.m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
+                    m_data.m_value.binary = nullptr;
+                }
+
+                m_data.m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_data.m_value.object->erase(first.m_it.object_iterator,
+                                              last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_data.m_value.array->erase(first.m_it.array_iterator,
+                                             last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return result;
+    }
+
+  private:
+    template < typename KeyType, detail::enable_if_t <
+                   detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    size_type erase_internal(KeyType && key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return m_data.m_value.object->erase(std::forward<KeyType>(key));
+    }
+
+    template < typename KeyType, detail::enable_if_t <
+                   !detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    size_type erase_internal(KeyType && key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        const auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it != m_data.m_value.object->end())
+        {
+            m_data.m_value.object->erase(it);
+            return 1;
+        }
+        return 0;
+    }
+
+  public:
+
+    /// @brief remove element from a JSON object given a key
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    size_type erase(const typename object_t::key_type& key)
+    {
+        // the indirection via erase_internal() is added to avoid making this
+        // function a template and thus de-rank it during overload resolution
+        return erase_internal(key);
+    }
+
+    /// @brief remove element from a JSON object given a key
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    size_type erase(KeyType && key)
+    {
+        return erase_internal(std::forward<KeyType>(key));
+    }
+
+    /// @brief remove element from a JSON array given an index
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    void erase(const size_type idx)
+    {
+        // this erase only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
+            {
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            }
+
+            m_data.m_value.array->erase(m_data.m_value.array->begin() + static_cast<difference_type>(idx));
+        }
+        else
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+    }
+
+    /// @}
+
+    ////////////
+    // lookup //
+    ////////////
+
+    /// @name lookup
+    /// @{
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    iterator find(const typename object_t::key_type& key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(key);
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    const_iterator find(const typename object_t::key_type& key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(key);
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    iterator find(KeyType && key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    const_iterator find(KeyType && key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
+        }
+
+        return result;
+    }
+
+    /// @brief returns the number of occurrences of a key in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/count/
+    size_type count(const typename object_t::key_type& key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_data.m_value.object->count(key) : 0;
+    }
+
+    /// @brief returns the number of occurrences of a key in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/count/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    size_type count(KeyType && key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_data.m_value.object->count(std::forward<KeyType>(key)) : 0;
+    }
+
+    /// @brief check the existence of an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    bool contains(const typename object_t::key_type& key) const
+    {
+        return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
+    }
+
+    /// @brief check the existence of an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    bool contains(KeyType && key) const
+    {
+        return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
+    }
+
+    /// @brief check the existence of an element in a JSON object given a JSON pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    bool contains(const json_pointer& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    /// @}
+
+    ///////////////
+    // iterators //
+    ///////////////
+
+    /// @name iterators
+    /// @{
+
+    /// @brief returns an iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/begin/
+    iterator begin() noexcept
+    {
+        iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /// @brief returns an iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/begin/
+    const_iterator begin() const noexcept
+    {
+        return cbegin();
+    }
+
+    /// @brief returns a const iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/cbegin/
+    const_iterator cbegin() const noexcept
+    {
+        const_iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/end/
+    iterator end() noexcept
+    {
+        iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/end/
+    const_iterator end() const noexcept
+    {
+        return cend();
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/cend/
+    const_iterator cend() const noexcept
+    {
+        const_iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /// @brief returns an iterator to the reverse-beginning
+    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
+    reverse_iterator rbegin() noexcept
+    {
+        return reverse_iterator(end());
+    }
+
+    /// @brief returns an iterator to the reverse-beginning
+    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return crbegin();
+    }
+
+    /// @brief returns an iterator to the reverse-end
+    /// @sa https://json.nlohmann.me/api/basic_json/rend/
+    reverse_iterator rend() noexcept
+    {
+        return reverse_iterator(begin());
+    }
+
+    /// @brief returns an iterator to the reverse-end
+    /// @sa https://json.nlohmann.me/api/basic_json/rend/
+    const_reverse_iterator rend() const noexcept
+    {
+        return crend();
+    }
+
+    /// @brief returns a const reverse iterator to the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/crbegin/
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return const_reverse_iterator(cend());
+    }
+
+    /// @brief returns a const reverse iterator to one before the first
+    /// @sa https://json.nlohmann.me/api/basic_json/crend/
+    const_reverse_iterator crend() const noexcept
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
+  public:
+    /// @brief wrapper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use @ref items() instead;
+    ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /// @brief wrapper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
+    ///         version 4.0.0 of the library. Please use @ref items() instead;
+    ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /// @brief helper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    iteration_proxy<iterator> items() noexcept
+    {
+        return iteration_proxy<iterator>(*this);
+    }
+
+    /// @brief helper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    iteration_proxy<const_iterator> items() const noexcept
+    {
+        return iteration_proxy<const_iterator>(*this);
+    }
+
+    /// @}
+
+    //////////////
+    // capacity //
+    //////////////
+
+    /// @name capacity
+    /// @{
+
+    /// @brief checks whether the container is empty.
+    /// @sa https://json.nlohmann.me/api/basic_json/empty/
+    bool empty() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return true;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::empty()
+                return m_data.m_value.array->empty();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::empty()
+                return m_data.m_value.object->empty();
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types are nonempty
+                return false;
+            }
+        }
+    }
+
+    /// @brief returns the number of elements
+    /// @sa https://json.nlohmann.me/api/basic_json/size/
+    size_type size() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return 0;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::size()
+                return m_data.m_value.array->size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::size()
+                return m_data.m_value.object->size();
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types have size 1
+                return 1;
+            }
+        }
+    }
+
+    /// @brief returns the maximum possible number of elements
+    /// @sa https://json.nlohmann.me/api/basic_json/max_size/
+    size_type max_size() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::array:
+            {
+                // delegate call to array_t::max_size()
+                return m_data.m_value.array->max_size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::max_size()
+                return m_data.m_value.object->max_size();
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types have max_size() == size()
+                return size();
+            }
+        }
+    }
+
+    /// @}
+
+    ///////////////
+    // modifiers //
+    ///////////////
+
+    /// @name modifiers
+    /// @{
+
+    /// @brief clears the contents
+    /// @sa https://json.nlohmann.me/api/basic_json/clear/
+    void clear() noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_data.m_value.number_integer = 0;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value.number_unsigned = 0;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value.number_float = 0.0;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value.boolean = false;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value.string->clear();
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value.binary->clear();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value.array->clear();
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_data.m_value.object->clear();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(basic_json&& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (move semantics)
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->push_back(std::move(val));
+        set_parent(m_data.m_value.array->back(), old_capacity);
+        // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(basic_json&& val)
+    {
+        push_back(std::move(val));
+        return *this;
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(const basic_json& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->push_back(val);
+        set_parent(m_data.m_value.array->back(), old_capacity);
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(const basic_json& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(const typename object_t::value_type& val)
+    {
+        // push_back only works for null objects or objects
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to object
+        auto res = m_data.m_value.object->insert(val);
+        set_parent(res.first->second);
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(const typename object_t::value_type& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(initializer_list_t init)
+    {
+        if (is_object() && init.size() == 2 && (*init.begin())->is_string())
+        {
+            basic_json&& key = init.begin()->moved_or_copied();
+            push_back(typename object_t::value_type(
+                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
+        }
+        else
+        {
+            push_back(basic_json(init));
+        }
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(initializer_list_t init)
+    {
+        push_back(init);
+        return *this;
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
+    template<class... Args>
+    reference emplace_back(Args&& ... args)
+    {
+        // emplace_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
+        return set_parent(m_data.m_value.array->back(), old_capacity);
+    }
+
+    /// @brief add an object to an object if key does not exist
+    /// @sa https://json.nlohmann.me/api/basic_json/emplace/
+    template<class... Args>
+    std::pair<iterator, bool> emplace(Args&& ... args)
+    {
+        // emplace only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace() with ", type_name()), this));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+        auto res = m_data.m_value.object->emplace(std::forward<Args>(args)...);
+        set_parent(res.first->second);
+
+        // create result iterator and set iterator to the result of emplace
+        auto it = begin();
+        it.m_it.object_iterator = res.first;
+
+        // return pair of iterator and boolean
+        return {it, res.second};
+    }
+
+    /// Helper for insertion of an iterator
+    /// @note: This uses std::distance to support GCC 4.8,
+    ///        see https://github.com/nlohmann/json/pull/1257
+    template<typename... Args>
+    iterator insert_iterator(const_iterator pos, Args&& ... args)
+    {
+        iterator result(this);
+        JSON_ASSERT(m_data.m_value.array != nullptr);
+
+        auto insert_pos = std::distance(m_data.m_value.array->begin(), pos.m_it.array_iterator);
+        m_data.m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
+        result.m_it.array_iterator = m_data.m_value.array->begin() + insert_pos;
+
+        // This could have been written as:
+        // result.m_it.array_iterator = m_data.m_value.array->insert(pos.m_it.array_iterator, cnt, val);
+        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
+
+        set_parents();
+        return result;
+    }
+
+    /// @brief inserts element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, val);
+        }
+
+        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+    }
+
+    /// @brief inserts element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, basic_json&& val)
+    {
+        return insert(pos, val);
+    }
+
+    /// @brief inserts copies of element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, cnt, val);
+        }
+
+        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+    }
+
+    /// @brief inserts range of elements into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, const_iterator first, const_iterator last)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
+        {
+            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", this));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
+    }
+
+    /// @brief inserts elements from initializer list into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, initializer_list_t ilist)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, ilist.begin(), ilist.end());
+    }
+
+    /// @brief inserts range of elements into object
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    void insert(const_iterator first, const_iterator last)
+    {
+        // insert only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", this));
+        }
+
+        m_data.m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
+    }
+
+    /// @brief updates a JSON object from another object, overwriting existing keys
+    /// @sa https://json.nlohmann.me/api/basic_json/update/
+    void update(const_reference j, bool merge_objects = false)
+    {
+        update(j.begin(), j.end(), merge_objects);
+    }
+
+    /// @brief updates a JSON object from another object, overwriting existing keys
+    /// @sa https://json.nlohmann.me/api/basic_json/update/
+    void update(const_iterator first, const_iterator last, bool merge_objects = false)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", type_name()), this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
+        }
+
+        for (auto it = first; it != last; ++it)
+        {
+            if (merge_objects && it.value().is_object())
+            {
+                auto it2 = m_data.m_value.object->find(it.key());
+                if (it2 != m_data.m_value.object->end())
+                {
+                    it2->second.update(it.value(), true);
+                    continue;
+                }
+            }
+            m_data.m_value.object->operator[](it.key()) = it.value();
+#if JSON_DIAGNOSTICS
+            m_data.m_value.object->operator[](it.key()).m_parent = this;
+#endif
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(reference other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        std::swap(m_data.m_type, other.m_data.m_type);
+        std::swap(m_data.m_value, other.m_data.m_value);
+
+        set_parents();
+        other.set_parents();
+        assert_invariant();
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    friend void swap(reference left, reference right) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        left.swap(right);
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(array_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.array), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(array_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(object_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.object), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(object_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(string_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_string()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.string), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(string_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(binary_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t::container_type&) with ", type_name()), this));
+        }
+    }
+
+    /// @}
+
+    //////////////////////////////////////////
+    // lexicographical comparison operators //
+    //////////////////////////////////////////
+
+    /// @name lexicographical comparison operators
+    /// @{
+
+    // note parentheses around operands are necessary; see
+    // https://github.com/nlohmann/json/issues/1530
+#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result)                       \
+    const auto lhs_type = lhs.type();                                                                    \
+    const auto rhs_type = rhs.type();                                                                    \
+    \
+    if (lhs_type == rhs_type) /* NOLINT(readability/braces) */                                           \
+    {                                                                                                    \
+        switch (lhs_type)                                                                                \
+        {                                                                                                \
+            case value_t::array:                                                                         \
+                return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array);                                     \
+                \
+            case value_t::object:                                                                        \
+                return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object);                                   \
+                \
+            case value_t::null:                                                                          \
+                return (null_result);                                                                    \
+                \
+            case value_t::string:                                                                        \
+                return (*lhs.m_data.m_value.string) op (*rhs.m_data.m_value.string);                                   \
+                \
+            case value_t::boolean:                                                                       \
+                return (lhs.m_data.m_value.boolean) op (rhs.m_data.m_value.boolean);                                   \
+                \
+            case value_t::number_integer:                                                                \
+                return (lhs.m_data.m_value.number_integer) op (rhs.m_data.m_value.number_integer);                     \
+                \
+            case value_t::number_unsigned:                                                               \
+                return (lhs.m_data.m_value.number_unsigned) op (rhs.m_data.m_value.number_unsigned);                   \
+                \
+            case value_t::number_float:                                                                  \
+                return (lhs.m_data.m_value.number_float) op (rhs.m_data.m_value.number_float);                         \
+                \
+            case value_t::binary:                                                                        \
+                return (*lhs.m_data.m_value.binary) op (*rhs.m_data.m_value.binary);                                   \
+                \
+            case value_t::discarded:                                                                     \
+            default:                                                                                     \
+                return (unordered_result);                                                               \
+        }                                                                                                \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)                   \
+    {                                                                                                    \
+        return static_cast<number_float_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float;      \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)                   \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_integer);      \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)                  \
+    {                                                                                                    \
+        return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float;     \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)                  \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_unsigned);     \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)                \
+    {                                                                                                    \
+        return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_integer; \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)                \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>(rhs.m_data.m_value.number_unsigned); \
+    }                                                                                                    \
+    else if(compares_unordered(lhs, rhs))\
+    {\
+        return (unordered_result);\
+    }\
+    \
+    return (default_result);
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // returns true if:
+    // - any operand is NaN and the other operand is of number type
+    // - any operand is discarded
+    // in legacy mode, discarded values are considered ordered if
+    // an operation is computed as an odd number of inverses of others
+    static bool compares_unordered(const_reference lhs, const_reference rhs, bool inverse = false) noexcept
+    {
+        if ((lhs.is_number_float() && std::isnan(lhs.m_data.m_value.number_float) && rhs.is_number())
+                || (rhs.is_number_float() && std::isnan(rhs.m_data.m_value.number_float) && lhs.is_number()))
+        {
+            return true;
+        }
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+        return (lhs.is_discarded() || rhs.is_discarded()) && !inverse;
+#else
+        static_cast<void>(inverse);
+        return lhs.is_discarded() || rhs.is_discarded();
+#endif
+    }
+
+  private:
+    bool compares_unordered(const_reference rhs, bool inverse = false) const noexcept
+    {
+        return compares_unordered(*this, rhs, inverse);
+    }
+
+  public:
+#if JSON_HAS_THREE_WAY_COMPARISON
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    bool operator==(const_reference rhs) const noexcept
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        const_reference lhs = *this;
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator==(ScalarType rhs) const noexcept
+    {
+        return *this == basic_json(rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    bool operator!=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !operator==(rhs);
+    }
+
+    /// @brief comparison: 3-way
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
+    std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD*
+    {
+        const_reference lhs = *this;
+        // default_result is used if we cannot compare values. In that case,
+        // we compare types.
+        JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*
+                                std::partial_ordering::equivalent,
+                                std::partial_ordering::unordered,
+                                lhs_type <=> rhs_type) // *NOPAD*
+    }
+
+    /// @brief comparison: 3-way
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    std::partial_ordering operator<=>(ScalarType rhs) const noexcept // *NOPAD*
+    {
+        return *this <=> basic_json(rhs); // *NOPAD*
+    }
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    // all operators that are computed as an odd number of inverses of others
+    // need to be overloaded to emulate the legacy comparison behavior
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
+    bool operator<=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !(rhs < *this);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator<=(ScalarType rhs) const noexcept
+    {
+        return *this <= basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
+    bool operator>=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !(*this < rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator>=(ScalarType rhs) const noexcept
+    {
+        return *this >= basic_json(rhs);
+    }
+#endif
+#else
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs == basic_json(rhs);
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) == rhs;
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(lhs == rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs != basic_json(rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) != rhs;
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
+    {
+        // default_result is used if we cannot compare values. In that case,
+        // we compare types. Note we have to call the operator explicitly,
+        // because MSVC has problems otherwise.
+        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type))
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs < basic_json(rhs);
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) < rhs;
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(rhs < lhs);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs <= basic_json(rhs);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) <= rhs;
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
+    {
+        // double inverse
+        if (compares_unordered(lhs, rhs))
+        {
+            return false;
+        }
+        return !(lhs <= rhs);
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs > basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) > rhs;
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(lhs < rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs >= basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) >= rhs;
+    }
+#endif
+
+#undef JSON_IMPLEMENT_OPERATOR
+
+    /// @}
+
+    ///////////////////
+    // serialization //
+    ///////////////////
+
+    /// @name serialization
+    /// @{
+#ifndef JSON_NO_IO
+    /// @brief serialize to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
+    {
+        // read width member and use it as indentation parameter if nonzero
+        const bool pretty_print = o.width() > 0;
+        const auto indentation = pretty_print ? o.width() : 0;
+
+        // reset width to 0 for subsequent calls to this stream
+        o.width(0);
+
+        // do the actual serialization
+        serializer s(detail::output_adapter<char>(o), o.fill());
+        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
+        return o;
+    }
+
+    /// @brief serialize to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    /// @deprecated This function is deprecated since 3.0.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             operator<<(std::ostream&, const basic_json&) instead; that is,
+    ///             replace calls like `j >> o;` with `o << j;`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
+    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
+    {
+        return o << j;
+    }
+#endif  // JSON_NO_IO
+    /// @}
+
+    /////////////////////
+    // deserialization //
+    /////////////////////
+
+    /// @name deserialization
+    /// @{
+
+    /// @brief deserialize from a compatible input
+    /// @sa https://json.nlohmann.me/api/basic_json/parse/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(InputType&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    /// @brief deserialize from a pair of character iterators
+    /// @sa https://json.nlohmann.me/api/basic_json/parse/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(IteratorType first,
+                            IteratorType last,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
+    static basic_json parse(detail::span_input_adapter&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    /// @brief check if the input is valid JSON
+    /// @sa https://json.nlohmann.me/api/basic_json/accept/
+    template<typename InputType>
+    static bool accept(InputType&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    /// @brief check if the input is valid JSON
+    /// @sa https://json.nlohmann.me/api/basic_json/accept/
+    template<typename IteratorType>
+    static bool accept(IteratorType first, IteratorType last,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
+    static bool accept(detail::span_input_adapter&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(i.get(), nullptr, false, ignore_comments).accept(true);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    template <typename InputType, typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(InputType&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    template<class IteratorType, class SAX>
+    JSON_HEDLEY_NON_NULL(3)
+    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    /// @deprecated This function is deprecated since 3.8.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             sax_parse(ptr, ptr + len) instead.
+    template <typename SAX>
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = i.get();
+        return format == input_format_t::json
+               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+#ifndef JSON_NO_IO
+    /// @brief deserialize from stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
+    /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             operator>>(std::istream&, basic_json&) instead; that is,
+    ///             replace calls like `j << i;` with `i >> j;`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
+    friend std::istream& operator<<(basic_json& j, std::istream& i)
+    {
+        return operator>>(i, j);
+    }
+
+    /// @brief deserialize from stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
+    friend std::istream& operator>>(std::istream& i, basic_json& j)
+    {
+        parser(detail::input_adapter(i)).parse(false, j);
+        return i;
+    }
+#endif  // JSON_NO_IO
+    /// @}
+
+    ///////////////////////////
+    // convenience functions //
+    ///////////////////////////
+
+    /// @brief return the type as string
+    /// @sa https://json.nlohmann.me/api/basic_json/type_name/
+    JSON_HEDLEY_RETURNS_NON_NULL
+    const char* type_name() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+                return "null";
+            case value_t::object:
+                return "object";
+            case value_t::array:
+                return "array";
+            case value_t::string:
+                return "string";
+            case value_t::boolean:
+                return "boolean";
+            case value_t::binary:
+                return "binary";
+            case value_t::discarded:
+                return "discarded";
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            default:
+                return "number";
+        }
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    //////////////////////
+    // member variables //
+    //////////////////////
+
+    struct data
+    {
+        /// the type of the current element
+        value_t m_type = value_t::null;
+
+        /// the value of the current element
+        json_value m_value = {};
+
+        data(const value_t v)
+            : m_type(v), m_value(v)
+        {
+        }
+
+        data(size_type cnt, const basic_json& val)
+            : m_type(value_t::array)
+        {
+            m_value.array = create<array_t>(cnt, val);
+        }
+
+        data() noexcept = default;
+        data(data&&) noexcept = default;
+        data(const data&) noexcept = delete;
+        data& operator=(data&&) noexcept = delete;
+        data& operator=(const data&) noexcept = delete;
+
+        ~data() noexcept
+        {
+            m_value.destroy(m_type);
+        }
+    };
+
+    data m_data = {};
+
+#if JSON_DIAGNOSTICS
+    /// a pointer to a parent value (for debugging purposes)
+    basic_json* m_parent = nullptr;
+#endif
+
+    //////////////////////////////////////////
+    // binary serialization/deserialization //
+    //////////////////////////////////////////
+
+    /// @name binary serialization/deserialization support
+    /// @{
+
+  public:
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static std::vector<std::uint8_t> to_cbor(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_cbor(j, result);
+        return result;
+    }
+
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_cbor(j);
+    }
+
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_cbor(j);
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_msgpack(j, result);
+        return result;
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_msgpack(j);
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_msgpack(j);
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
+            const bool use_size = false,
+            const bool use_type = false)
+    {
+        std::vector<std::uint8_t> result;
+        to_ubjson(j, result, use_size, use_type);
+        return result;
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
+            const bool use_size = false,
+            const bool use_type = false)
+    {
+        std::vector<std::uint8_t> result;
+        to_bjdata(j, result, use_size, use_type);
+        return result;
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true, true);
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type, true, true);
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static std::vector<std::uint8_t> to_bson(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_bson(j, result);
+        return result;
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_bson(j);
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_bson(j);
+    }
+
+    /// @brief create a JSON value from an input in CBOR format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in CBOR format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in MessagePack format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(InputType&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in MessagePack format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(IteratorType first, IteratorType last,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(const T* ptr, std::size_t len,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(detail::span_input_adapter&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in UBJSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(InputType&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in UBJSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(IteratorType first, IteratorType last,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(const T* ptr, std::size_t len,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(detail::span_input_adapter&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BJData format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bjdata(InputType&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BJData format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bjdata(IteratorType first, IteratorType last,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        return from_bson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+    /// @}
+
+    //////////////////////////
+    // JSON Pointer support //
+    //////////////////////////
+
+    /// @name JSON Pointer functions
+    /// @{
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](const json_pointer& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](const json_pointer& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(const json_pointer& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(const json_pointer& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    /// @brief return flattened JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/flatten/
+    basic_json flatten() const
+    {
+        basic_json result(value_t::object);
+        json_pointer::flatten("", *this, result);
+        return result;
+    }
+
+    /// @brief unflatten a previously flattened JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/unflatten/
+    basic_json unflatten() const
+    {
+        return json_pointer::unflatten(*this);
+    }
+
+    /// @}
+
+    //////////////////////////
+    // JSON Patch functions //
+    //////////////////////////
+
+    /// @name JSON Patch functions
+    /// @{
+
+    /// @brief applies a JSON patch in-place without copying the object
+    /// @sa https://json.nlohmann.me/api/basic_json/patch/
+    void patch_inplace(const basic_json& json_patch)
+    {
+        basic_json& result = *this;
+        // the valid JSON Patch operations
+        enum class patch_operations {add, remove, replace, move, copy, test, invalid};
+
+        const auto get_op = [](const std::string & op)
+        {
+            if (op == "add")
+            {
+                return patch_operations::add;
+            }
+            if (op == "remove")
+            {
+                return patch_operations::remove;
+            }
+            if (op == "replace")
+            {
+                return patch_operations::replace;
+            }
+            if (op == "move")
+            {
+                return patch_operations::move;
+            }
+            if (op == "copy")
+            {
+                return patch_operations::copy;
+            }
+            if (op == "test")
+            {
+                return patch_operations::test;
+            }
+
+            return patch_operations::invalid;
+        };
+
+        // wrapper for "add" operation; add value at ptr
+        const auto operation_add = [&result](json_pointer & ptr, basic_json val)
+        {
+            // adding to the root of the target document means replacing it
+            if (ptr.empty())
+            {
+                result = val;
+                return;
+            }
+
+            // make sure the top element of the pointer exists
+            json_pointer const top_pointer = ptr.top();
+            if (top_pointer != ptr)
+            {
+                result.at(top_pointer);
+            }
+
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            // parent must exist when performing patch add per RFC6902 specs
+            basic_json& parent = result.at(ptr);
+
+            switch (parent.m_data.m_type)
+            {
+                case value_t::null:
+                case value_t::object:
+                {
+                    // use operator[] to add value
+                    parent[last_path] = val;
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    if (last_path == "-")
+                    {
+                        // special case: append to back
+                        parent.push_back(val);
+                    }
+                    else
+                    {
+                        const auto idx = json_pointer::template array_index<basic_json_t>(last_path);
+                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
+                        {
+                            // avoid undefined behavior
+                            JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent));
+                        }
+
+                        // default case: insert add offset
+                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
+                    }
+                    break;
+                }
+
+                // if there exists a parent it cannot be primitive
+                case value_t::string: // LCOV_EXCL_LINE
+                case value_t::boolean: // LCOV_EXCL_LINE
+                case value_t::number_integer: // LCOV_EXCL_LINE
+                case value_t::number_unsigned: // LCOV_EXCL_LINE
+                case value_t::number_float: // LCOV_EXCL_LINE
+                case value_t::binary: // LCOV_EXCL_LINE
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            }
+        };
+
+        // wrapper for "remove" operation; remove value at ptr
+        const auto operation_remove = [this, & result](json_pointer & ptr)
+        {
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            basic_json& parent = result.at(ptr);
+
+            // remove child
+            if (parent.is_object())
+            {
+                // perform range check
+                auto it = parent.find(last_path);
+                if (JSON_HEDLEY_LIKELY(it != parent.end()))
+                {
+                    parent.erase(it);
+                }
+                else
+                {
+                    JSON_THROW(out_of_range::create(403, detail::concat("key '", last_path, "' not found"), this));
+                }
+            }
+            else if (parent.is_array())
+            {
+                // note erase performs range check
+                parent.erase(json_pointer::template array_index<basic_json_t>(last_path));
+            }
+        };
+
+        // type check: top level value must be an array
+        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
+        {
+            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &json_patch));
+        }
+
+        // iterate and apply the operations
+        for (const auto& val : json_patch)
+        {
+            // wrapper to get a value for an operation
+            const auto get_value = [&val](const std::string & op,
+                                          const std::string & member,
+                                          bool string_type) -> basic_json &
+            {
+                // find value
+                auto it = val.m_data.m_value.object->find(member);
+
+                // context-sensitive error message
+                const auto error_msg = (op == "op") ? "operation" : detail::concat("operation '", op, '\'');
+
+                // check if desired value is present
+                if (JSON_HEDLEY_UNLIKELY(it == val.m_data.m_value.object->end()))
+                {
+                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
+                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have member '", member, "'"), &val));
+                }
+
+                // check if result is of type string
+                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
+                {
+                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
+                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have string member '", member, "'"), &val));
+                }
+
+                // no error: return value
+                return it->second;
+            };
+
+            // type check: every element of the array must be an object
+            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
+            {
+                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &val));
+            }
+
+            // collect mandatory members
+            const auto op = get_value("op", "op", true).template get<std::string>();
+            const auto path = get_value(op, "path", true).template get<std::string>();
+            json_pointer ptr(path);
+
+            switch (get_op(op))
+            {
+                case patch_operations::add:
+                {
+                    operation_add(ptr, get_value("add", "value", false));
+                    break;
+                }
+
+                case patch_operations::remove:
+                {
+                    operation_remove(ptr);
+                    break;
+                }
+
+                case patch_operations::replace:
+                {
+                    // the "path" location must exist - use at()
+                    result.at(ptr) = get_value("replace", "value", false);
+                    break;
+                }
+
+                case patch_operations::move:
+                {
+                    const auto from_path = get_value("move", "from", true).template get<std::string>();
+                    json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json const v = result.at(from_ptr);
+
+                    // The move operation is functionally identical to a
+                    // "remove" operation on the "from" location, followed
+                    // immediately by an "add" operation at the target
+                    // location with the value that was just removed.
+                    operation_remove(from_ptr);
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::copy:
+                {
+                    const auto from_path = get_value("copy", "from", true).template get<std::string>();
+                    const json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json const v = result.at(from_ptr);
+
+                    // The copy is functionally identical to an "add"
+                    // operation at the target location using the value
+                    // specified in the "from" member.
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::test:
+                {
+                    bool success = false;
+                    JSON_TRY
+                    {
+                        // check if "value" matches the one at "path"
+                        // the "path" location must exist - use at()
+                        success = (result.at(ptr) == get_value("test", "value", false));
+                    }
+                    JSON_INTERNAL_CATCH (out_of_range&)
+                    {
+                        // ignore out of range errors: success remains false
+                    }
+
+                    // throw an exception if test fails
+                    if (JSON_HEDLEY_UNLIKELY(!success))
+                    {
+                        JSON_THROW(other_error::create(501, detail::concat("unsuccessful: ", val.dump()), &val));
+                    }
+
+                    break;
+                }
+
+                case patch_operations::invalid:
+                default:
+                {
+                    // op must be "add", "remove", "replace", "move", "copy", or
+                    // "test"
+                    JSON_THROW(parse_error::create(105, 0, detail::concat("operation value '", op, "' is invalid"), &val));
+                }
+            }
+        }
+    }
+
+    /// @brief applies a JSON patch to a copy of the current object
+    /// @sa https://json.nlohmann.me/api/basic_json/patch/
+    basic_json patch(const basic_json& json_patch) const
+    {
+        basic_json result = *this;
+        result.patch_inplace(json_patch);
+        return result;
+    }
+
+    /// @brief creates a diff as a JSON patch
+    /// @sa https://json.nlohmann.me/api/basic_json/diff/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json diff(const basic_json& source, const basic_json& target,
+                           const std::string& path = "")
+    {
+        // the patch
+        basic_json result(value_t::array);
+
+        // if the values are the same, return empty patch
+        if (source == target)
+        {
+            return result;
+        }
+
+        if (source.type() != target.type())
+        {
+            // different types: replace value
+            result.push_back(
+            {
+                {"op", "replace"}, {"path", path}, {"value", target}
+            });
+            return result;
+        }
+
+        switch (source.type())
+        {
+            case value_t::array:
+            {
+                // first pass: traverse common elements
+                std::size_t i = 0;
+                while (i < source.size() && i < target.size())
+                {
+                    // recursive call to compare array values at index i
+                    auto temp_diff = diff(source[i], target[i], detail::concat(path, '/', std::to_string(i)));
+                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    ++i;
+                }
+
+                // We now reached the end of at least one array
+                // in a second pass, traverse the remaining elements
+
+                // remove my remaining elements
+                const auto end_index = static_cast<difference_type>(result.size());
+                while (i < source.size())
+                {
+                    // add operations in reverse order to avoid invalid
+                    // indices
+                    result.insert(result.begin() + end_index, object(
+                    {
+                        {"op", "remove"},
+                        {"path", detail::concat(path, '/', std::to_string(i))}
+                    }));
+                    ++i;
+                }
+
+                // add other remaining elements
+                while (i < target.size())
+                {
+                    result.push_back(
+                    {
+                        {"op", "add"},
+                        {"path", detail::concat(path, "/-")},
+                        {"value", target[i]}
+                    });
+                    ++i;
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // first pass: traverse this object's elements
+                for (auto it = source.cbegin(); it != source.cend(); ++it)
+                {
+                    // escape the key name to be used in a JSON patch
+                    const auto path_key = detail::concat(path, '/', detail::escape(it.key()));
+
+                    if (target.find(it.key()) != target.end())
+                    {
+                        // recursive call to compare object values at key it
+                        auto temp_diff = diff(it.value(), target[it.key()], path_key);
+                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    }
+                    else
+                    {
+                        // found a key that is not in o -> remove it
+                        result.push_back(object(
+                        {
+                            {"op", "remove"}, {"path", path_key}
+                        }));
+                    }
+                }
+
+                // second pass: traverse other object's elements
+                for (auto it = target.cbegin(); it != target.cend(); ++it)
+                {
+                    if (source.find(it.key()) == source.end())
+                    {
+                        // found a key that is not in this -> add it
+                        const auto path_key = detail::concat(path, '/', detail::escape(it.key()));
+                        result.push_back(
+                        {
+                            {"op", "add"}, {"path", path_key},
+                            {"value", it.value()}
+                        });
+                    }
+                }
+
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // both primitive type: replace value
+                result.push_back(
+                {
+                    {"op", "replace"}, {"path", path}, {"value", target}
+                });
+                break;
+            }
+        }
+
+        return result;
+    }
+    /// @}
+
+    ////////////////////////////////
+    // JSON Merge Patch functions //
+    ////////////////////////////////
+
+    /// @name JSON Merge Patch functions
+    /// @{
+
+    /// @brief applies a JSON Merge Patch
+    /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
+    void merge_patch(const basic_json& apply_patch)
+    {
+        if (apply_patch.is_object())
+        {
+            if (!is_object())
+            {
+                *this = object();
+            }
+            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
+            {
+                if (it.value().is_null())
+                {
+                    erase(it.key());
+                }
+                else
+                {
+                    operator[](it.key()).merge_patch(it.value());
+                }
+            }
+        }
+        else
+        {
+            *this = apply_patch;
+        }
+    }
+
+    /// @}
+};
+
+/// @brief user-defined to_string function for JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/to_string/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
+{
+    return j.dump();
+}
+
+inline namespace literals
+{
+inline namespace json_literals
+{
+
+/// @brief user-defined string literal for JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
+JSON_HEDLEY_NON_NULL(1)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json operator ""_json(const char* s, std::size_t n)
+#else
+    inline nlohmann::json operator "" _json(const char* s, std::size_t n)
+#endif
+{
+    return nlohmann::json::parse(s, s + n);
+}
+
+/// @brief user-defined string literal for JSON pointer
+/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
+JSON_HEDLEY_NON_NULL(1)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json::json_pointer operator ""_json_pointer(const char* s, std::size_t n)
+#else
+    inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
+#endif
+{
+    return nlohmann::json::json_pointer(std::string(s, n));
+}
+
+}  // namespace json_literals
+}  // namespace literals
+NLOHMANN_JSON_NAMESPACE_END
+
+///////////////////////
+// nonmember support //
+///////////////////////
+
+namespace std // NOLINT(cert-dcl58-cpp)
+{
+
+/// @brief hash value for JSON objects
+/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp)
+{
+    std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
+    {
+        return nlohmann::detail::hash(j);
+    }
+};
+
+// specialization for std::less<value_t>
+template<>
+struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
+{
+    /*!
+    @brief compare two value_t enum values
+    @since version 3.0.0
+    */
+    bool operator()(::nlohmann::detail::value_t lhs,
+                    ::nlohmann::detail::value_t rhs) const noexcept
+    {
+#if JSON_HAS_THREE_WAY_COMPARISON
+        return std::is_lt(lhs <=> rhs); // *NOPAD*
+#else
+        return ::nlohmann::detail::operator<(lhs, rhs);
+#endif
+    }
+};
+
+// C++20 prohibit function specialization in the std namespace.
+#ifndef JSON_HAS_CPP_20
+
+/// @brief exchanges the values of two JSON objects
+/// @sa https://json.nlohmann.me/api/basic_json/std_swap/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp)
+    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
+{
+    j1.swap(j2);
+}
+
+#endif
+
+}  // namespace std
+
+#if JSON_USE_GLOBAL_UDLS
+    #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+        using nlohmann::literals::json_literals::operator ""_json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator ""_json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #else
+        using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #endif
+#endif
+
+// #include <nlohmann/detail/macro_unscope.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// restore clang diagnostic settings
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+// clean up
+#undef JSON_ASSERT
+#undef JSON_INTERNAL_CATCH
+#undef JSON_THROW
+#undef JSON_PRIVATE_UNLESS_TESTED
+#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
+#undef NLOHMANN_BASIC_JSON_TPL
+#undef JSON_EXPLICIT
+#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
+#undef JSON_INLINE_VARIABLE
+#undef JSON_NO_UNIQUE_ADDRESS
+#undef JSON_DISABLE_ENUM_SERIALIZATION
+#undef JSON_USE_GLOBAL_UDLS
+
+#ifndef JSON_TEST_KEEP_MACROS
+    #undef JSON_CATCH
+    #undef JSON_TRY
+    #undef JSON_HAS_CPP_11
+    #undef JSON_HAS_CPP_14
+    #undef JSON_HAS_CPP_17
+    #undef JSON_HAS_CPP_20
+    #undef JSON_HAS_FILESYSTEM
+    #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+    #undef JSON_HAS_THREE_WAY_COMPARISON
+    #undef JSON_HAS_RANGES
+    #undef JSON_HAS_STATIC_RTTI
+    #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+#endif
+
+// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#undef JSON_HEDLEY_ALWAYS_INLINE
+#undef JSON_HEDLEY_ARM_VERSION
+#undef JSON_HEDLEY_ARM_VERSION_CHECK
+#undef JSON_HEDLEY_ARRAY_PARAM
+#undef JSON_HEDLEY_ASSUME
+#undef JSON_HEDLEY_BEGIN_C_DECLS
+#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#undef JSON_HEDLEY_CLANG_HAS_WARNING
+#undef JSON_HEDLEY_COMPCERT_VERSION
+#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#undef JSON_HEDLEY_CONCAT
+#undef JSON_HEDLEY_CONCAT3
+#undef JSON_HEDLEY_CONCAT3_EX
+#undef JSON_HEDLEY_CONCAT_EX
+#undef JSON_HEDLEY_CONST
+#undef JSON_HEDLEY_CONSTEXPR
+#undef JSON_HEDLEY_CONST_CAST
+#undef JSON_HEDLEY_CPP_CAST
+#undef JSON_HEDLEY_CRAY_VERSION
+#undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#undef JSON_HEDLEY_C_DECL
+#undef JSON_HEDLEY_DEPRECATED
+#undef JSON_HEDLEY_DEPRECATED_FOR
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#undef JSON_HEDLEY_DIAGNOSTIC_POP
+#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#undef JSON_HEDLEY_DMC_VERSION
+#undef JSON_HEDLEY_DMC_VERSION_CHECK
+#undef JSON_HEDLEY_EMPTY_BASES
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#undef JSON_HEDLEY_END_C_DECLS
+#undef JSON_HEDLEY_FLAGS
+#undef JSON_HEDLEY_FLAGS_CAST
+#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#undef JSON_HEDLEY_GCC_HAS_FEATURE
+#undef JSON_HEDLEY_GCC_HAS_WARNING
+#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#undef JSON_HEDLEY_GCC_VERSION
+#undef JSON_HEDLEY_GCC_VERSION_CHECK
+#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#undef JSON_HEDLEY_GNUC_HAS_WARNING
+#undef JSON_HEDLEY_GNUC_VERSION
+#undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#undef JSON_HEDLEY_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_BUILTIN
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_EXTENSION
+#undef JSON_HEDLEY_HAS_FEATURE
+#undef JSON_HEDLEY_HAS_WARNING
+#undef JSON_HEDLEY_IAR_VERSION
+#undef JSON_HEDLEY_IAR_VERSION_CHECK
+#undef JSON_HEDLEY_IBM_VERSION
+#undef JSON_HEDLEY_IBM_VERSION_CHECK
+#undef JSON_HEDLEY_IMPORT
+#undef JSON_HEDLEY_INLINE
+#undef JSON_HEDLEY_INTEL_CL_VERSION
+#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#undef JSON_HEDLEY_INTEL_VERSION
+#undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#undef JSON_HEDLEY_IS_CONSTANT
+#undef JSON_HEDLEY_IS_CONSTEXPR_
+#undef JSON_HEDLEY_LIKELY
+#undef JSON_HEDLEY_MALLOC
+#undef JSON_HEDLEY_MCST_LCC_VERSION
+#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
+#undef JSON_HEDLEY_MESSAGE
+#undef JSON_HEDLEY_MSVC_VERSION
+#undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#undef JSON_HEDLEY_NEVER_INLINE
+#undef JSON_HEDLEY_NON_NULL
+#undef JSON_HEDLEY_NO_ESCAPE
+#undef JSON_HEDLEY_NO_RETURN
+#undef JSON_HEDLEY_NO_THROW
+#undef JSON_HEDLEY_NULL
+#undef JSON_HEDLEY_PELLES_VERSION
+#undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#undef JSON_HEDLEY_PGI_VERSION
+#undef JSON_HEDLEY_PGI_VERSION_CHECK
+#undef JSON_HEDLEY_PREDICT
+#undef JSON_HEDLEY_PRINTF_FORMAT
+#undef JSON_HEDLEY_PRIVATE
+#undef JSON_HEDLEY_PUBLIC
+#undef JSON_HEDLEY_PURE
+#undef JSON_HEDLEY_REINTERPRET_CAST
+#undef JSON_HEDLEY_REQUIRE
+#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#undef JSON_HEDLEY_REQUIRE_MSG
+#undef JSON_HEDLEY_RESTRICT
+#undef JSON_HEDLEY_RETURNS_NON_NULL
+#undef JSON_HEDLEY_SENTINEL
+#undef JSON_HEDLEY_STATIC_ASSERT
+#undef JSON_HEDLEY_STATIC_CAST
+#undef JSON_HEDLEY_STRINGIFY
+#undef JSON_HEDLEY_STRINGIFY_EX
+#undef JSON_HEDLEY_SUNPRO_VERSION
+#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#undef JSON_HEDLEY_TINYC_VERSION
+#undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#undef JSON_HEDLEY_TI_ARMCL_VERSION
+#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL2000_VERSION
+#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL430_VERSION
+#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL6X_VERSION
+#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL7X_VERSION
+#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CLPRU_VERSION
+#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#undef JSON_HEDLEY_TI_VERSION
+#undef JSON_HEDLEY_TI_VERSION_CHECK
+#undef JSON_HEDLEY_UNAVAILABLE
+#undef JSON_HEDLEY_UNLIKELY
+#undef JSON_HEDLEY_UNPREDICTABLE
+#undef JSON_HEDLEY_UNREACHABLE
+#undef JSON_HEDLEY_UNREACHABLE_RETURN
+#undef JSON_HEDLEY_VERSION
+#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#undef JSON_HEDLEY_VERSION_ENCODE
+#undef JSON_HEDLEY_WARNING
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#undef JSON_HEDLEY_FALL_THROUGH
+
+
+
+#endif  // INCLUDE_NLOHMANN_JSON_HPP_
diff --git a/dynadjust/include/thread/dnathreading.hpp b/dynadjust/include/thread/dnathreading.hpp
index 4db9a1d7a..30bde8ff2 100644
--- a/dynadjust/include/thread/dnathreading.hpp
+++ b/dynadjust/include/thread/dnathreading.hpp
@@ -373,8 +373,7 @@ class message_bank
 		std::lock_guard<std::mutex> lock(message_mutex);
 		if (i >= messages.size())
 		{
-			T msg(0);
-			return msg;
+			return T{};
 		}
 		return messages.at(i);
 	}
diff --git a/resources/make_dynadjust_gcc.sh b/resources/make_dynadjust_gcc.sh
index 99a9ba35a..ada1e8a40 100755
--- a/resources/make_dynadjust_gcc.sh
+++ b/resources/make_dynadjust_gcc.sh
@@ -139,10 +139,10 @@ fi
 # opt installation folder
 OPT_DYNADJUST_PATH=/opt/dynadjust
 OPT_DYNADJUST_GCC_PATH=/opt/dynadjust/gcc
-DYNADJUST_INSTALL_PATH=/opt/dynadjust/gcc/1_3_0
+DYNADJUST_INSTALL_PATH=/opt/dynadjust/gcc/1_4_0
 
 # version info
-_version="1.3.0"
+_version="1.4.0"
 
 echo -e "\n==========================================================================="
 echo -e "DynAdjust $_version build configuration options..."
diff --git a/resources/xml2jsonl.py b/resources/xml2jsonl.py
new file mode 100755
index 000000000..df9c58710
--- /dev/null
+++ b/resources/xml2jsonl.py
@@ -0,0 +1,370 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# dependencies = []
+# ///
+"""Convert DynaML XML station and measurement files to JSONL format.
+
+Usage:
+    xml2jsonl.py input.xml [input2.xml ...] [-o output.jsonl]
+    xml2jsonl.py stations.xml measurements.xml  # auto-names .jsonl
+
+If -o is not given, output is written to input.jsonl (replacing .xml).
+"""
+import argparse
+import json
+import sys
+import xml.etree.ElementTree as ET
+
+
+def text(elem, tag, default=""):
+    """Get text content of a child element."""
+    child = elem.find(tag)
+    if child is None:
+        return default
+    return child.text if child.text else default
+
+
+def num(s):
+    """Convert a string to a JSON number if possible, else return as string.
+
+    Preserves exact decimal representation by using float for values that
+    round-trip losslessly, otherwise keeps the original string.
+    """
+    if not s:
+        return s
+    try:
+        f = float(s)
+        # Verify round-trip: float -> str -> float matches
+        if f == float(repr(f)):
+            return f
+        return s
+    except (ValueError, OverflowError):
+        return s
+
+
+def numtext(elem, tag, default=""):
+    """Get text of a child element and convert to number if possible."""
+    v = text(elem, tag, default)
+    return num(v)
+
+
+# Measurement types that use Second station
+TYPES_WITH_SECOND = set("ABKCEMSDGLVZX")
+# Measurement types that use Third station
+TYPES_WITH_THIRD = set("A")
+# Measurement types that use Value/StdDev
+TYPES_WITH_VALUE = set("ABKCEMDHLVZRIJPQS")
+# Measurement types that use InstHeight/TargHeight
+TYPES_WITH_HEIGHTS = set("SVZ")
+
+
+def convert_station_file(xmlpath, jsonlpath):
+    """Convert a DynaML station XML file to JSONL."""
+    tree = ET.parse(xmlpath)
+    root = tree.getroot()
+    count = 0
+
+    with open(jsonlpath, "w") as f:
+        # Header
+        hdr = {
+            "DnaXmlFormat": {
+                "type": root.get("type", ""),
+                "referenceframe": root.get("referenceframe", ""),
+                "epoch": root.get("epoch", ""),
+            }
+        }
+        f.write(json.dumps(hdr, separators=(",", ":")) + "\n")
+
+        for stn_elem in root.findall("DnaStation"):
+            coord_elem = stn_elem.find("StationCoord")
+            coord = {}
+            if coord_elem is not None:
+                coord = {
+                    "Name": text(coord_elem, "Name"),
+                    "XAxis": numtext(coord_elem, "XAxis"),
+                    "YAxis": numtext(coord_elem, "YAxis"),
+                    "Height": numtext(coord_elem, "Height"),
+                }
+                hz = text(coord_elem, "HemisphereZone")
+                if hz:
+                    coord["HemisphereZone"] = hz
+
+            stn = {
+                "Name": text(stn_elem, "Name"),
+                "Constraints": text(stn_elem, "Constraints"),
+                "Type": text(stn_elem, "Type"),
+                "StationCoord": coord,
+                "Description": text(stn_elem, "Description"),
+            }
+            f.write(json.dumps({"DnaStation": stn}, separators=(",", ":")) + "\n")
+            count += 1
+
+    return count
+
+
+def parse_covariance(cov_elem):
+    """Parse a GPSCovariance or PointCovariance element."""
+    return {
+        "m11": numtext(cov_elem, "m11"),
+        "m12": numtext(cov_elem, "m12"),
+        "m13": numtext(cov_elem, "m13"),
+        "m21": numtext(cov_elem, "m21"),
+        "m22": numtext(cov_elem, "m22"),
+        "m23": numtext(cov_elem, "m23"),
+        "m31": numtext(cov_elem, "m31"),
+        "m32": numtext(cov_elem, "m32"),
+        "m33": numtext(cov_elem, "m33"),
+    }
+
+
+def parse_baseline_elem(child):
+    """Parse a GPSBaseline XML element into a dict."""
+    bsl = {
+        "X": numtext(child, "X"),
+        "Y": numtext(child, "Y"),
+        "Z": numtext(child, "Z"),
+        "SigmaXX": numtext(child, "SigmaXX"),
+        "SigmaXY": numtext(child, "SigmaXY"),
+        "SigmaXZ": numtext(child, "SigmaXZ"),
+        "SigmaYY": numtext(child, "SigmaYY"),
+        "SigmaYZ": numtext(child, "SigmaYZ"),
+        "SigmaZZ": numtext(child, "SigmaZZ"),
+    }
+    msr_id = text(child, "MeasurementID")
+    if msr_id:
+        bsl["MeasurementID"] = int(msr_id)
+    covs = [parse_covariance(c) for c in child.findall("GPSCovariance")]
+    if covs:
+        bsl["GPSCovariance"] = covs
+    return bsl
+
+
+def parse_clusterpoint_elem(child):
+    """Parse a Clusterpoint XML element into a dict."""
+    pt = {
+        "X": numtext(child, "X"),
+        "Y": numtext(child, "Y"),
+        "Z": numtext(child, "Z"),
+        "SigmaXX": numtext(child, "SigmaXX"),
+        "SigmaXY": numtext(child, "SigmaXY"),
+        "SigmaXZ": numtext(child, "SigmaXZ"),
+        "SigmaYY": numtext(child, "SigmaYY"),
+        "SigmaYZ": numtext(child, "SigmaYZ"),
+        "SigmaZZ": numtext(child, "SigmaZZ"),
+    }
+    msr_id = text(child, "MeasurementID")
+    if msr_id:
+        pt["MeasurementID"] = int(msr_id)
+    covs = [parse_covariance(c) for c in child.findall("PointCovariance")]
+    if covs:
+        pt["PointCovariance"] = covs
+    return pt
+
+
+def convert_measurement_file(xmlpath, jsonlpath):
+    """Convert a DynaML measurement XML file to JSONL."""
+    tree = ET.parse(xmlpath)
+    root = tree.getroot()
+    count = 0
+
+    with open(jsonlpath, "w") as f:
+        # Header
+        hdr = {
+            "DnaXmlFormat": {
+                "type": root.get("type", ""),
+                "referenceframe": root.get("referenceframe", ""),
+                "epoch": root.get("epoch", ""),
+            }
+        }
+        f.write(json.dumps(hdr, separators=(",", ":")) + "\n")
+
+        for msr_elem in root.findall("DnaMeasurement"):
+            msr_type = text(msr_elem, "Type")
+            m = {"Type": msr_type}
+
+            # Source
+            source = text(msr_elem, "Source")
+            m["Source"] = source
+
+            # Ignore
+            m["Ignore"] = text(msr_elem, "Ignore")
+
+            # Epoch (all types may have it)
+            epoch = text(msr_elem, "Epoch")
+            if epoch:
+                m["Epoch"] = epoch
+
+            obs_epoch = text(msr_elem, "EpochOfObservation")
+            if obs_epoch:
+                m["EpochOfObservation"] = obs_epoch
+
+            # ReferenceFrame (GPS types)
+            if msr_type in ("G", "X", "Y"):
+                m["ReferenceFrame"] = text(msr_elem, "ReferenceFrame")
+
+            # MeasurementID and ClusterID (all types may have them)
+            msr_id = text(msr_elem, "MeasurementID")
+            if msr_id:
+                m["MeasurementID"] = int(msr_id)
+            cluster_dbid = text(msr_elem, "ClusterID")
+            if cluster_dbid:
+                m["ClusterID"] = int(cluster_dbid)
+
+            if msr_type in ("G", "X", "Y"):
+                m["Vscale"] = numtext(msr_elem, "Vscale")
+                m["Pscale"] = numtext(msr_elem, "Pscale")
+                m["Lscale"] = numtext(msr_elem, "Lscale")
+                m["Hscale"] = numtext(msr_elem, "Hscale")
+
+            if msr_type == "G":
+                # G type: single baseline, First/Second at measurement level
+                m["First"] = text(msr_elem, "First")
+                m["Second"] = text(msr_elem, "Second")
+                bsl_elem = msr_elem.find("GPSBaseline")
+                if bsl_elem is not None:
+                    m["GPSBaseline"] = [parse_baseline_elem(bsl_elem)]
+
+            elif msr_type == "X":
+                # X type: multiple baselines, First/Second per baseline
+                m["Total"] = int(text(msr_elem, "Total"))
+                baselines = []
+                cur_first = cur_second = ""
+                for child in msr_elem:
+                    if child.tag == "First":
+                        cur_first = child.text or ""
+                        if "First" not in m:
+                            m["First"] = cur_first
+                    elif child.tag == "Second":
+                        cur_second = child.text or ""
+                        if "Second" not in m:
+                            m["Second"] = cur_second
+                    elif child.tag == "GPSBaseline":
+                        bsl = parse_baseline_elem(child)
+                        bsl["First"] = cur_first
+                        bsl["Second"] = cur_second
+                        baselines.append(bsl)
+                m["GPSBaseline"] = baselines
+
+            elif msr_type == "Y":
+                # Y type: clusterpoints with per-point First
+                m["Coords"] = text(msr_elem, "Coords")
+                m["Total"] = int(text(msr_elem, "Total"))
+                points = []
+                cur_first = ""
+                for child in msr_elem:
+                    if child.tag == "First":
+                        cur_first = child.text or ""
+                        if "First" not in m:
+                            m["First"] = cur_first
+                    elif child.tag == "Clusterpoint":
+                        pt = parse_clusterpoint_elem(child)
+                        pt["First"] = cur_first
+                        points.append(pt)
+                m["Clusterpoint"] = points
+
+            elif msr_type == "D":
+                # D type: direction set
+                m["First"] = text(msr_elem, "First")
+                second = text(msr_elem, "Second")
+                if second:
+                    m["Second"] = second
+                m["Value"] = numtext(msr_elem, "Value")
+                m["StdDev"] = numtext(msr_elem, "StdDev")
+                m["Total"] = int(text(msr_elem, "Total"))
+
+                directions = []
+                for dir_elem in msr_elem.findall("Directions"):
+                    d = {
+                        "Ignore": text(dir_elem, "Ignore"),
+                        "Target": text(dir_elem, "Target"),
+                        "Value": numtext(dir_elem, "Value"),
+                        "StdDev": numtext(dir_elem, "StdDev"),
+                    }
+                    directions.append(d)
+                m["Directions"] = directions
+
+            else:
+                # Scalar types: A, B, C, E, H, I, J, K, L, M, P, Q, R, S, V, Z
+                m["First"] = text(msr_elem, "First")
+                if msr_type in TYPES_WITH_SECOND:
+                    m["Second"] = text(msr_elem, "Second")
+                if msr_type in TYPES_WITH_THIRD:
+                    m["Third"] = text(msr_elem, "Third")
+                if msr_type in TYPES_WITH_VALUE:
+                    m["Value"] = numtext(msr_elem, "Value")
+                    m["StdDev"] = numtext(msr_elem, "StdDev")
+                if msr_type in TYPES_WITH_HEIGHTS:
+                    ih = numtext(msr_elem, "InstHeight")
+                    if ih:
+                        m["InstHeight"] = ih
+                    th = numtext(msr_elem, "TargHeight")
+                    if th:
+                        m["TargHeight"] = th
+
+            f.write(
+                json.dumps({"DnaMeasurement": m}, separators=(",", ":")) + "\n"
+            )
+            count += 1
+
+    return count
+
+
+def detect_file_type(xmlpath):
+    """Detect whether an XML file is a station or measurement file."""
+    tree = ET.parse(xmlpath)
+    root = tree.getroot()
+    file_type = root.get("type", "").lower()
+
+    if "station" in file_type:
+        return "station"
+    if "measurement" in file_type:
+        return "measurement"
+
+    # Fall back to content detection
+    if root.find("DnaStation") is not None:
+        return "station"
+    if root.find("DnaMeasurement") is not None:
+        return "measurement"
+
+    return "unknown"
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Convert DynaML XML files to JSONL format."
+    )
+    parser.add_argument("input", nargs="+", help="Input XML file(s)")
+    parser.add_argument(
+        "-o",
+        "--output",
+        help="Output JSONL file (only valid with single input)",
+    )
+    args = parser.parse_args()
+
+    if args.output and len(args.input) > 1:
+        print("Error: -o can only be used with a single input file.", file=sys.stderr)
+        sys.exit(1)
+
+    for xmlpath in args.input:
+        if args.output:
+            jsonlpath = args.output
+        elif xmlpath.endswith(".xml"):
+            jsonlpath = xmlpath[:-4] + ".jsonl"
+        else:
+            jsonlpath = xmlpath + ".jsonl"
+
+        file_type = detect_file_type(xmlpath)
+
+        if file_type == "station":
+            count = convert_station_file(xmlpath, jsonlpath)
+            print(f"{jsonlpath}: {count} stations")
+        elif file_type == "measurement":
+            count = convert_measurement_file(xmlpath, jsonlpath)
+            print(f"{jsonlpath}: {count} measurements")
+        else:
+            print(f"Error: Cannot determine type of {xmlpath}", file=sys.stderr)
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/sampleData/DynaML.xsd b/sampleData/DynaML.xsd
index 33d4d66c6..58dd535c3 100644
--- a/sampleData/DynaML.xsd
+++ b/sampleData/DynaML.xsd
@@ -43,6 +43,7 @@
 				<xs:element ref="Ignore" minOccurs="0"/>
 				<xs:element ref="ReferenceFrame" minOccurs="0"/>
 				<xs:element ref="Epoch" minOccurs="0"/>
+				<xs:element ref="EpochOfObservation" minOccurs="0"/>
 				<xs:element ref="First"/>
 				<xs:element ref="Second"/>
 				<xs:element ref="Third"/>
@@ -194,6 +195,7 @@
 	<xs:element name="Source" type="xs:string"/>
 	<xs:element name="ReferenceFrame" type="xs:string"/>
 	<xs:element name="Epoch" type="xs:string"/>
+	<xs:element name="EpochOfObservation" type="xs:string"/>
 	<xs:element name="MeasurementID" type="xs:string"/>
 	<xs:element name="ClusterID" type="xs:string"/>
 </xs:schema>
diff --git a/sampleData/gnss-networkmsr.jsonl b/sampleData/gnss-networkmsr.jsonl
new file mode 100644
index 000000000..bd6710c27
--- /dev/null
+++ b/sampleData/gnss-networkmsr.jsonl
@@ -0,0 +1,132 @@
+{"DnaXmlFormat":{"type":"Measurement File","referenceframe":"GDA2020","epoch":"01.01.2020"}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900360","Second":"BEEC","GPSBaseline":[{"X":-8628.718,"Y":12647.1455,"Z":18788.9482,"SigmaXX":1.7012598619e-05,"SigmaXY":-1.0467927495e-05,"SigmaXZ":1.4195195035e-05,"SigmaYY":9.433588275e-06,"SigmaYZ":-1.0196034054e-05,"SigmaZZ":1.4284143617e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":100.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900360","Second":"MYRT","GPSBaseline":[{"X":-1.8961,"Y":63.2445,"Z":36.3205,"SigmaXX":4.0651889321e-07,"SigmaXY":-1.6381380874e-07,"SigmaXZ":2.113690698e-07,"SigmaYY":3.8172527184e-07,"SigmaYZ":-2.100093468e-07,"SigmaZZ":3.2840807762e-07}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900360","Second":"BNLA","GPSBaseline":[{"X":34769.4176,"Y":53952.7536,"Z":1317.7921,"SigmaXX":1.3081703401e-05,"SigmaXY":-7.4526451499e-06,"SigmaXZ":1.0981510059e-05,"SigmaYY":7.428857316e-06,"SigmaYZ":-7.413743333e-06,"SigmaZZ":1.1094109141e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900360","Second":"HOTH","GPSBaseline":[{"X":2127.5479,"Y":-46036.7569,"Z":-38596.2103,"SigmaXX":1.3417868104e-05,"SigmaXY":-9.1385281848e-06,"SigmaXZ":1.1773546248e-05,"SigmaYY":8.6507207016e-06,"SigmaYZ":-8.8916431196e-06,"SigmaZZ":1.2962176697e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BEEC","Second":"356000780","GPSBaseline":[{"X":13080.4424,"Y":14099.1619,"Z":-3810.0618,"SigmaXX":1.959324436e-05,"SigmaXY":-1.4739506696e-05,"SigmaXZ":1.655957567e-05,"SigmaYY":1.5756797438e-05,"SigmaYZ":-1.366264587e-05,"SigmaZZ":1.6312815205e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BEEC","Second":"261000380","GPSBaseline":[{"X":10618.7508,"Y":5371.1229,"Z":-7604.5285,"SigmaXX":1.5254352547e-05,"SigmaXY":-9.6582443803e-06,"SigmaXZ":1.2731454262e-05,"SigmaYY":8.5833844423e-06,"SigmaYZ":-8.8018032329e-06,"SigmaZZ":1.2554354726e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BEEC","Second":"222702940","GPSBaseline":[{"X":4564.7753,"Y":-41051.4683,"Z":-35302.9747,"SigmaXX":1.7608042981e-05,"SigmaXY":-1.1397175513e-05,"SigmaXZ":1.5357714801e-05,"SigmaYY":1.0014583495e-05,"SigmaYZ":-1.0562840544e-05,"SigmaZZ":1.6415548089e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"356000780","GPSBaseline":[{"X":4453.6049,"Y":26683.0774,"Z":14942.5487,"SigmaXX":1.7441385353e-05,"SigmaXY":-1.3219617358e-05,"SigmaXZ":1.4734629985e-05,"SigmaYY":1.4200943042e-05,"SigmaYZ":-1.2220738427e-05,"SigmaZZ":1.4477298464e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"261000380","GPSBaseline":[{"X":1991.9214,"Y":17955.0328,"Z":11148.088,"SigmaXX":1.1933630958e-05,"SigmaXY":-7.4710842455e-06,"SigmaXZ":9.9291319202e-06,"SigmaYY":6.6765342126e-06,"SigmaYZ":-6.8071735768e-06,"SigmaZZ":9.8342052297e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"222702940","GPSBaseline":[{"X":-4062.0619,"Y":-28467.5578,"Z":-16550.3638,"SigmaXX":1.381106631e-05,"SigmaXY":-8.68376992e-06,"SigmaXZ":1.163817069e-05,"SigmaYY":7.1546664913e-06,"SigmaYZ":-7.8683606262e-06,"SigmaZZ":1.1374075257e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"356000780","GPSBaseline":[{"X":-30317.7047,"Y":-27206.4389,"Z":13661.0848,"SigmaXX":1.6215779397e-05,"SigmaXY":-1.1689723578e-05,"SigmaXZ":1.3763876268e-05,"SigmaYY":1.2433503798e-05,"SigmaYZ":-1.082855124e-05,"SigmaZZ":1.3475050764e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":25.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"261000380","GPSBaseline":[{"X":-32779.3771,"Y":-35934.4908,"Z":9866.6349,"SigmaXX":1.1618014469e-05,"SigmaXY":-7.4718282121e-06,"SigmaXZ":1.0108157767e-05,"SigmaYY":6.4394625952e-06,"SigmaYZ":-7.3019209594e-06,"SigmaZZ":1.0311842743e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"HOTH","Second":"222702940","GPSBaseline":[{"X":-6191.4918,"Y":17632.4484,"Z":22082.1833,"SigmaXX":1.4340297639e-05,"SigmaXY":-9.0113198894e-06,"SigmaXZ":1.2067101125e-05,"SigmaYY":7.4430204222e-06,"SigmaYZ":-8.1624748418e-06,"SigmaZZ":1.1800298125e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"356000780","Second":"261000380","GPSBaseline":[{"X":-2461.6826,"Y":-8728.0419,"Z":-3794.4607,"SigmaXX":2.8794564059e-05,"SigmaXY":-2.0999126718e-05,"SigmaXZ":2.4361937903e-05,"SigmaYY":2.2534986783e-05,"SigmaYZ":-1.9646071451e-05,"SigmaZZ":2.4153398044e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"356000780","Second":"324900360","GPSBaseline":[{"X":-4451.7262,"Y":-26746.3102,"Z":-14978.8827,"SigmaXX":3.786344314e-05,"SigmaXY":-2.1661027858e-05,"SigmaXZ":3.019264841e-05,"SigmaYY":3.6131012166e-05,"SigmaYZ":-2.7531119486e-05,"SigmaZZ":3.2944655686e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"356000780","Second":"222702940","GPSBaseline":[{"X":-8515.6657,"Y":-55150.6293,"Z":-31492.9205,"SigmaXX":4.623741188e-05,"SigmaXY":-3.2861626096e-05,"SigmaXZ":4.0217269998e-05,"SigmaYY":3.8551115722e-05,"SigmaYZ":-2.7847128877e-05,"SigmaZZ":3.9899703552e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"261000380","Second":"324900360","GPSBaseline":[{"X":-1990.036,"Y":-18018.2704,"Z":-11184.4202,"SigmaXX":1.7772135834e-05,"SigmaXY":-1.0300082067e-05,"SigmaXZ":1.4709563402e-05,"SigmaYY":9.5001287264e-06,"SigmaYZ":-1.0154942174e-05,"SigmaZZ":1.4877182366e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"261000380","Second":"222702940","GPSBaseline":[{"X":-6053.9797,"Y":-46422.5899,"Z":-27698.4494,"SigmaXX":2.3077447622e-05,"SigmaXY":-1.3168264559e-05,"SigmaXZ":2.0839030185e-05,"SigmaYY":1.0908092008e-05,"SigmaYZ":-1.2313749721e-05,"SigmaZZ":2.2091267965e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900360","Second":"222702940","GPSBaseline":[{"X":-4063.9526,"Y":-28404.3154,"Z":-16514.034,"SigmaXX":1.955069456e-05,"SigmaXY":-1.2115606296e-05,"SigmaXZ":1.6592410248e-05,"SigmaYY":1.046305897e-05,"SigmaYZ":-1.1723958778e-05,"SigmaZZ":1.6825002604e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"222702010","Second":"MYRT","GPSBaseline":[{"X":3802.5786,"Y":24340.573,"Z":14331.0519,"SigmaXX":2.631825555e-05,"SigmaXY":-1.6486612367e-05,"SigmaXZ":2.3368267648e-05,"SigmaYY":1.3261505046e-05,"SigmaYZ":-1.497678204e-05,"SigmaZZ":2.3191500077e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"222702010","Second":"HOTH","GPSBaseline":[{"X":5932.0373,"Y":-21759.446,"Z":-24301.4768,"SigmaXX":2.3643355235e-05,"SigmaXY":-1.4436021956e-05,"SigmaXZ":2.1208186809e-05,"SigmaYY":1.1524773072e-05,"SigmaYZ":-1.3234757716e-05,"SigmaZZ":2.1275487597e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":2.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"222702010","Second":"222701160","GPSBaseline":[{"X":1133.0352,"Y":-265.7103,"Z":-918.5983,"SigmaXX":1.5972047549e-05,"SigmaXY":-1.0449504771e-05,"SigmaXZ":9.5474615591e-06,"SigmaYY":1.0023561117e-05,"SigmaYZ":-7.1951699283e-06,"SigmaZZ":8.6726076916e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"222702010","Second":"222702320","GPSBaseline":[{"X":1341.851,"Y":-1728.4494,"Z":-2269.0233,"SigmaXX":0.00017032439064,"SigmaXY":-0.00010827392543,"SigmaXZ":0.00015073745453,"SigmaYY":8.2457394456e-05,"SigmaYZ":-0.00010254172958,"SigmaZZ":0.00014807633124}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":5.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"222702010","Second":"222702940","GPSBaseline":[{"X":-259.4798,"Y":-4126.9688,"Z":-2219.317,"SigmaXX":6.4288702561e-05,"SigmaXY":-4.421587073e-05,"SigmaXZ":5.1152939704e-05,"SigmaYY":4.54693145e-05,"SigmaYZ":-3.7555833842e-05,"SigmaZZ":5.5575688748e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"222702010","Second":"341301360","GPSBaseline":[{"X":2193.4175,"Y":1527.8925,"Z":-807.0124,"SigmaXX":0.0001047541009,"SigmaXY":-6.1505314079e-05,"SigmaXZ":9.9565178971e-05,"SigmaYY":4.3989221012e-05,"SigmaYZ":-5.7199467847e-05,"SigmaZZ":0.00011026002903}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"222702010","Second":"341301380","GPSBaseline":[{"X":2323.241,"Y":1540.2615,"Z":-971.4684,"SigmaXX":0.00012232632434,"SigmaXY":-7.0960413723e-05,"SigmaXZ":0.00011644773622,"SigmaYY":5.3383100749e-05,"SigmaYZ":-6.4156876761e-05,"SigmaZZ":0.00012839761621}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"222701160","GPSBaseline":[{"X":-2669.5358,"Y":-24606.2966,"Z":-15249.6506,"SigmaXX":8.5299034254e-05,"SigmaXY":-5.5988988606e-05,"SigmaXZ":7.1946386015e-05,"SigmaYY":4.0773051296e-05,"SigmaYZ":-4.8106070608e-05,"SigmaZZ":6.5583764808e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"222702320","GPSBaseline":[{"X":-2460.7245,"Y":-26069.0299,"Z":-16600.0759,"SigmaXX":0.00014388846466,"SigmaXY":-9.1402289399e-05,"SigmaXZ":0.0001258757693,"SigmaYY":6.9737019658e-05,"SigmaYZ":-8.592933591e-05,"SigmaZZ":0.00012198292825}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"HOTH","Second":"222701160","GPSBaseline":[{"X":-4798.9887,"Y":21493.7184,"Z":23382.8829,"SigmaXX":8.0282770796e-05,"SigmaXY":-5.2922059695e-05,"SigmaXZ":6.7746659624e-05,"SigmaYY":3.8723741454e-05,"SigmaYZ":-4.5515891543e-05,"SigmaZZ":6.1889411882e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"HOTH","Second":"222702320","GPSBaseline":[{"X":-4590.1696,"Y":20030.9815,"Z":22032.464,"SigmaXX":0.00015086930944,"SigmaXY":-9.6216841484e-05,"SigmaXZ":0.00013426475925,"SigmaYY":7.3091578088e-05,"SigmaYZ":-9.1864603746e-05,"SigmaZZ":0.00013187728473}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"222701160","Second":"222702320","GPSBaseline":[{"X":208.8135,"Y":-1462.7421,"Z":-1350.4225,"SigmaXX":0.0001787035726,"SigmaXY":-0.00012217018229,"SigmaXZ":0.00015706324484,"SigmaYY":9.4437564258e-05,"SigmaYZ":-0.00011150668433,"SigmaZZ":0.00014773129078}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"222701160","Second":"222702940","GPSBaseline":[{"X":-1392.5342,"Y":-3861.2379,"Z":-1300.7399,"SigmaXX":3.9196271246e-05,"SigmaXY":-2.1503741664e-05,"SigmaXZ":2.9425369576e-05,"SigmaYY":2.7547317586e-05,"SigmaYZ":-1.0662156456e-05,"SigmaZZ":3.9304526581e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"222702320","Second":"222702940","GPSBaseline":[{"X":-1601.3126,"Y":-2398.5143,"Z":49.7152,"SigmaXX":5.3208528698e-05,"SigmaXY":-3.5806322558e-05,"SigmaXZ":4.2072591896e-05,"SigmaYY":4.3847263441e-05,"SigmaYZ":-3.5458644561e-05,"SigmaZZ":4.919611456e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"19.02.2015","ReferenceFrame":"ITRF2008","Vscale":5.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"341301360","Second":"341301380","GPSBaseline":[{"X":129.8149,"Y":12.3865,"Z":-164.4531,"SigmaXX":5.5547288866e-06,"SigmaXY":-6.9213915594e-06,"SigmaXZ":2.1732837467e-06,"SigmaYY":1.040931329e-05,"SigmaYZ":-2.1520258997e-06,"SigmaZZ":2.1283917704e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"324900360","GPSBaseline":[{"X":1.8855,"Y":-63.2484,"Z":-36.3245,"SigmaXX":7.2914099292e-07,"SigmaXY":-2.6945906484e-07,"SigmaXZ":4.0551975644e-07,"SigmaYY":3.0389062999e-07,"SigmaYZ":-2.4226429218e-07,"SigmaZZ":4.7769515277e-07}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"324900930","GPSBaseline":[{"X":-774.6034,"Y":-119.0541,"Z":767.2771,"SigmaXX":1.6534739871e-06,"SigmaXY":-8.5841952568e-07,"SigmaXZ":1.1287739881e-06,"SigmaYY":1.1531153632e-06,"SigmaYZ":-8.3159778796e-07,"SigmaZZ":1.6032748817e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":5.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"324901090","GPSBaseline":[{"X":126.3558,"Y":145.4375,"Z":-20.5772,"SigmaXX":3.1210041925e-05,"SigmaXY":-4.5022909035e-05,"SigmaXZ":1.2450901522e-05,"SigmaYY":9.1906760645e-05,"SigmaYZ":-1.9478718968e-05,"SigmaZZ":1.1892870134e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"324901240","GPSBaseline":[{"X":-409.348,"Y":-1270.4682,"Z":-759.6611,"SigmaXX":6.229587143e-06,"SigmaXY":-5.1285087466e-06,"SigmaXZ":4.8982005865e-06,"SigmaYY":7.4761783253e-06,"SigmaYZ":-4.7052567425e-06,"SigmaZZ":6.9526986408e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":5.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"349800490","GPSBaseline":[{"X":-10402.2499,"Y":-1810.4215,"Z":9012.9251,"SigmaXX":3.0598432204e-05,"SigmaXY":-1.8722947061e-05,"SigmaXZ":2.667220906e-05,"SigmaYY":1.4460739294e-05,"SigmaYZ":-1.7743563149e-05,"SigmaZZ":2.8031077818e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":2.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900360","Second":"324901200","GPSBaseline":[{"X":-385.9026,"Y":-361.7631,"Z":140.6822,"SigmaXX":1.8416008061e-06,"SigmaXY":-8.0146429582e-07,"SigmaXZ":5.5909487173e-07,"SigmaYY":1.2213878335e-06,"SigmaYZ":-8.2375260035e-07,"SigmaZZ":1.4219856439e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900360","Second":"324900930","GPSBaseline":[{"X":-776.4893,"Y":-55.8045,"Z":803.6003,"SigmaXX":3.9255023694e-06,"SigmaXY":-1.6046080873e-06,"SigmaXZ":2.2234971766e-06,"SigmaYY":1.6155040612e-06,"SigmaYZ":-1.2529671949e-06,"SigmaZZ":2.316446853e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":5.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900360","Second":"324901090","GPSBaseline":[{"X":124.4515,"Y":208.7444,"Z":15.7326,"SigmaXX":7.2545532021e-05,"SigmaXY":-0.0001130660894,"SigmaXZ":2.6294366762e-05,"SigmaYY":0.00020717200823,"SigmaYZ":-4.2083996959e-05,"SigmaZZ":1.6295083697e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900360","Second":"324901240","GPSBaseline":[{"X":-411.2355,"Y":-1207.2186,"Z":-723.3433,"SigmaXX":1.6282416254e-05,"SigmaXY":-9.6358253359e-06,"SigmaXZ":1.2089150914e-05,"SigmaYY":8.8644464995e-06,"SigmaYZ":-8.5124993348e-06,"SigmaZZ":1.2961520952e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":2.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900360","Second":"349800490","GPSBaseline":[{"X":-10404.1546,"Y":-1747.1606,"Z":9049.2229,"SigmaXX":4.1810977564e-05,"SigmaXY":-1.8169572286e-05,"SigmaXZ":3.1776122341e-05,"SigmaYY":1.885499114e-05,"SigmaYZ":-2.3708278604e-05,"SigmaZZ":4.7469035053e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":2.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900930","Second":"324901200","GPSBaseline":[{"X":390.5881,"Y":-305.9534,"Z":-662.9198,"SigmaXX":2.4954579203e-06,"SigmaXY":-8.9620652943e-07,"SigmaXZ":8.746009712e-07,"SigmaYY":1.4530726276e-06,"SigmaYZ":-9.1466688446e-07,"SigmaZZ":1.6735605186e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":5.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900930","Second":"324901090","GPSBaseline":[{"X":900.9512,"Y":264.4897,"Z":-787.8461,"SigmaXX":1.8650503989e-05,"SigmaXY":-2.6522746339e-05,"SigmaXZ":1.1704401004e-05,"SigmaYY":9.4070303021e-05,"SigmaYZ":-2.5534594897e-05,"SigmaZZ":1.9908244212e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900930","Second":"324901240","GPSBaseline":[{"X":365.2535,"Y":-1151.4139,"Z":-1526.9424,"SigmaXX":1.3059265257e-05,"SigmaXY":-8.9050736278e-06,"SigmaXZ":1.0457148164e-05,"SigmaYY":9.9694798337e-06,"SigmaYZ":-8.4926932686e-06,"SigmaZZ":1.3073049558e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":2.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324900930","Second":"349800490","GPSBaseline":[{"X":-9627.666,"Y":-1691.3582,"Z":8245.6272,"SigmaXX":3.8660255086e-05,"SigmaXY":-2.161255361e-05,"SigmaXZ":3.8660433347e-05,"SigmaYY":2.3381124265e-05,"SigmaYZ":-3.1559862691e-05,"SigmaZZ":6.3301318733e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":20.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324901090","Second":"324901200","GPSBaseline":[{"X":-510.3575,"Y":-570.4222,"Z":124.9338,"SigmaXX":1.0711760297e-05,"SigmaXY":-6.8099416239e-06,"SigmaXZ":4.6096024562e-06,"SigmaYY":2.1335539714e-05,"SigmaYZ":-2.4519624731e-06,"SigmaZZ":8.6704476416e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":2.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"324901240","Second":"349800490","GPSBaseline":[{"X":-9992.9191,"Y":-539.9542,"Z":9772.5663,"SigmaXX":0.00037672923645,"SigmaXY":-0.00026159599656,"SigmaXZ":0.00040115820593,"SigmaYY":0.00021454929083,"SigmaYZ":-0.00028847489739,"SigmaZZ":0.00046291097533}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"03.03.2016","ReferenceFrame":"ITRF2008","Vscale":2.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"324901200","GPSBaseline":[{"X":-384.016,"Y":-425.009,"Z":104.3552,"SigmaXX":1.0703240605e-06,"SigmaXY":-4.7906593181e-07,"SigmaXZ":5.1375263865e-07,"SigmaYY":8.155229807e-07,"SigmaYZ":-4.8782794693e-07,"SigmaZZ":1.1746957398e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"384300490","GPSBaseline":[{"X":-5610.8942,"Y":-4623.6203,"Z":2802.4759,"SigmaXX":2.9244032703e-05,"SigmaXY":-1.8602986529e-05,"SigmaXZ":2.5655246645e-05,"SigmaYY":1.4788183762e-05,"SigmaYZ":-1.7385409592e-05,"SigmaZZ":2.6588231776e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"384300430","GPSBaseline":[{"X":-3699.2465,"Y":-3091.6296,"Z":1819.6065,"SigmaXX":2.6123148928e-05,"SigmaXY":-1.6760295694e-05,"SigmaXZ":2.3180164135e-05,"SigmaYY":1.3201266484e-05,"SigmaYZ":-1.5796476873e-05,"SigmaZZ":2.3926811991e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"211301630","GPSBaseline":[{"X":48.6448,"Y":668.6189,"Z":464.7776,"SigmaXX":1.4387899228e-06,"SigmaXY":-7.8026249639e-07,"SigmaXZ":9.8951909422e-07,"SigmaYY":9.2437880994e-07,"SigmaYZ":-7.6885606859e-07,"SigmaZZ":1.3709138784e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"211301110","GPSBaseline":[{"X":1016.4233,"Y":790.8468,"Z":-526.7644,"SigmaXX":2.9418708891e-06,"SigmaXY":-1.700404141e-06,"SigmaXZ":1.8853713755e-06,"SigmaYY":2.5872473088e-06,"SigmaYZ":-1.6859054313e-06,"SigmaZZ":3.0759404126e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"211301080","GPSBaseline":[{"X":1673.9193,"Y":1477.4341,"Z":-743.3932,"SigmaXX":2.5223444027e-05,"SigmaXY":-1.4915231077e-05,"SigmaXZ":1.9752102162e-05,"SigmaYY":1.1425009689e-05,"SigmaYZ":-1.2136559235e-05,"SigmaZZ":1.7810107238e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"211301000","GPSBaseline":[{"X":2824.9691,"Y":1700.9764,"Z":-1863.8118,"SigmaXX":2.1699775971e-05,"SigmaXY":-1.3062332073e-05,"SigmaXZ":1.7016693164e-05,"SigmaYY":1.063653599e-05,"SigmaYZ":-1.0502744772e-05,"SigmaZZ":1.5593166609e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"211300470","GPSBaseline":[{"X":3308.4718,"Y":2582.8485,"Z":-1739.7199,"SigmaXX":6.1116086727e-05,"SigmaXY":-3.3943084418e-05,"SigmaXZ":4.941989755e-05,"SigmaYY":2.2509248083e-05,"SigmaYZ":-2.8705433579e-05,"SigmaZZ":4.3671065214e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"211300940","GPSBaseline":[{"X":1690.5432,"Y":2458.1735,"Z":-17.6891,"SigmaXX":3.9153681428e-05,"SigmaXY":-2.2647223886e-05,"SigmaXZ":3.1973220757e-05,"SigmaYY":1.6470292394e-05,"SigmaYZ":-1.9687960958e-05,"SigmaZZ":2.9240443837e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"384300490","Second":"384300430","GPSBaseline":[{"X":1911.6459,"Y":1531.9911,"Z":-982.8706,"SigmaXX":1.7283438865e-05,"SigmaXY":-1.1187868949e-05,"SigmaXZ":1.538172728e-05,"SigmaYY":8.9340228442e-06,"SigmaYZ":-1.0573382497e-05,"SigmaZZ":1.5941046513e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"384300490","Second":"211301630","GPSBaseline":[{"X":5659.543,"Y":5292.2414,"Z":-2337.6957,"SigmaXX":5.3468735132e-05,"SigmaXY":-3.5607288737e-05,"SigmaXZ":4.8560512369e-05,"SigmaYY":2.7823083656e-05,"SigmaYZ":-3.4292279452e-05,"SigmaZZ":4.9885016779e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"384300490","Second":"211301110","GPSBaseline":[{"X":6627.3113,"Y":5414.4745,"Z":-3329.2464,"SigmaXX":6.5071471909e-05,"SigmaXY":-4.1646351747e-05,"SigmaXZ":5.9859383327e-05,"SigmaYY":3.1847084756e-05,"SigmaYZ":-4.1846466047e-05,"SigmaZZ":6.3911844336e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"384300430","Second":"211301630","GPSBaseline":[{"X":3747.8941,"Y":3760.2492,"Z":-1354.8262,"SigmaXX":4.8116562539e-05,"SigmaXY":-3.2104191632e-05,"SigmaXZ":4.2963889427e-05,"SigmaYY":2.4596865842e-05,"SigmaYZ":-3.0201725167e-05,"SigmaZZ":4.2925374146e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"384300430","Second":"211301110","GPSBaseline":[{"X":4715.6636,"Y":3882.4822,"Z":-2346.3762,"SigmaXX":5.4839376389e-05,"SigmaXY":-3.5188182665e-05,"SigmaXZ":5.0249440392e-05,"SigmaYY":2.6994095606e-05,"SigmaYZ":-3.5236804251e-05,"SigmaZZ":5.3537234635e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"211301630","Second":"211301110","GPSBaseline":[{"X":967.7755,"Y":122.2318,"Z":-991.5461,"SigmaXX":4.69649558e-06,"SigmaXY":-2.8248909985e-06,"SigmaXZ":3.4267907267e-06,"SigmaYY":3.7737563616e-06,"SigmaYZ":-3.0552300814e-06,"SigmaZZ":5.2304039855e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":5.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"211301080","Second":"211301000","GPSBaseline":[{"X":1151.0463,"Y":223.5451,"Z":-1120.4216,"SigmaXX":4.8149217946e-06,"SigmaXY":-2.6020186397e-06,"SigmaXZ":2.6511520446e-06,"SigmaYY":3.3027524751e-06,"SigmaYZ":-1.5715129393e-06,"SigmaZZ":2.767442993e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"211301080","Second":"211300470","GPSBaseline":[{"X":1634.5515,"Y":1105.4163,"Z":-996.3311,"SigmaXX":4.7480567446e-05,"SigmaXY":-2.7215666705e-05,"SigmaXZ":3.7609504943e-05,"SigmaYY":2.0161862267e-05,"SigmaYZ":-2.2790398361e-05,"SigmaZZ":3.4082939237e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"211301080","Second":"211300940","GPSBaseline":[{"X":16.629,"Y":980.7361,"Z":725.7057,"SigmaXX":7.339325748e-06,"SigmaXY":-2.9479347177e-06,"SigmaXZ":4.2423134801e-06,"SigmaYY":3.2903865304e-06,"SigmaYZ":-1.8852744006e-06,"SigmaZZ":3.8254270294e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"211301000","Second":"211300470","GPSBaseline":[{"X":483.4951,"Y":881.8738,"Z":124.0858,"SigmaXX":3.8907110138e-06,"SigmaXY":-1.8198999214e-06,"SigmaXZ":2.3147222237e-06,"SigmaYY":2.178780278e-06,"SigmaYZ":-1.2501274114e-06,"SigmaZZ":2.4657772428e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"211301000","Second":"211300940","GPSBaseline":[{"X":-1134.4347,"Y":757.1991,"Z":1846.1145,"SigmaXX":4.5129134378e-05,"SigmaXY":-2.7495296308e-05,"SigmaXZ":3.8220321585e-05,"SigmaYY":2.0490706447e-05,"SigmaYZ":-2.4174389182e-05,"SigmaZZ":3.556257434e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"23.03.2016","ReferenceFrame":"ITRF2008","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"211300470","Second":"211300940","GPSBaseline":[{"X":-1617.9352,"Y":-124.673,"Z":1722.0255,"SigmaXX":7.382343756e-05,"SigmaXY":-4.4535318011e-05,"SigmaXZ":6.0840975493e-05,"SigmaYY":3.1627874705e-05,"SigmaYZ":-3.8167316234e-05,"SigmaZZ":5.4861182434e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"31.01.2017","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"309800190","Second":"EURA","GPSBaseline":[{"X":-5253.9391,"Y":18549.5892,"Z":19993.9218,"SigmaXX":1.6576434064e-05,"SigmaXY":-1.0309747267e-05,"SigmaXZ":1.460776457e-05,"SigmaYY":9.1993342721e-06,"SigmaYZ":-9.0425737653e-06,"SigmaZZ":1.467621496e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"31.01.2017","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"309800190","Second":"MNSF","GPSBaseline":[{"X":-13848.0666,"Y":-30940.7403,"Z":-7816.8495,"SigmaXX":1.5448333215e-05,"SigmaXY":-9.4554306997e-06,"SigmaXZ":1.3705005586e-05,"SigmaYY":8.3705008365e-06,"SigmaYZ":-8.3450468082e-06,"SigmaZZ":1.3835266145e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"31.01.2017","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"309800190","Second":"220700210","GPSBaseline":[{"X":-5008.0917,"Y":-5452.1352,"Z":1429.8281,"SigmaXX":2.6963838536e-05,"SigmaXY":-1.6935066014e-05,"SigmaXZ":2.4230635972e-05,"SigmaYY":1.5817062376e-05,"SigmaYZ":-1.5069539586e-05,"SigmaZZ":2.5167246349e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"31.01.2017","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"309800190","Second":"253600210","GPSBaseline":[{"X":-9577.2198,"Y":-20058.1676,"Z":-4431.5292,"SigmaXX":2.6002793675e-05,"SigmaXY":-1.7368109184e-05,"SigmaXZ":2.3453549147e-05,"SigmaYY":1.8258140699e-05,"SigmaYZ":-1.5198758774e-05,"SigmaZZ":2.4864482839e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"31.01.2017","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"309800190","Second":"305600730","GPSBaseline":[{"X":-14658.4871,"Y":-30585.5011,"Z":-6614.7399,"SigmaXX":3.3676635212e-05,"SigmaXY":-2.3195872927e-05,"SigmaXZ":3.2236621337e-05,"SigmaYY":1.8747869035e-05,"SigmaYZ":-2.3409071218e-05,"SigmaZZ":3.4849479562e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"31.01.2017","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"EURA","Second":"220700210","GPSBaseline":[{"X":245.8478,"Y":-24001.7257,"Z":-18564.0908,"SigmaXX":1.8930984879e-05,"SigmaXY":-1.2052963029e-05,"SigmaXZ":1.710014476e-05,"SigmaYY":1.1113816072e-05,"SigmaYZ":-1.0757343262e-05,"SigmaZZ":1.7808530174e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"31.01.2017","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MNSF","Second":"220700210","GPSBaseline":[{"X":8839.9752,"Y":25488.6018,"Z":9246.6811,"SigmaXX":1.9185956262e-05,"SigmaXY":-1.2247502127e-05,"SigmaXZ":1.7307504095e-05,"SigmaYY":1.1334534975e-05,"SigmaYZ":-1.0921067769e-05,"SigmaZZ":1.8030510546e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"31.01.2017","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MNSF","Second":"253600210","GPSBaseline":[{"X":4270.8463,"Y":10882.5672,"Z":3385.3203,"SigmaXX":2.9947075745e-05,"SigmaXY":-2.0160685381e-05,"SigmaXZ":2.6919886295e-05,"SigmaYY":2.2132733648e-05,"SigmaYZ":-1.7563628717e-05,"SigmaZZ":2.8965871024e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"31.01.2017","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MNSF","Second":"305600730","GPSBaseline":[{"X":-810.4199,"Y":355.2385,"Z":1202.1054,"SigmaXX":2.0450788725e-06,"SigmaXY":-1.2055629668e-06,"SigmaXZ":1.1776891142e-06,"SigmaYY":1.880275363e-06,"SigmaYZ":-1.0562886246e-06,"SigmaZZ":1.9598264771e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"31.01.2017","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"220700210","Second":"253600210","GPSBaseline":[{"X":-4569.1265,"Y":-14606.0296,"Z":-5861.3597,"SigmaXX":2.9986265872e-05,"SigmaXY":-1.9987613996e-05,"SigmaXZ":2.6994777727e-05,"SigmaYY":2.1115276468e-05,"SigmaYZ":-1.7392931113e-05,"SigmaZZ":2.876005783e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"31.01.2017","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"220700210","Second":"305600730","GPSBaseline":[{"X":-9650.3955,"Y":-25133.3616,"Z":-8044.5743,"SigmaXX":3.3950633224e-05,"SigmaXY":-2.1304254915e-05,"SigmaXZ":3.2298459701e-05,"SigmaYY":1.7202790332e-05,"SigmaYZ":-2.0750490876e-05,"SigmaZZ":3.5297380236e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"31.01.2017","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"253600210","Second":"305600730","GPSBaseline":[{"X":-5081.2666,"Y":-10527.3314,"Z":-2183.212,"SigmaXX":4.3022635509e-05,"SigmaXY":-2.7225700251e-05,"SigmaXZ":4.0619641368e-05,"SigmaYY":2.2701473426e-05,"SigmaYZ":-2.6316773074e-05,"SigmaZZ":4.4878041081e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MNSF","Second":"380800400","GPSBaseline":[{"X":-24769.5536,"Y":-13112.7927,"Z":17666.4989,"SigmaXX":1.4073471903e-05,"SigmaXY":-8.4769999376e-06,"SigmaXZ":1.1717330381e-05,"SigmaYY":6.6643638093e-06,"SigmaYZ":-7.812606782e-06,"SigmaZZ":1.1435745364e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MNSF","Second":"380700500","GPSBaseline":[{"X":-32792.5314,"Y":-13273.6381,"Z":26646.0771,"SigmaXX":1.260400586e-05,"SigmaXY":-8.3914683273e-06,"SigmaXZ":1.0964872672e-05,"SigmaYY":6.9979901127e-06,"SigmaYZ":-7.5006873885e-06,"SigmaZZ":1.0917959116e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"257700170","Second":"BNLA","GPSBaseline":[{"X":6926.9046,"Y":41075.6721,"Z":23093.6018,"SigmaXX":1.2768261513e-05,"SigmaXY":-8.4419734776e-06,"SigmaXZ":1.0979512808e-05,"SigmaYY":6.7908904384e-06,"SigmaYZ":-7.7548438639e-06,"SigmaZZ":1.1096671187e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"257700170","Second":"MYRT","GPSBaseline":[{"X":-27844.4223,"Y":-12813.8319,"Z":21812.116,"SigmaXX":1.4607247067e-05,"SigmaXY":-9.2969266916e-06,"SigmaXZ":1.1878309124e-05,"SigmaYY":7.5894504334e-06,"SigmaYZ":-8.2251754066e-06,"SigmaZZ":1.158507348e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"257700170","Second":"MNSF","GPSBaseline":[{"X":31570.3053,"Y":15822.6924,"Z":-23359.6426,"SigmaXX":1.4010142877e-05,"SigmaXY":-9.1755027825e-06,"SigmaXZ":1.1788077245e-05,"SigmaYY":7.6303085734e-06,"SigmaYZ":-8.3895629359e-06,"SigmaZZ":1.1869968148e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"211302450","GPSBaseline":[{"X":1675.8167,"Y":1402.7547,"Z":-797.441,"SigmaXX":8.2574724729e-06,"SigmaXY":-5.257435987e-06,"SigmaXZ":6.8039480539e-06,"SigmaYY":4.1867301661e-06,"SigmaYZ":-4.6807826948e-06,"SigmaZZ":6.6062370934e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"320500750","GPSBaseline":[{"X":-15719.7387,"Y":-31365.1022,"Z":-5917.4501,"SigmaXX":1.1775316125e-05,"SigmaXY":-7.5688958532e-06,"SigmaXZ":9.9268654594e-06,"SigmaYY":6.0844763539e-06,"SigmaYZ":-6.6853585849e-06,"SigmaZZ":9.6456478786e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"380800400","GPSBaseline":[{"X":-126.1455,"Y":-38365.7783,"Z":-28786.7382,"SigmaXX":1.1794405509e-05,"SigmaXY":-7.7401164162e-06,"SigmaXZ":1.0104244211e-05,"SigmaYY":6.0412271523e-06,"SigmaYZ":-7.0204591793e-06,"SigmaZZ":9.9856151792e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"380700500","GPSBaseline":[{"X":-8149.1266,"Y":-38526.6234,"Z":-19807.1651,"SigmaXX":1.2628406694e-05,"SigmaXY":-8.2655369624e-06,"SigmaXZ":1.1114351764e-05,"SigmaYY":6.3600509748e-06,"SigmaYZ":-7.544242635e-06,"SigmaZZ":1.1052113223e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"211302450","GPSBaseline":[{"X":36447.1361,"Y":55292.2653,"Z":484.0359,"SigmaXX":1.1013631593e-05,"SigmaXY":-6.9711582e-06,"SigmaXZ":9.0693083621e-06,"SigmaYY":6.7591918196e-06,"SigmaYZ":-6.8823783295e-06,"SigmaZZ":9.0242783699e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"320500750","GPSBaseline":[{"X":19051.5908,"Y":22524.4015,"Z":-4635.9634,"SigmaXX":1.2393730685e-05,"SigmaXY":-7.4016907092e-06,"SigmaXZ":9.8833870652e-06,"SigmaYY":6.5763924795e-06,"SigmaYZ":-6.2560102378e-06,"SigmaZZ":9.3624039437e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"MYRT","Second":"380700500","GPSBaseline":[{"X":26622.2005,"Y":15362.8839,"Z":-18525.6807,"SigmaXX":1.3023827705e-05,"SigmaXY":-8.6564878075e-06,"SigmaXZ":1.1301704035e-05,"SigmaYY":7.2475945672e-06,"SigmaYZ":-7.7238109952e-06,"SigmaZZ":1.1258668565e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"257700170","Second":"380700500","GPSBaseline":[{"X":-1222.2185,"Y":2549.0497,"Z":3286.4341,"SigmaXX":2.9007684134e-05,"SigmaXY":-1.9324497771e-05,"SigmaXZ":2.4141027097e-05,"SigmaYY":1.6279100237e-05,"SigmaYZ":-1.7014133846e-05,"SigmaZZ":2.3579654226e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"257700170","Second":"380800400","GPSBaseline":[{"X":6800.7531,"Y":2709.8967,"Z":-5693.138,"SigmaXX":2.8389076761e-05,"SigmaXY":-1.8054644897e-05,"SigmaXZ":2.3378122933e-05,"SigmaYY":1.4539337826e-05,"SigmaYZ":-1.6106921976e-05,"SigmaZZ":2.2824320695e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"257700170","Second":"320500750","GPSBaseline":[{"X":-8792.8322,"Y":9710.5688,"Z":17176.1515,"SigmaXX":2.1112551622e-05,"SigmaXY":-1.3317519915e-05,"SigmaXZ":1.7189418941e-05,"SigmaYY":1.1852125681e-05,"SigmaYZ":-1.1386458937e-05,"SigmaZZ":1.6557301933e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"320500750","Second":"211302450","GPSBaseline":[{"X":17395.5479,"Y":32767.8632,"Z":5120.0011,"SigmaXX":1.8167276721e-05,"SigmaXY":-1.1095295122e-05,"SigmaXZ":1.4424191249e-05,"SigmaYY":8.6673517217e-06,"SigmaYZ":-9.4380438895e-06,"SigmaZZ":1.3104432583e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"320500750","Second":"380800400","GPSBaseline":[{"X":15593.5868,"Y":-7000.6735,"Z":-22869.2923,"SigmaXX":1.880538548e-05,"SigmaXY":-1.1770323908e-05,"SigmaXZ":1.5308442016e-05,"SigmaYY":9.3249227575e-06,"SigmaYZ":-1.0218944226e-05,"SigmaZZ":1.4384053429e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"320500750","Second":"380700500","GPSBaseline":[{"X":7570.6084,"Y":-7161.5169,"Z":-13889.7166,"SigmaXX":2.3163438527e-05,"SigmaXY":-1.4812362679e-05,"SigmaXZ":1.9487126337e-05,"SigmaYY":1.2796608644e-05,"SigmaYZ":-1.2838839211e-05,"SigmaZZ":1.8805567379e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"380700500","Second":"380800400","GPSBaseline":[{"X":8022.9797,"Y":160.8435,"Z":-8979.5693,"SigmaXX":2.8550335628e-05,"SigmaXY":-1.8211407223e-05,"SigmaXZ":2.4175404178e-05,"SigmaYY":1.4493237359e-05,"SigmaYZ":-1.6431613403e-05,"SigmaZZ":2.3527465601e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"211302450","Second":"380800400","GPSBaseline":[{"X":-1801.9602,"Y":-39768.5373,"Z":-27989.2926,"SigmaXX":1.58334351e-05,"SigmaXY":-9.5129626061e-06,"SigmaXZ":1.312996028e-05,"SigmaYY":7.2346811066e-06,"SigmaYZ":-8.6122217908e-06,"SigmaZZ":1.2472567505e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"211302450","Second":"257700170","GPSBaseline":[{"X":-8602.717,"Y":-42478.4326,"Z":-22296.1559,"SigmaXX":2.2148751668e-05,"SigmaXY":-1.4195094991e-05,"SigmaXZ":1.8390439436e-05,"SigmaYY":1.1120741874e-05,"SigmaYZ":-1.2585771401e-05,"SigmaZZ":1.7566251699e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"18.01.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"211302450","Second":"380700500","GPSBaseline":[{"X":-9824.9411,"Y":-39929.3817,"Z":-19009.7202,"SigmaXX":2.022571789e-05,"SigmaXY":-1.281655841e-05,"SigmaXZ":1.6880670955e-05,"SigmaYY":1.0047018804e-05,"SigmaYZ":-1.1330036614e-05,"SigmaZZ":1.6030751794e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"260801700","Second":"BNLA","GPSBaseline":[{"X":-33602.1759,"Y":-24510.9789,"Z":18816.1629,"SigmaXX":7.5166362876e-06,"SigmaXY":-4.3681047828e-06,"SigmaXZ":6.3707448135e-06,"SigmaYY":3.4720230815e-06,"SigmaYZ":-3.8842872527e-06,"SigmaZZ":6.5467766035e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"260801700","Second":"EURA","GPSBaseline":[{"X":-364.6399,"Y":-273.6243,"Z":173.6919,"SigmaXX":2.2012592638e-07,"SigmaXY":-9.0036898825e-08,"SigmaXZ":1.2414815842e-07,"SigmaYY":1.4542651172e-07,"SigmaYZ":-6.0376727617e-08,"SigmaZZ":1.9758154224e-07}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":10.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"260801700","Second":"222000390","GPSBaseline":[{"X":302.7335,"Y":777.0038,"Z":257.6249,"SigmaXX":5.3580009762e-07,"SigmaXY":-2.0347432894e-07,"SigmaXZ":2.974281017e-07,"SigmaYY":3.6237594259e-07,"SigmaYZ":-1.4919372404e-07,"SigmaZZ":4.5793893833e-07}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"BNLA","Second":"385900240","GPSBaseline":[{"X":33060.5727,"Y":13506.1106,"Z":-27567.8452,"SigmaXX":1.1935960174e-05,"SigmaXY":-8.1925327322e-06,"SigmaXZ":1.0892369573e-05,"SigmaYY":6.4962541728e-06,"SigmaYZ":-7.8413095252e-06,"SigmaZZ":1.1382130651e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"EURA","Second":"385900240","GPSBaseline":[{"X":-176.9704,"Y":-10731.2352,"Z":-8925.3812,"SigmaXX":1.3736026631e-05,"SigmaXY":-9.1482188509e-06,"SigmaXZ":1.1948910469e-05,"SigmaYY":7.3625665209e-06,"SigmaYZ":-8.4585872173e-06,"SigmaZZ":1.2618957044e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"EURA","Second":"260801050","GPSBaseline":[{"X":-430.7484,"Y":-877.5346,"Z":-171.1784,"SigmaXX":8.9399424041e-07,"SigmaXY":-4.0578007088e-07,"SigmaXZ":4.7066410502e-07,"SigmaYY":4.5841278506e-07,"SigmaYZ":-2.5956512673e-07,"SigmaZZ":6.0974423377e-07}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"EURA","Second":"260801010","GPSBaseline":[{"X":404.326,"Y":-644.7627,"Z":-918.6529,"SigmaXX":8.9668884584e-07,"SigmaXY":-3.6400638237e-07,"SigmaXZ":5.4683550843e-07,"SigmaYY":5.4749614264e-07,"SigmaYZ":-2.5744773779e-07,"SigmaZZ":8.5562157892e-07}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"EURA","Second":"260801120","GPSBaseline":[{"X":-264.3479,"Y":1032.244,"Z":1099.8457,"SigmaXX":9.4715005616e-07,"SigmaXY":-3.9913260252e-07,"SigmaXZ":5.3598529348e-07,"SigmaYY":6.5749264877e-07,"SigmaYZ":-2.7008854886e-07,"SigmaZZ":8.5119472715e-07}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"EURA","Second":"222000390","GPSBaseline":[{"X":667.3733,"Y":1050.6283,"Z":83.9331,"SigmaXX":7.3702102554e-07,"SigmaXY":-3.2974153896e-07,"SigmaXZ":4.1662138983e-07,"SigmaYY":5.2267165529e-07,"SigmaYZ":-2.2635151709e-07,"SigmaZZ":6.9853894047e-07}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"385900240","Second":"MNSF","GPSBaseline":[{"X":-8417.1619,"Y":-38759.0983,"Z":-18885.3857,"SigmaXX":1.1494371392e-05,"SigmaXY":-7.9006431406e-06,"SigmaXZ":1.0560303053e-05,"SigmaYY":6.4427281359e-06,"SigmaYZ":-7.8036946434e-06,"SigmaZZ":1.1535007616e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"385900240","Second":"260801050","GPSBaseline":[{"X":-253.7783,"Y":9853.7028,"Z":8754.1998,"SigmaXX":1.9385774067e-05,"SigmaXY":-1.315353893e-05,"SigmaXZ":1.6902580683e-05,"SigmaYY":1.0575127817e-05,"SigmaYZ":-1.2167204659e-05,"SigmaZZ":1.7296166334e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"385900240","Second":"260801010","GPSBaseline":[{"X":581.2936,"Y":10086.4775,"Z":8006.727,"SigmaXX":1.9709830667e-05,"SigmaXY":-1.2430023162e-05,"SigmaXZ":1.6583200704e-05,"SigmaYY":9.8454511317e-06,"SigmaYZ":-1.0907272554e-05,"SigmaZZ":1.6201309336e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"260801700","Second":"385900240","GPSBaseline":[{"X":-541.6031,"Y":-11004.8653,"Z":-8751.6831,"SigmaXX":1.4589259081e-05,"SigmaXY":-9.6358744486e-06,"SigmaXZ":1.2455905562e-05,"SigmaYY":8.0152794908e-06,"SigmaYZ":-8.7576991064e-06,"SigmaZZ":1.2753648662e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"385900240","Second":"260801120","GPSBaseline":[{"X":-87.3851,"Y":11763.4874,"Z":10025.2224,"SigmaXX":1.7353173462e-05,"SigmaXY":-1.1599888239e-05,"SigmaXZ":1.523345145e-05,"SigmaYY":9.5155482995e-06,"SigmaYZ":-1.0754338291e-05,"SigmaZZ":1.5701190932e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"385900240","Second":"222000390","GPSBaseline":[{"X":844.3408,"Y":11781.8676,"Z":9009.312,"SigmaXX":1.7917856894e-05,"SigmaXY":-1.2209340639e-05,"SigmaXZ":1.5971718312e-05,"SigmaYY":1.0155298696e-05,"SigmaYZ":-1.1524411093e-05,"SigmaZZ":1.6873176719e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"260801050","Second":"260801010","GPSBaseline":[{"X":835.0738,"Y":232.7712,"Z":-747.475,"SigmaXX":1.6176641111e-06,"SigmaXY":-6.3504887748e-07,"SigmaXZ":8.7275554961e-07,"SigmaYY":8.3580783894e-07,"SigmaYZ":-3.7906320927e-07,"SigmaZZ":1.0989195971e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"260801700","Second":"260801050","GPSBaseline":[{"X":-795.3879,"Y":-1151.1586,"Z":2.5138,"SigmaXX":1.5509214109e-06,"SigmaXY":-6.7811248528e-07,"SigmaXZ":7.5666793009e-07,"SigmaYY":8.1837168864e-07,"SigmaYZ":-4.0571976001e-07,"SigmaZZ":9.2787405492e-07}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"260801050","Second":"260801120","GPSBaseline":[{"X":166.4009,"Y":1909.7771,"Z":1271.0233,"SigmaXX":1.2077834072e-05,"SigmaXY":-7.5219372775e-06,"SigmaXZ":1.0706219655e-05,"SigmaYY":6.231099178e-06,"SigmaYZ":-7.2073194133e-06,"SigmaZZ":1.1424473996e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"260801050","Second":"222000390","GPSBaseline":[{"X":1098.1253,"Y":1928.1601,"Z":255.1144,"SigmaXX":1.1145132703e-05,"SigmaXY":-7.2827692748e-06,"SigmaXZ":9.8354003057e-06,"SigmaYY":6.0425168158e-06,"SigmaYZ":-6.9159123086e-06,"SigmaZZ":1.0553905668e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"260801700","Second":"260801010","GPSBaseline":[{"X":39.686,"Y":-918.3876,"Z":-744.9618,"SigmaXX":9.3373097343e-07,"SigmaXY":-3.4364649082e-07,"SigmaXZ":5.3942471823e-07,"SigmaYY":5.8663425762e-07,"SigmaYZ":-2.4368722507e-07,"SigmaZZ":8.1010864506e-07}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"260801010","Second":"260801120","GPSBaseline":[{"X":-668.676,"Y":1677.0094,"Z":2018.4964,"SigmaXX":1.555335075e-05,"SigmaXY":-9.4727711257e-06,"SigmaXZ":1.3282782675e-05,"SigmaYY":7.4816334745e-06,"SigmaYZ":-8.4578587121e-06,"SigmaZZ":1.317308579e-05}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"260801010","Second":"222000390","GPSBaseline":[{"X":263.0477,"Y":1695.3912,"Z":1002.5868,"SigmaXX":2.1139385353e-06,"SigmaXY":-7.7269407939e-07,"SigmaXZ":1.2597781733e-06,"SigmaYY":1.366045467e-06,"SigmaYZ":-5.720416425e-07,"SigmaZZ":1.9621329557e-06}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"260801700","Second":"260801120","GPSBaseline":[{"X":-628.9879,"Y":758.6196,"Z":1273.537,"SigmaXX":1.0978856153e-06,"SigmaXY":-4.3296648755e-07,"SigmaXZ":5.8817272475e-07,"SigmaYY":7.5499974628e-07,"SigmaYZ":-3.068868466e-07,"SigmaZZ":8.6906999286e-07}]}}
+{"DnaMeasurement":{"Type":"G","Source":"","Ignore":"","Epoch":"30.05.2018","ReferenceFrame":"ITRF2014","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"First":"260801120","Second":"222000390","GPSBaseline":[{"X":931.7212,"Y":18.3841,"Z":-1015.9118,"SigmaXX":1.0562148418e-06,"SigmaXY":-4.2241421738e-07,"SigmaXZ":5.884219263e-07,"SigmaYY":7.1765765597e-07,"SigmaYZ":-3.0682434726e-07,"SigmaZZ":8.7936257387e-07}]}}
+{"DnaMeasurement":{"Type":"X","Source":"18017.SNX.VIC.NGCA","Ignore":"","Epoch":"17.01.2018","ReferenceFrame":"ITRF2014","Vscale":8.95,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"Total":4,"First":"211302450","Second":"320500750","GPSBaseline":[{"X":-17395.5539,"Y":-32767.8622,"Z":-5120.0023,"SigmaXX":9.4015092194406e-06,"SigmaXY":-5.8218280654235e-06,"SigmaXZ":7.2784289181185e-06,"SigmaYY":5.0777030687888e-06,"SigmaYZ":-5.1066458443689e-06,"SigmaZZ":7.8407055391149e-06,"GPSCovariance":[{"m11":4.9749423065996e-06,"m12":-3.1969114896831e-06,"m13":3.695832800241e-06,"m21":-3.2013529554219e-06,"m22":2.8060194218639e-06,"m23":-2.6976989698366e-06,"m31":3.7097119997028e-06,"m32":-2.7018343838404e-06,"m33":3.8290076077562e-06},{"m11":4.7079500744576e-06,"m12":-3.0264112469986e-06,"m13":3.4619813060035e-06,"m21":-3.039844849272e-06,"m22":2.6584736880284e-06,"m23":-2.5263704298622e-06,"m31":3.4657271482637e-06,"m32":-2.5129679431939e-06,"m33":3.533784030306e-06},{"m11":4.9606859901968e-06,"m12":-3.2006386884567e-06,"m13":3.6829531143396e-06,"m21":-3.1962437395653e-06,"m22":2.8056266335507e-06,"m23":-2.6911042173119e-06,"m31":3.6839944649982e-06,"m32":-2.6947751841514e-06,"m33":3.8046362180399e-06}],"First":"211302450","Second":"320500750"},{"X":-9824.9302,"Y":-39929.3888,"Z":-19009.7158,"SigmaXX":1.1373463563357e-05,"SigmaXY":-7.0947993502791e-06,"SigmaXZ":8.4205521716444e-06,"SigmaYY":6.1787804174728e-06,"SigmaYZ":-6.0548776061979e-06,"SigmaZZ":8.5570656713947e-06,"GPSCovariance":[{"m11":4.7484332982848e-06,"m12":-3.0467503647178e-06,"m13":3.4995034282007e-06,"m21":-3.058911037872e-06,"m22":2.6724697164314e-06,"m23":-2.550103164825e-06,"m31":3.4999539181858e-06,"m32":-2.5349036046196e-06,"m33":3.5763538628976e-06},{"m11":5.00480613225e-06,"m12":-3.2225449506309e-06,"m13":3.750271184238e-06,"m21":-3.2200180812577e-06,"m22":2.8214046669047e-06,"m23":-2.7354970209635e-06,"m31":3.7353121565658e-06,"m32":-2.725287857758e-06,"m33":3.8951957931228e-06}],"First":"211302450","Second":"380700500"},{"X":-1675.8264,"Y":-1402.7452,"Z":797.4319,"SigmaXX":7.3108047802123e-06,"SigmaXY":-4.5759645766274e-06,"SigmaXZ":5.3166422823289e-06,"SigmaYY":4.0543101609152e-06,"SigmaYZ":-3.8047337134496e-06,"SigmaZZ":5.5221550091332e-06,"GPSCovariance":[{"m11":4.74807679002e-06,"m12":-3.0654271547572e-06,"m13":3.4994577107431e-06,"m21":-3.0530763280825e-06,"m22":2.6796973857218e-06,"m23":-2.5389647975991e-06,"m31":3.4951456908458e-06,"m32":-2.5515830597151e-06,"m33":3.5720918928189e-06}],"First":"211302450","Second":"BNLA"},{"X":-36447.1488,"Y":-55292.2573,"Z":-484.0467,"SigmaXX":7.5344191440056e-06,"SigmaXY":-4.6926566480302e-06,"SigmaXZ":5.4672709047927e-06,"SigmaYY":4.1396546078512e-06,"SigmaYZ":-3.9025034104855e-06,"SigmaZZ":5.6838369486787e-06,"First":"211302450","Second":"MYRT"}]}}
+{"DnaMeasurement":{"Type":"Y","Source":"","Ignore":"","Epoch":"01.01.2020","ReferenceFrame":"GDA2020","Vscale":1.0,"Pscale":1.0,"Lscale":1.0,"Hscale":1.0,"Coords":"XYZ","Total":6,"First":"BEEC","Clusterpoint":[{"X":-4297030.4411,"Y":2827160.2328,"Z":-3759485.1852,"SigmaXX":2.1650722737585e-05,"SigmaXY":-8.2984902599951e-06,"SigmaXZ":1.1052987276139e-05,"SigmaYY":1.452094328725e-05,"SigmaYZ":-7.2786324221448e-06,"SigmaZZ":1.8772773467386e-05,"PointCovariance":[{"m11":2.5948963396491e-08,"m12":-9.2972227574468e-09,"m13":1.3445882933297e-08,"m21":-9.2840368886566e-09,"m22":1.8342544265724e-08,"m23":-8.004486276435e-09,"m31":1.3179165725694e-08,"m32":-7.9541537456198e-09,"m33":2.0133098502121e-08},{"m11":2.6111957589998e-08,"m12":-9.2222073888913e-09,"m13":1.343948631818e-08,"m21":-9.3859306751771e-09,"m22":1.8356694474461e-08,"m23":-8.109974728333e-09,"m31":1.3333477443645e-08,"m32":-7.8874653345601e-09,"m33":2.0213578362423e-08},{"m11":2.6171058622378e-08,"m12":-9.3479873171353e-09,"m13":1.345481323467e-08,"m21":-9.4659382127562e-09,"m22":1.8438562832347e-08,"m23":-8.1180396318296e-09,"m31":1.3409145308116e-08,"m32":-8.0072624270008e-09,"m33":2.0249615328041e-08},{"m11":2.4983053845989e-08,"m12":-8.8005878554783e-09,"m13":1.2738797976884e-08,"m21":-8.9848577471518e-09,"m22":1.8096075247997e-08,"m23":-7.7446294542536e-09,"m31":1.2576431518795e-08,"m32":-7.5997243392428e-09,"m33":1.9448491518897e-08},{"m11":2.6384633801837e-08,"m12":-9.6486777236176e-09,"m13":1.3790794627055e-08,"m21":-9.6770871305634e-09,"m22":1.8762281978073e-08,"m23":-8.2971474776011e-09,"m31":1.3493915481085e-08,"m32":-8.2590713485878e-09,"m33":2.0563494078932e-08}],"First":"BEEC"},{"X":-4228988.874,"Y":2843212.8459,"Z":-3823409.56,"SigmaXX":8.4485025987399e-05,"SigmaXY":-3.250444593873e-05,"SigmaXZ":4.3886660735789e-05,"SigmaYY":5.7977765837968e-05,"SigmaYZ":-2.950089300568e-05,"SigmaZZ":7.6040355931127e-05,"PointCovariance":[{"m11":4.402964254206e-08,"m12":-2.0190310594122e-08,"m13":2.604264979067e-08,"m21":-2.0434656168513e-08,"m22":2.7890235325193e-08,"m23":-1.6850384710028e-08,"m31":2.6268984792575e-08,"m32":-1.6643942958088e-08,"m33":3.3229881345053e-08},{"m11":5.7960774268073e-08,"m12":-2.8836247270585e-08,"m13":3.6469392490676e-08,"m21":-2.904414831575e-08,"m22":3.5290113551989e-08,"m23":-2.4049686801066e-08,"m31":3.6833094508146e-08,"m32":-2.4010321011707e-08,"m33":4.4781571176922e-08},{"m11":3.6769885996121e-08,"m12":-1.6334217900584e-08,"m13":2.0942207446702e-08,"m21":-1.6541967817881e-08,"m22":2.4859370115466e-08,"m23":-1.3683927063326e-08,"m31":2.1153694767666e-08,"m32":-1.3635626607603e-08,"m33":2.7957252156833e-08},{"m11":4.4168437314062e-08,"m12":-2.0697124403524e-08,"m13":2.6328307495055e-08,"m21":-2.0776437793687e-08,"m22":2.856328577256e-08,"m23":-1.7102680388822e-08,"m31":2.6227532071846e-08,"m32":-1.7008208514947e-08,"m33":3.3489504480264e-08}],"First":"MNSF"},{"X":-4286274.1563,"Y":2768476.3104,"Z":-3816870.3348,"SigmaXX":8.6509782444567e-05,"SigmaXY":-3.2534169583418e-05,"SigmaXZ":4.4938948629376e-05,"SigmaYY":5.7266701734391e-05,"SigmaYZ":-2.9064537658202e-05,"SigmaZZ":7.6518834352369e-05,"PointCovariance":[{"m11":5.1354212131275e-08,"m12":-2.4928040869739e-08,"m13":3.1488770613924e-08,"m21":-2.478135255577e-08,"m22":3.1726779208858e-08,"m23":-2.0375675871307e-08,"m31":3.1482825337295e-08,"m32":-2.0517276662461e-08,"m33":3.8620236862616e-08},{"m11":3.7917248268677e-08,"m12":-1.7232674373758e-08,"m13":2.1734467149637e-08,"m21":-1.7230206411933e-08,"m22":2.5691152012504e-08,"m23":-1.4186438399012e-08,"m31":2.1745245792018e-08,"m32":-1.433544254947e-08,"m33":2.8702505244536e-08},{"m11":4.6768761296241e-08,"m12":-2.2505724167755e-08,"m13":2.8003406790169e-08,"m21":-2.2307728792376e-08,"m22":3.0262500991746e-08,"m23":-1.8204170200969e-08,"m31":2.7632397982121e-08,"m32":-1.8311048677186e-08,"m33":3.5201972916124e-08}],"First":"HOTH"},{"X":-4288403.6055,"Y":2814576.3226,"Z":-3778237.7997,"SigmaXX":8.5807836783474e-05,"SigmaXY":-3.2641989000792e-05,"SigmaXZ":4.3995885141792e-05,"SigmaYY":5.7583006773614e-05,"SigmaYZ":-2.8905321841416e-05,"SigmaZZ":7.5178616587682e-05,"PointCovariance":[{"m11":3.8843838228981e-08,"m12":-1.7723893150702e-08,"m13":2.2405976323955e-08,"m21":-1.7751177655552e-08,"m22":2.6073024399427e-08,"m23":-1.4616153603486e-08,"m31":2.2384741410539e-08,"m32":-1.4711151601348e-08,"m33":2.9356152041264e-08},{"m11":6.4309145681525e-08,"m12":-3.3381866106661e-08,"m13":4.0968555608583e-08,"m21":-3.331928856006e-08,"m22":3.9806773538103e-08,"m23":-2.7369642336658e-08,"m31":4.0622546765565e-08,"m32":-2.7357096468155e-08,"m33":4.8946455936092e-08}],"First":"MYRT"},{"X":-4253632.2815,"Y":2868465.8281,"Z":-3776956.316,"SigmaXX":8.521166114245e-05,"SigmaXY":-3.3153838341475e-05,"SigmaXZ":4.375679036766e-05,"SigmaYY":5.8557901972282e-05,"SigmaYZ":-2.9561140533748e-05,"SigmaZZ":7.5245084336609e-05,"PointCovariance":[{"m11":3.9076606711848e-08,"m12":-1.7976234597421e-08,"m13":2.2581222111944e-08,"m21":-1.799279690678e-08,"m22":2.6536617815041e-08,"m23":-1.4868521969818e-08,"m31":2.2309289052865e-08,"m32":-1.4729610155903e-08,"m33":2.9555680197407e-08}],"First":"BNLA"},{"X":-4220394.7452,"Y":2892703.1874,"Z":-3795598.7896,"SigmaXX":8.8972829111023e-05,"SigmaXY":-3.5923715683165e-05,"SigmaXZ":4.7075293807288e-05,"SigmaYY":6.140717749691e-05,"SigmaYZ":-3.2376311968246e-05,"SigmaZZ":7.96224505263e-05,"First":"EURA"}]}}
diff --git a/sampleData/gnss-networkstn.jsonl b/sampleData/gnss-networkstn.jsonl
new file mode 100644
index 000000000..be8e59acd
--- /dev/null
+++ b/sampleData/gnss-networkstn.jsonl
@@ -0,0 +1,44 @@
+{"DnaXmlFormat":{"type":"Station File","referenceframe":"GDA2020","epoch":"01.01.2020"}}
+{"DnaStation":{"Name":"211300470","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"211300470","XAxis":-36.3348253511,"YAxis":145.5741006918,"Height":172.1735},"Description":"BENALLA PM   47"}}
+{"DnaStation":{"Name":"211300940","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"211300940","XAxis":-36.3238821203,"YAxis":145.5821571078,"Height":167.5607},"Description":"BENALLA PM   94"}}
+{"DnaStation":{"Name":"211301000","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"211301000","XAxis":-36.33532816,"YAxis":145.582127866,"Height":171.4809},"Description":"BENALLA PM  100"}}
+{"DnaStation":{"Name":"211301080","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"211301080","XAxis":-36.3308068592,"YAxis":145.585462686,"Height":169.9381},"Description":"BENALLA PM  108"}}
+{"DnaStation":{"Name":"211301110","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"211301110","XAxis":-36.325931386,"YAxis":145.5932297935,"Height":170.2009},"Description":"BENALLA PM  111"}}
+{"DnaStation":{"Name":"211301630","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"211301630","XAxis":-36.3219294692,"YAxis":145.595813161,"Height":169.4131},"Description":"BENALLA PM  163"}}
+{"DnaStation":{"Name":"220700210","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"220700210","XAxis":-36.5740496664,"YAxis":145.4736891223,"Height":332.2819},"Description":"BORODOMANIN PM   21"}}
+{"DnaStation":{"Name":"222000390","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"222000390","XAxis":-36.4508400442,"YAxis":145.3332109089,"Height":171.9275},"Description":"BRANJEE PM   39"}}
+{"DnaStation":{"Name":"222701160","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"222701160","XAxis":-36.434283878,"YAxis":146.580797543,"Height":311.8949},"Description":"BRIGHT PM  116"}}
+{"DnaStation":{"Name":"222702010","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"222702010","XAxis":-36.4257720842,"YAxis":146.5823883952,"Height":640.1152},"Description":"BRIGHT PM  201"}}
+{"DnaStation":{"Name":"222702320","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"222702320","XAxis":-36.4436809426,"YAxis":146.5852816896,"Height":340.3811},"Description":"BRIGHT PM  232"}}
+{"DnaStation":{"Name":"222702940","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"222702940","XAxis":-36.4434808235,"YAxis":147.0049050659,"Height":339.7698},"Description":"222702940, ?, ?"}}
+{"DnaStation":{"Name":"253600210","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"253600210","XAxis":-37.013845371,"YAxis":145.5729502088,"Height":335.742},"Description":"DOOLAM PM   21"}}
+{"DnaStation":{"Name":"257700170","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"257700170","XAxis":-36.4809662585,"YAxis":146.25515005,"Height":268.8467},"Description":"EDI PM   17"}}
+{"DnaStation":{"Name":"260801010","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"260801010","XAxis":-36.4548855103,"YAxis":145.3434480622,"Height":177.6646},"Description":"EUROA PM  101"}}
+{"DnaStation":{"Name":"260801050","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"260801050","XAxis":-36.451861004,"YAxis":145.3501252523,"Height":176.7759},"Description":"EUROA PM  105"}}
+{"DnaStation":{"Name":"260801120","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"260801120","XAxis":-36.4427281796,"YAxis":145.3353959502,"Height":171.5002},"Description":"EUROA PM  112"}}
+{"DnaStation":{"Name":"260801700","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"260801700","XAxis":-36.4518778808,"YAxis":145.3404844754,"Height":174.0624},"Description":"EUROA PM  170"}}
+{"DnaStation":{"Name":"261000380","Constraints":"FFF","Type":"XYZ","StationCoord":{"Name":"261000380","XAxis":-4286411.6817,"YAxis":2832531.3526,"Height":-3767089.7082},"Description":""}}
+{"DnaStation":{"Name":"305600730","Constraints":"FFF","Type":"XYZ","StationCoord":{"Name":"305600730","XAxis":-4229799.2969,"YAxis":2843568.0889,"Height":-3822207.4542},"Description":""}}
+{"DnaStation":{"Name":"309800190","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"309800190","XAxis":-36.5838453748,"YAxis":145.4240764208,"Height":336.3503},"Description":"309800190, ?, ?"}}
+{"DnaStation":{"Name":"324900360","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"324900360","XAxis":-36.3330289906,"YAxis":146.4322017064,"Height":208.3086},"Description":"324900360, ?, ?"}}
+{"DnaStation":{"Name":"324900930","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"324900930","XAxis":-36.3257397589,"YAxis":146.434102305,"Height":226.5738},"Description":"MYRTLEFORD PM   93"}}
+{"DnaStation":{"Name":"324901090","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"324901090","XAxis":-36.3329677497,"YAxis":146.4312255092,"Height":207.3438},"Description":"MYRTLEFORD PM  109"}}
+{"DnaStation":{"Name":"324901200","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"324901200","XAxis":-36.3324225079,"YAxis":146.4342692604,"Height":224.2215},"Description":"MYRTLEFORD PM  120"}}
+{"DnaStation":{"Name":"324901240","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"324901240","XAxis":-36.3355290834,"YAxis":146.4411677544,"Height":383.3658},"Description":"MYRTLEFORD PM  124"}}
+{"DnaStation":{"Name":"341301360","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"341301360","XAxis":-36.4338208982,"YAxis":146.5644085036,"Height":316.678},"Description":"341301360, ?, ?"}}
+{"DnaStation":{"Name":"341301380","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"341301380","XAxis":-36.4344464433,"YAxis":146.5640813454,"Height":333.2243},"Description":"341301380, ?, ?"}}
+{"DnaStation":{"Name":"349800490","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"349800490","XAxis":-36.2704890586,"YAxis":146.4809871586,"Height":1049.6453},"Description":"STANLEY"}}
+{"DnaStation":{"Name":"356000780","Constraints":"FFF","Type":"XYZ","StationCoord":{"Name":"356000780","XAxis":-4283949.9939,"YAxis":2841259.3921,"Height":-3763295.2417},"Description":""}}
+{"DnaStation":{"Name":"380700500","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"380700500","XAxis":-36.4557116945,"YAxis":146.2453114085,"Height":245.6121},"Description":"WHITFIELD PM   50"}}
+{"DnaStation":{"Name":"384300430","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"384300430","XAxis":-36.3124531719,"YAxis":146.0327668401,"Height":172.0214},"Description":"WINTON PM   43"}}
+{"DnaStation":{"Name":"384300490","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"384300490","XAxis":-36.3044794353,"YAxis":146.0501640563,"Height":174.5938},"Description":"WINTON PM   49"}}
+{"DnaStation":{"Name":"385900240","Constraints":"FFF","Type":"XYZ","StationCoord":{"Name":"385900240","XAxis":-4220571.7137,"YAxis":2881971.9439,"Height":-3804524.1681},"Description":""}}
+{"DnaStation":{"Name":"BEEC","Constraints":"FFF","Type":"XYZ","StationCoord":{"Name":"BEEC","XAxis":-4297030.4381,"YAxis":2827160.2309,"Height":-3759485.1829},"Description":"BEEC"}}
+{"DnaStation":{"Name":"BNLA","Constraints":"FFF","Type":"XYZ","StationCoord":{"Name":"BNLA","XAxis":-4253632.2844,"YAxis":2868465.8326,"Height":-3776956.3212},"Description":"BNLA"}}
+{"DnaStation":{"Name":"EURA","Constraints":"FFF","Type":"XYZ","StationCoord":{"Name":"EURA","XAxis":-4220394.7475,"YAxis":2892703.1823,"Height":-3795598.7892},"Description":"EURA"}}
+{"DnaStation":{"Name":"HOTH","Constraints":"FFF","Type":"XYZ","StationCoord":{"Name":"HOTH","XAxis":-4286274.1603,"YAxis":2768476.3135,"Height":-3816870.3376},"Description":"HOTH"}}
+{"DnaStation":{"Name":"MNSF","Constraints":"FFF","Type":"XYZ","StationCoord":{"Name":"MNSF","XAxis":-4228988.8767,"YAxis":2843212.849,"Height":-3823409.5598},"Description":"MNSF"}}
+{"DnaStation":{"Name":"MYRT","Constraints":"FFF","Type":"XYZ","StationCoord":{"Name":"MYRT","XAxis":-4288403.6055,"YAxis":2814576.3244,"Height":-3778237.8015},"Description":"MYRT"}}
+{"DnaStation":{"Name":"211302450","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"211302450","XAxis":-36.3310314683,"YAxis":145.5857072987,"Height":167.3013},"Description":"211302450, ?, ?"}}
+{"DnaStation":{"Name":"320500750","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"320500750","XAxis":-36.3636779636,"YAxis":146.2341565543,"Height":181.8212},"Description":"320500750, ?, ?"}}
+{"DnaStation":{"Name":"380800400","Constraints":"FFF","Type":"LLH","StationCoord":{"Name":"380800400","XAxis":-36.5158459374,"YAxis":146.2148531785,"Height":348.8055},"Description":"380800400, ?, ?"}}
diff --git a/sampleData/strip_schema_location.sh b/sampleData/strip_schema_location.sh
new file mode 100755
index 000000000..a8984e2dc
--- /dev/null
+++ b/sampleData/strip_schema_location.sh
@@ -0,0 +1,6 @@
+#!/bin/bash
+# Strip xsi:noNamespaceSchemaLocation attribute from DynaML XML files.
+# Usage: strip_schema_location.sh <input.xml> <output.xml>
+[ $# -ne 2 ] && { echo "Usage: $0 <input.xml> <output.xml>"; exit 1; }
+[ -f "$1" ] || { echo "FAIL: $1 not found"; exit 1; }
+sed 's/ xsi:noNamespaceSchemaLocation="DynaML\.xsd"//' "$1" > "$2"
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index ae23ce475..b2d1b7d70 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -42,6 +42,31 @@ set(IO_COMMON_SOURCES
     ../dynadjust/include/measurement_types/dnastation.cpp
 )
 
+set(JSONL_PARSER_TEST_SOURCES
+    ../dynadjust/dynadjust/dnaimport/dnaparser_jsonl.cpp
+    ../dynadjust/dynadjust/dnaimport/dnaparser_validators.cpp
+    ../dynadjust/include/functions/dnastringfuncs.cpp
+    ../dynadjust/include/functions/template_instantiations.cpp
+    ../dynadjust/include/math/dnamatrix_contiguous.cpp
+    ../dynadjust/include/ide/trace.cpp
+    ../dynadjust/include/parameters/dnadatum.cpp
+    ../dynadjust/include/parameters/dnaellipsoid.cpp
+    ../dynadjust/include/parameters/dnaprojection.cpp
+    ../dynadjust/include/measurement_types/dnaangle.cpp
+    ../dynadjust/include/measurement_types/dnacoordinate.cpp
+    ../dynadjust/include/measurement_types/dnadirection.cpp
+    ../dynadjust/include/measurement_types/dnadirectionset.cpp
+    ../dynadjust/include/measurement_types/dnadistance.cpp
+    ../dynadjust/include/measurement_types/dnagpsbaseline.cpp
+    ../dynadjust/include/measurement_types/dnagpspoint.cpp
+    ../dynadjust/include/measurement_types/dnaheight.cpp
+    ../dynadjust/include/measurement_types/dnaheightdifference.cpp
+    ../dynadjust/include/measurement_types/dnameasurement.cpp
+    ../dynadjust/include/measurement_types/dnastation.cpp
+    ../dynadjust/include/measurement_types/dnamsrtally.cpp
+    ../dynadjust/include/measurement_types/dnastntally.cpp
+)
+
 # Test 1: Matrix test
 add_executable(test_matrix
     test_matrix.cpp
@@ -219,6 +244,89 @@ target_compile_definitions(test_gnss_nstat_sort PRIVATE
     __BINARY_DESC__="Unit tests for GNSS n-stat sort in alternate units"
 )
 
+# Test 11: FormatElapsedTime helper (issue #351)
+add_executable(test_format_elapsed_time
+    test_format_elapsed_time.cpp
+)
+
+target_compile_definitions(test_format_elapsed_time PRIVATE
+    __BINARY_NAME__="test_format_elapsed_time"
+    __BINARY_DESC__="Unit tests for FormatElapsedTime helper (issue #351)"
+)
+
+# Test 12: DynadjustFile v1.1 back-compat test (issue #325)
+add_executable(test_dynadjust_file
+    test_dynadjust_file.cpp
+    ${IO_COMMON_SOURCES}
+)
+
+target_link_libraries(test_dynadjust_file
+    ${PLATFORM_LIBS}
+    ${Boost_LIBRARIES}
+)
+
+target_compile_definitions(test_dynadjust_file PRIVATE
+    __BINARY_NAME__="test_dynadjust_file"
+    __BINARY_DESC__="Unit tests for DynadjustFile v1.1 back-compat (issue #325)"
+)
+
+# Test 13: JSONL adjustment output schema contract + hook-context threading
+add_executable(test_dnaadjust_json_printer
+    test_dnaadjust_json_printer.cpp
+    ../dynadjust/include/math/dnamatrix_contiguous.cpp
+    ../dynadjust/include/ide/trace.cpp
+)
+
+target_link_libraries(test_dnaadjust_json_printer
+    ${PLATFORM_LIBS}
+)
+
+target_compile_definitions(test_dnaadjust_json_printer PRIVATE
+    __BINARY_NAME__="test_dnaadjust_json_printer"
+    __BINARY_DESC__="Schema contract tests for JSONL adjustment output"
+)
+
+# Test 14: JSONL parser adjustment-report metadata compatibility
+add_executable(test_dnaparser_jsonl
+    test_dnaparser_jsonl.cpp
+    ${JSONL_PARSER_TEST_SOURCES}
+)
+
+target_link_libraries(test_dnaparser_jsonl
+    ${PLATFORM_LIBS}
+    ${Boost_LIBRARIES}
+)
+
+target_compile_definitions(test_dnaparser_jsonl PRIVATE
+    __BINARY_NAME__="test_dnaparser_jsonl"
+    __BINARY_DESC__="Regression tests for JSONL parser"
+)
+
+set(UNIT_TEST_TARGETS
+    test_matrix
+    test_msr_to_stn_sort
+    test_bst_file
+    test_asl_file
+    test_aml_file_loader
+    test_bms_file
+    test_network_data_loader
+    test_measurement_processor
+    test_dnaadjust_printer
+    test_gnss_nstat_sort
+    test_format_elapsed_time
+    test_dynadjust_file
+    test_dnaadjust_json_printer
+    test_dnaparser_jsonl
+)
+
+if(WIN32)
+    foreach(UNIT_TEST_TARGET IN LISTS UNIT_TEST_TARGETS)
+        # Standalone unit tests compile selected DynAdjust sources directly, so
+        # they must not import DNATYPE_API classes from the shared libraries.
+        target_compile_definitions(${UNIT_TEST_TARGET} PRIVATE BUILD_STATIC)
+    endforeach()
+endif()
+
 # Enable testing
 enable_testing()
 
@@ -233,16 +341,20 @@ add_test(NAME NetworkDataLoaderTest COMMAND test_network_data_loader)
 add_test(NAME MeasurementProcessorTest COMMAND test_measurement_processor)
 add_test(NAME DynAdjustPrinterTest COMMAND test_dnaadjust_printer)
 add_test(NAME GNSSNstatSortTest COMMAND test_gnss_nstat_sort)
+add_test(NAME FormatElapsedTimeTest COMMAND test_format_elapsed_time)
+add_test(NAME DynadjustFileTest COMMAND test_dynadjust_file)
+add_test(NAME DynAdjustJsonPrinterTest COMMAND test_dnaadjust_json_printer)
+add_test(NAME DnaParserJsonlTest COMMAND test_dnaparser_jsonl)
 
 # Custom target to run all tests
 add_custom_target(run_tests
     COMMAND ${CMAKE_CTEST_COMMAND} --verbose
-    DEPENDS test_matrix test_msr_to_stn_sort test_bst_file test_asl_file test_aml_file_loader test_bms_file test_network_data_loader test_measurement_processor test_dnaadjust_printer test_gnss_nstat_sort
+    DEPENDS ${UNIT_TEST_TARGETS}
     COMMENT "Running all tests"
 )
 
 # Custom target equivalent to 'make all'
 add_custom_target(tests_all
-    DEPENDS test_matrix test_msr_to_stn_sort test_bst_file test_asl_file test_aml_file_loader test_bms_file test_network_data_loader test_measurement_processor test_dnaadjust_printer test_gnss_nstat_sort
+    DEPENDS ${UNIT_TEST_TARGETS}
     COMMENT "Building all tests"
 )
diff --git a/tests/test_asl_file.cpp b/tests/test_asl_file.cpp
index dbbde08e0..3ee628649 100644
--- a/tests/test_asl_file.cpp
+++ b/tests/test_asl_file.cpp
@@ -261,10 +261,12 @@ TEST_CASE("Write ASL text file", "[asl_file][text]") {
     REQUIRE(std::filesystem::file_size(TEMP_ASL_TXT_FILE) > 0);
 
     // Read and verify basic content structure
-    std::ifstream txt_file(TEMP_ASL_TXT_FILE);
-    std::string first_line;
-    std::getline(txt_file, first_line);
-    REQUIRE(first_line.find("3 stations") != std::string::npos);
+    {
+        std::ifstream txt_file(TEMP_ASL_TXT_FILE);
+        std::string first_line;
+        std::getline(txt_file, first_line);
+        REQUIRE(first_line.find("3 stations") != std::string::npos);
+    }
 
     cleanup_temp_files();
 }
@@ -343,4 +345,4 @@ TEST_CASE("Handle large station counts", "[asl_file][large]") {
     REQUIRE(loaded_result.stations[999].IsValid() == false);
 
     cleanup_temp_files();
-}
\ No newline at end of file
+}
diff --git a/tests/test_asl_file_loader.cpp b/tests/test_asl_file_loader.cpp
index e6f800742..d64ae8151 100644
--- a/tests/test_asl_file_loader.cpp
+++ b/tests/test_asl_file_loader.cpp
@@ -251,10 +251,12 @@ TEST_CASE("Write ASL text file", "[AslFileLoader][text]") {
     REQUIRE(std::filesystem::file_size(TEMP_ASL_TXT_FILE) > 0);
 
     // Read and verify basic content structure
-    std::ifstream txt_file(TEMP_ASL_TXT_FILE);
-    std::string first_line;
-    std::getline(txt_file, first_line);
-    REQUIRE(first_line.find("3 stations") != std::string::npos);
+    {
+        std::ifstream txt_file(TEMP_ASL_TXT_FILE);
+        std::string first_line;
+        std::getline(txt_file, first_line);
+        REQUIRE(first_line.find("3 stations") != std::string::npos);
+    }
 
     cleanup_temp_files();
 }
@@ -334,4 +336,4 @@ TEST_CASE("Handle large station counts", "[AslFileLoader][large]") {
     REQUIRE(loaded_asl_data[999].IsValid() == false);
 
     cleanup_temp_files();
-}
\ No newline at end of file
+}
diff --git a/tests/test_bms_file.cpp b/tests/test_bms_file.cpp
index 89fad4a0f..2c41aa054 100644
--- a/tests/test_bms_file.cpp
+++ b/tests/test_bms_file.cpp
@@ -553,5 +553,39 @@ TEST_CASE("Source file index round-trip", "[BmsFile][roundtrip][source]") {
     REQUIRE(std::string(loaded_meta.sourceFileMeta[0].filename) == "network_a.xml");
     REQUIRE(std::string(loaded_meta.sourceFileMeta[1].filename) == "network_b.xml");
 
+    cleanup_temp_files();
+}
+
+TEST_CASE("observation_epoch round-trip preserves distinct values", "[BmsFile][observation_epoch]") {
+    BmsFile bms_loader;
+    vmsr_t measurements;
+    binary_file_meta_t meta;
+
+    cleanup_temp_files();
+
+    measurement_t msr = {};
+    msr.measType = 'G';
+    msr.measurementStations = 2;
+    snprintf(msr.epsgCode, sizeof(msr.epsgCode), "7843");
+    snprintf(msr.epoch, sizeof(msr.epoch), "01.01.2020");
+    snprintf(msr.observation_epoch, sizeof(msr.observation_epoch), "15.06.2015");
+    msr.station1 = 0;
+    msr.station2 = 1;
+    msr.term1 = 1234.5;
+    measurements.push_back(msr);
+
+    create_test_binary_meta(meta, measurements.size());
+    snprintf(meta.observation_epoch, sizeof(meta.observation_epoch), "15.06.2015");
+
+    bms_loader.WriteFile(TEMP_BMS_FILE, &measurements, meta);
+
+    vmsr_t loaded;
+    binary_file_meta_t loaded_meta;
+    bms_loader.LoadFile(TEMP_BMS_FILE, &loaded, loaded_meta);
+
+    REQUIRE(std::string(loaded[0].epoch) == "01.01.2020");
+    REQUIRE(std::string(loaded[0].observation_epoch) == "15.06.2015");
+    REQUIRE(std::string(loaded_meta.observation_epoch) == "15.06.2015");
+
     cleanup_temp_files();
 }
\ No newline at end of file
diff --git a/tests/test_bst_file.cpp b/tests/test_bst_file.cpp
index e80993062..222d1563d 100644
--- a/tests/test_bst_file.cpp
+++ b/tests/test_bst_file.cpp
@@ -224,3 +224,42 @@ TEST_CASE("Write and read back synthetic data", "[BstFile]") {
 
     cleanup_temp_files();
 }
+
+TEST_CASE("observation_epoch round-trip preserves distinct epoch values", "[BstFile][observation_epoch]") {
+    BstFile bst_loader;
+    vstn_t stations;
+    binary_file_meta_t bst_meta;
+
+    cleanup_temp_files();
+
+    station_t stn;
+    snprintf(stn.stationName, sizeof(stn.stationName), "OBS001");
+    snprintf(stn.stationNameOrig, sizeof(stn.stationNameOrig), "OBS001_2015");
+    snprintf(stn.epoch, sizeof(stn.epoch), "01.01.2020");
+    snprintf(stn.observation_epoch, sizeof(stn.observation_epoch), "15.06.2015");
+    stn.initialLatitude = -35.0;
+    stn.currentLatitude = -35.0;
+    stn.initialLongitude = 149.0;
+    stn.currentLongitude = 149.0;
+    stn.initialHeight = 100.0;
+    stn.currentHeight = 100.0;
+    stn.zone = 55;
+    stn.fileOrder = 1;
+    stn.nameOrder = 1;
+    stations.push_back(stn);
+
+    create_test_binary_meta(bst_meta, static_cast<UINT32>(stations.size()));
+    snprintf(bst_meta.observation_epoch, sizeof(bst_meta.observation_epoch), "15.06.2015");
+
+    bst_loader.WriteFile(TEMP_BST_FILE, &stations, bst_meta);
+
+    vstn_t loaded;
+    binary_file_meta_t loaded_meta;
+    bst_loader.LoadFile(TEMP_BST_FILE, &loaded, loaded_meta);
+
+    REQUIRE(std::string(loaded[0].epoch) == "01.01.2020");
+    REQUIRE(std::string(loaded[0].observation_epoch) == "15.06.2015");
+    REQUIRE(std::string(loaded_meta.observation_epoch) == "15.06.2015");
+
+    cleanup_temp_files();
+}
diff --git a/tests/test_dnaadjust_json_printer.cpp b/tests/test_dnaadjust_json_printer.cpp
new file mode 100644
index 000000000..ac181dbec
--- /dev/null
+++ b/tests/test_dnaadjust_json_printer.cpp
@@ -0,0 +1,688 @@
+//============================================================================
+// Name         : test_dnaadjust_json_printer.cpp
+// Author       : Dale Roberts <dale.o.roberts@gmail.com>
+// Copyright    : Copyright 2026 Geoscience Australia
+//
+//                Licensed under the Apache License, Version 2.0 (the "License");
+//                you may not use this file except in compliance with the License.
+//                You may obtain a copy of the License at
+//
+//                http://www.apache.org/licenses/LICENSE-2.0
+//
+// Description  : Schema contract tests for the JSONL adjustment output.  These
+//                tests lock in the key names and top-level record wrappers
+//                emitted by DynAdjustJsonPrinter so downstream consumers (the
+//                JSONL import parser in particular) can keep round-tripping
+//                records produced by the adjustment path.
+//============================================================================
+
+#define TESTING_MAIN
+#ifndef __BINARY_NAME__
+#define __BINARY_NAME__ "test_dnaadjust_json_printer"
+#endif
+#ifndef __BINARY_DESC__
+#define __BINARY_DESC__ "Schema contract tests for JSONL adjustment output"
+#endif
+
+#include "testing.hpp"
+
+#include <string>
+
+#include "../dynadjust/include/thirdparty/nlohmann/json.hpp"
+
+// Bring matrix_2d into scope before including dnaadjust_printer.hpp.
+// The printer header uses matrix_2d unqualified; it relies on the including
+// translation unit having already pulled in using namespace dynadjust::math
+// (normally provided by dnaadjust.hpp).  We do that explicitly here so the
+// header compiles without the full dnaadjust.hpp dependency chain.
+#include <include/math/dnamatrix_contiguous.hpp>
+using namespace dynadjust::math;
+
+#include <dynadjust/dnaadjust/dnaadjust_printer.hpp>
+
+using nlohmann::json;
+
+// Sample JSONL fragments matching the shapes produced by
+// DynAdjustJsonPrinter.  If the output schema changes in
+// dnaadjust_json_printer.cpp, these fixtures need to track it so
+// downstream tooling and the JSONL import parser stay in sync.
+constexpr const char* kAdjHeader =
+    "{\"DnaAdjustmentReport\":{\"epoch\":\"01.01.2020\","
+    "\"referenceframe\":\"GDA2020\",\"report\":\"adj\","
+    "\"software\":\"DynAdjust 1.4.0\",\"type\":\"Adjustment\"}}";
+
+constexpr const char* kStatisticsLine =
+    "{\"DnaStatistics\":{\"chisq\":335.45,\"chisq_lower\":0.84,"
+    "\"chisq_test\":\"passed\",\"chisq_upper\":1.17,"
+    "\"confidence_interval\":95.0,\"dof\":288,"
+    "\"global_pelzer\":0.78,\"measurement_params\":417,"
+    "\"potential_outliers\":9,\"sigma_zero\":1.16,"
+    "\"unknown_parameters\":129}}";
+
+// Lat/Lon are DMS-packed decimals: -36.345678 ≡ -36°34'56.78".  This matches
+// RadtoDms()'s output and lets the JSONL import parser round-trip via atof →
+// DmstoDeg → Radians.
+constexpr const char* kAdjustedStationLine =
+    "{\"DnaStation\":{\"Adjusted\":{\"Height\":227.18,\"Lat\":-36.544321,"
+    "\"Lon\":146.393456,\"X\":-4288403.6,\"Y\":2814576.3,\"Z\":-3778237.8},"
+    "\"Constraints\":\"FFF\",\"Initial\":{\"Height\":227.17,"
+    "\"Lat\":-36.544321,\"Lon\":146.393456},\"Name\":\"MYRT\","
+    "\"StationCoord\":{\"Height\":227.18,\"Name\":\"MYRT\","
+    "\"XAxis\":-36.544321,\"YAxis\":146.393456},"
+    "\"Type\":\"LLH\","
+    "\"Uncertainty\":{\"HzPosU\":0.005,\"Orientation\":1.88,"
+    "\"SE\":0.002,\"SN\":0.002,\"SU\":0.005,\"SemiMajor\":0.002,"
+    "\"SemiMinor\":0.002,\"VtPosU\":0.010}}}";
+
+constexpr const char* kUncertaintyLine =
+    "{\"DnaStation\":{\"Constraints\":\"FFF\",\"Name\":\"STN1\","
+    "\"Type\":\"LLH\","
+    "\"Uncertainty\":{\"HzPosU\":0.005,\"Orientation\":1.9,"
+    "\"SE\":0.002,\"SN\":0.002,\"SU\":0.005,\"SemiMajor\":0.002,"
+    "\"SemiMinor\":0.002,\"VtPosU\":0.010}}}";
+
+constexpr const char* kCorrectionsLine =
+    "{\"DnaStation\":{\"Constraints\":\"FFF\",\"Corrections\":"
+    "{\"dE\":0.003,\"dN\":0.002,\"dUp\":9.1},\"Initial\":"
+    "{\"Height\":172.19,\"Lat\":-36.544321,\"Lon\":146.393456},"
+    "\"Name\":\"211300470\",\"Type\":\"LLH\"}}";
+
+constexpr const char* kM2SLine =
+    "{\"DnaStation\":{\"Constraints\":\"FFF\","
+    "\"MsrCounts\":{\"A\":0,\"B\":0,\"C\":0,\"D\":0,\"E\":0,\"G\":4,"
+    "\"H\":0,\"I\":0,\"J\":0,\"K\":0,\"L\":0,\"M\":0,\"P\":0,\"Q\":0,"
+    "\"R\":0,\"S\":0,\"V\":0,\"X\":0,\"Y\":0,\"Z\":0},"
+    "\"Name\":\"STN1\",\"TotalMeasurements\":4,\"Type\":\"LLH\"}}";
+
+constexpr const char* kMeasurementLine =
+    "{\"DnaMeasurement\":{\"Adjusted\":1234.567,"
+    "\"AdjustedPrecision\":0.001,\"Correction\":0.002,"
+    "\"EpochOfObservation\":\"15.07.2021\","
+    "\"First\":\"STN1\",\"NStat\":0.8,\"PelzerRel\":0.92,"
+    "\"ResidualPrecision\":0.001,\"Second\":\"STN2\","
+    "\"StdDev\":0.004,\"TStat\":1.1,\"Type\":\"L\","
+    "\"Value\":1234.565}}";
+
+constexpr const char* kDirectionSetLine =
+    "{\"DnaMeasurement\":{\"Adjusted\":45.0,"
+    "\"AdjustedPrecision\":0.0001,\"Correction\":0.0,"
+    "\"Directions\":[{\"Adjusted\":45.1,\"AdjustedPrecision\":0.0002,"
+    "\"Correction\":0.1,\"NStat\":0.5,\"PelzerRel\":0.9,"
+    "\"ResidualPrecision\":0.0003,\"StdDev\":0.01,\"TStat\":1.1,"
+    "\"Target\":\"STN3\",\"Value\":45.0},"
+    "{\"Adjusted\":46.2,\"AdjustedPrecision\":0.0002,"
+    "\"Correction\":0.2,\"Ignore\":true,\"NStat\":0.6,"
+    "\"PelzerRel\":0.8,\"ResidualPrecision\":0.0003,"
+    "\"StdDev\":0.01,\"TStat\":1.2,\"Target\":\"STN4\","
+    "\"Value\":46.0}],\"EpochOfObservation\":\"16.07.2021\","
+    "\"First\":\"STN1\",\"NStat\":0.0,"
+    "\"PelzerRel\":0.0,\"ResidualPrecision\":0.0001,"
+    "\"Second\":\"STN2\",\"StdDev\":0.01,\"TStat\":0.0,"
+    "\"Total\":2,\"Type\":\"D\",\"Value\":44.0}}";
+
+// Cluster measurements (G/X/Y) carry observed X/Y/Z and covariance terms in
+// the same GPSBaseline/Clusterpoint arrays consumed by the JSONL input parser.
+// Adjusted statistics remain as output-only metadata.
+constexpr const char* kClusterMeasurementLine =
+    "{\"DnaMeasurement\":{"
+    "\"Adjusted\":[{\"X\":1.1,\"Y\":2.2,\"Z\":3.3},"
+    "{\"X\":4.4,\"Y\":5.5,\"Z\":6.6}],"
+    "\"AdjustedPrecision\":[{\"X\":0.01,\"Y\":0.01,\"Z\":0.01},"
+    "{\"X\":0.02,\"Y\":0.02,\"Z\":0.02}],"
+    "\"Correction\":[{\"X\":0.001,\"Y\":0.002,\"Z\":0.003},"
+    "{\"X\":0.004,\"Y\":0.005,\"Z\":0.006}],"
+    "\"EpochOfObservation\":\"17.07.2021\","
+    "\"First\":\"STN1\",\"GPSBaseline\":[{\"First\":\"STN1\","
+    "\"GPSCovariance\":[{\"m11\":0.000001,\"m12\":0.000002,"
+    "\"m13\":0.000003,\"m21\":0.000004,\"m22\":0.000005,"
+    "\"m23\":0.000006,\"m31\":0.000007,\"m32\":0.000008,"
+    "\"m33\":0.000009}],\"Second\":\"STN2\","
+    "\"SigmaXX\":0.0001,\"SigmaXY\":0.00001,"
+    "\"SigmaXZ\":0.00002,\"SigmaYY\":0.0002,\"SigmaYZ\":0.00003,"
+    "\"SigmaZZ\":0.0003,\"X\":1.099,\"Y\":2.198,\"Z\":3.297},"
+    "{\"First\":\"STN1\",\"Second\":\"STN3\",\"SigmaXX\":0.0004,"
+    "\"SigmaXY\":0.00004,\"SigmaXZ\":0.00005,\"SigmaYY\":0.0005,"
+    "\"SigmaYZ\":0.00006,\"SigmaZZ\":0.0006,\"X\":4.396,"
+    "\"Y\":5.495,\"Z\":6.594}],"
+    "\"NStat\":[{\"X\":0.5,\"Y\":0.6,\"Z\":0.7},"
+    "{\"X\":0.8,\"Y\":0.9,\"Z\":1.0}],"
+    "\"PelzerRel\":[{\"X\":0.9,\"Y\":0.9,\"Z\":0.9},"
+    "{\"X\":0.8,\"Y\":0.8,\"Z\":0.8}],"
+    "\"Second\":\"STN2\",\"TStat\":[{\"X\":1.0,\"Y\":1.1,\"Z\":1.2},"
+    "{\"X\":1.3,\"Y\":1.4,\"Z\":1.5}],"
+    "\"Total\":2,\"Type\":\"X\"}}";
+
+TEST_CASE("header line has DnaAdjustmentReport wrapper with required keys") {
+    const json record = json::parse(kAdjHeader);
+    REQUIRE(record.contains("DnaAdjustmentReport"));
+    const auto& hdr = record["DnaAdjustmentReport"];
+    REQUIRE(hdr.contains("type"));
+    REQUIRE(hdr.contains("report"));
+    REQUIRE(hdr.contains("software"));
+    REQUIRE(hdr.contains("referenceframe"));
+    REQUIRE(hdr.contains("epoch"));
+    REQUIRE(hdr["type"] == "Adjustment");
+    REQUIRE(hdr["report"] == "adj");
+    REQUIRE(!hdr.contains("statistics"));
+}
+
+TEST_CASE("statistics trailer has DnaStatistics wrapper with required keys") {
+    const json record = json::parse(kStatisticsLine);
+    REQUIRE(record.contains("DnaStatistics"));
+    const auto& s = record["DnaStatistics"];
+    REQUIRE(s.contains("chisq"));
+    REQUIRE(s.contains("dof"));
+    REQUIRE(s.contains("sigma_zero"));
+    REQUIRE(s.contains("global_pelzer"));
+    REQUIRE(s.contains("chisq_lower"));
+    REQUIRE(s.contains("chisq_upper"));
+    REQUIRE(s.contains("chisq_test"));
+    REQUIRE(s.contains("unknown_parameters"));
+    REQUIRE(s.contains("measurement_params"));
+    REQUIRE(s["chisq_test"].get<std::string>() == "passed");
+}
+
+TEST_CASE("adjusted station record carries Initial, Adjusted, Uncertainty") {
+    const json record = json::parse(kAdjustedStationLine);
+    REQUIRE(record.contains("DnaStation"));
+    const auto& s = record["DnaStation"];
+    REQUIRE(s.contains("Name"));
+    REQUIRE(s.contains("Constraints"));
+    REQUIRE(s.contains("Type"));
+    REQUIRE(s.contains("StationCoord"));
+    REQUIRE(s.contains("Initial"));
+    REQUIRE(s.contains("Adjusted"));
+    REQUIRE(s.contains("Uncertainty"));
+    REQUIRE(s["Type"] == "LLH");
+    REQUIRE(s["Adjusted"].contains("X"));
+    REQUIRE(s["Adjusted"].contains("Y"));
+    REQUIRE(s["Adjusted"].contains("Z"));
+    REQUIRE(s["Adjusted"].contains("Lat"));
+    REQUIRE(s["Adjusted"].contains("Lon"));
+    REQUIRE(s["Adjusted"].contains("Height"));
+}
+
+TEST_CASE("station record has round-trippable StationCoord block") {
+    // dnaparser_jsonl.cpp:146-157 expects StationCoord.{XAxis,YAxis,Height}
+    // alongside top-level Type; this makes the emitted station record
+    // directly re-ingestible as initial inputs for a follow-on adjustment.
+    const json record = json::parse(kAdjustedStationLine);
+    const auto& s = record["DnaStation"];
+    REQUIRE(s["Type"].is_string());
+    REQUIRE(s["StationCoord"].is_object());
+    const auto& sc = s["StationCoord"];
+    REQUIRE(sc.contains("Name"));
+    REQUIRE(sc.contains("XAxis"));
+    REQUIRE(sc.contains("YAxis"));
+    REQUIRE(sc.contains("Height"));
+    // Name inside StationCoord mirrors the station Name.
+    REQUIRE(sc["Name"] == s["Name"]);
+}
+
+TEST_CASE("uncertainty record carries ellipse + horizontal/vertical PU") {
+    const json record = json::parse(kUncertaintyLine);
+    const auto& u = record["DnaStation"]["Uncertainty"];
+    REQUIRE(u.contains("SE"));
+    REQUIRE(u.contains("SN"));
+    REQUIRE(u.contains("SU"));
+    REQUIRE(u.contains("SemiMajor"));
+    REQUIRE(u.contains("SemiMinor"));
+    REQUIRE(u.contains("Orientation"));
+    REQUIRE(u.contains("HzPosU"));
+    REQUIRE(u.contains("VtPosU"));
+}
+
+TEST_CASE("station correction record carries dE, dN, dUp") {
+    const json record = json::parse(kCorrectionsLine);
+    const auto& c = record["DnaStation"]["Corrections"];
+    REQUIRE(c.contains("dE"));
+    REQUIRE(c.contains("dN"));
+    REQUIRE(c.contains("dUp"));
+}
+
+TEST_CASE("measurements-to-stations record carries MsrCounts + total") {
+    const json record = json::parse(kM2SLine);
+    const auto& s = record["DnaStation"];
+    REQUIRE(s.contains("MsrCounts"));
+    REQUIRE(s.contains("TotalMeasurements"));
+    const auto& counts = s["MsrCounts"];
+    // 20 canonical single-letter measurement types.
+    REQUIRE(counts.size() == 20);
+    REQUIRE(counts.contains("G"));
+    REQUIRE(counts["G"] == 4);
+}
+
+TEST_CASE("adjusted measurement record carries Type and adjustment fields") {
+    const json record = json::parse(kMeasurementLine);
+    REQUIRE(record.contains("DnaMeasurement"));
+    const auto& m = record["DnaMeasurement"];
+    REQUIRE(m.contains("Type"));
+    REQUIRE(m.contains("First"));
+    REQUIRE(m.contains("Value"));
+    REQUIRE(m.contains("StdDev"));
+    REQUIRE(m.contains("Adjusted"));
+    REQUIRE(m.contains("Correction"));
+    REQUIRE(m.contains("EpochOfObservation"));
+    REQUIRE(m.contains("NStat"));
+    REQUIRE(m.contains("TStat"));
+    REQUIRE(m.contains("PelzerRel"));
+}
+
+TEST_CASE("records round-trip through parse/dump") {
+    // The compact dump format (no whitespace) is what DynAdjustJsonPrinter
+    // emits.  Re-parsing and re-dumping must produce byte-identical output
+    // so records survive a JSON parse/dump pass.
+    for (const char* line : {kAdjHeader, kStatisticsLine,
+                             kAdjustedStationLine, kUncertaintyLine,
+                             kCorrectionsLine, kM2SLine, kMeasurementLine,
+                             kClusterMeasurementLine}) {
+        const json parsed = json::parse(line);
+        REQUIRE(!parsed.is_discarded());
+        const std::string redump = parsed.dump();
+        REQUIRE(!redump.empty());
+        REQUIRE(json::parse(redump) == parsed);
+    }
+}
+
+// ---------------------------------------------------------------------
+// Schema alignment with the JSONL input parser (dnaparser_jsonl.cpp)
+// ---------------------------------------------------------------------
+
+TEST_CASE("station record uses input-parser-compatible key names") {
+    // dnaparser_jsonl.cpp:113-160 reads these keys from DnaStation; when
+    // the adjusted JSONL is re-ingested, these must survive verbatim.
+    const json record = json::parse(kAdjustedStationLine);
+    const auto& s = record["DnaStation"];
+    REQUIRE(s.contains("Name"));
+    REQUIRE(s.contains("Constraints"));
+    REQUIRE(s.contains("Type"));
+    REQUIRE(s.contains("StationCoord"));
+    // "Description" is optional in the input parser; present only when
+    // non-empty on adjusted-station output.  Same policy as the parser.
+}
+
+TEST_CASE("measurement record uses input-parser-compatible key names") {
+    // dnaparser_jsonl.cpp:415-495 reads these keys from DnaMeasurement.
+    const json record = json::parse(kMeasurementLine);
+    const auto& m = record["DnaMeasurement"];
+    REQUIRE(m.contains("Type"));
+    REQUIRE(m.contains("First"));
+    REQUIRE(m.contains("Value"));
+    REQUIRE(m.contains("StdDev"));
+    REQUIRE(m.contains("EpochOfObservation"));
+    // "Second" is present on any non-scalar-from-nothing measurement;
+    // the L (height diff) fixture has two stations.
+    REQUIRE(m.contains("Second"));
+}
+
+// ---------------------------------------------------------------------
+// Type safety — numbers must be numbers, strings must be strings
+// ---------------------------------------------------------------------
+
+TEST_CASE("station identity fields are strings") {
+    const json record = json::parse(kAdjustedStationLine);
+    const auto& s = record["DnaStation"];
+    REQUIRE(s["Name"].is_string());
+    REQUIRE(s["Constraints"].is_string());
+}
+
+TEST_CASE("adjusted coordinate fields are numeric") {
+    const json record = json::parse(kAdjustedStationLine);
+    const auto& a = record["DnaStation"]["Adjusted"];
+    REQUIRE(a["X"].is_number());
+    REQUIRE(a["Y"].is_number());
+    REQUIRE(a["Z"].is_number());
+    REQUIRE(a["Lat"].is_number());
+    REQUIRE(a["Lon"].is_number());
+    REQUIRE(a["Height"].is_number());
+}
+
+TEST_CASE("uncertainty numeric fields are numbers not strings") {
+    const json record = json::parse(kUncertaintyLine);
+    const auto& u = record["DnaStation"]["Uncertainty"];
+    REQUIRE(u["SE"].is_number());
+    REQUIRE(u["SN"].is_number());
+    REQUIRE(u["SU"].is_number());
+    REQUIRE(u["SemiMajor"].is_number());
+    REQUIRE(u["SemiMinor"].is_number());
+    REQUIRE(u["Orientation"].is_number());
+    REQUIRE(u["HzPosU"].is_number());
+    REQUIRE(u["VtPosU"].is_number());
+}
+
+TEST_CASE("correction delta fields are numbers") {
+    const json record = json::parse(kCorrectionsLine);
+    const auto& c = record["DnaStation"]["Corrections"];
+    REQUIRE(c["dE"].is_number());
+    REQUIRE(c["dN"].is_number());
+    REQUIRE(c["dUp"].is_number());
+}
+
+TEST_CASE("statistics numeric fields are numbers and counts are integers") {
+    const json record = json::parse(kStatisticsLine);
+    const auto& s = record["DnaStatistics"];
+    REQUIRE(s["chisq"].is_number());
+    REQUIRE(s["sigma_zero"].is_number());
+    REQUIRE(s["global_pelzer"].is_number());
+    REQUIRE(s["chisq_lower"].is_number());
+    REQUIRE(s["chisq_upper"].is_number());
+    REQUIRE(s["confidence_interval"].is_number());
+    REQUIRE(s["chisq_test"].is_string());
+    REQUIRE(s["dof"].is_number_integer());
+    REQUIRE(s["unknown_parameters"].is_number_integer());
+    REQUIRE(s["measurement_params"].is_number_integer());
+    REQUIRE(s["potential_outliers"].is_number_integer());
+}
+
+TEST_CASE("measurement statistics fields are numbers") {
+    const json record = json::parse(kMeasurementLine);
+    const auto& m = record["DnaMeasurement"];
+    REQUIRE(m["Value"].is_number());
+    REQUIRE(m["StdDev"].is_number());
+    REQUIRE(m["Adjusted"].is_number());
+    REQUIRE(m["Correction"].is_number());
+    REQUIRE(m["AdjustedPrecision"].is_number());
+    REQUIRE(m["ResidualPrecision"].is_number());
+    REQUIRE(m["NStat"].is_number());
+    REQUIRE(m["TStat"].is_number());
+    REQUIRE(m["PelzerRel"].is_number());
+}
+
+TEST_CASE("measurement Type is single uppercase character") {
+    const json record = json::parse(kMeasurementLine);
+    const std::string t = record["DnaMeasurement"]["Type"].get<std::string>();
+    REQUIRE(t.size() == 1);
+    REQUIRE(t[0] >= 'A');
+    REQUIRE(t[0] <= 'Z');
+}
+
+// ---------------------------------------------------------------------
+// Optional-field policies
+// ---------------------------------------------------------------------
+
+TEST_CASE("station Description only appears when non-empty") {
+    // kAdjustedStationLine has no Description (station MYRT in fixture)
+    const json with_no_desc = json::parse(kAdjustedStationLine);
+    REQUIRE(!with_no_desc["DnaStation"].contains("Description"));
+
+    // kCorrectionsLine has a Description (station 211300470 → BENALLA)
+    constexpr const char* with_desc =
+        "{\"DnaStation\":{\"Constraints\":\"FFF\",\"Description\":"
+        "\"BENALLA PM 47\",\"Name\":\"211300470\"}}";
+    const json r = json::parse(with_desc);
+    REQUIRE(r["DnaStation"].contains("Description"));
+    REQUIRE(r["DnaStation"]["Description"].get<std::string>() ==
+            "BENALLA PM 47");
+}
+
+TEST_CASE("ignored measurement carries Ignore=true; active ones omit it") {
+    // Default measurement has no Ignore key
+    const json active = json::parse(kMeasurementLine);
+    REQUIRE(!active["DnaMeasurement"].contains("Ignore"));
+
+    constexpr const char* ignored =
+        "{\"DnaMeasurement\":{\"Type\":\"L\",\"First\":\"A\","
+        "\"Second\":\"B\",\"Value\":10.0,\"Adjusted\":10.0,"
+        "\"StdDev\":0.01,\"Correction\":0.0,\"AdjustedPrecision\":0.01,"
+        "\"ResidualPrecision\":0.01,\"NStat\":0.0,\"TStat\":0.0,"
+        "\"PelzerRel\":0.0,\"Ignore\":true}}";
+    const json r = json::parse(ignored);
+    REQUIRE(r["DnaMeasurement"].contains("Ignore"));
+    REQUIRE(r["DnaMeasurement"]["Ignore"].get<bool>() == true);
+}
+
+// ---------------------------------------------------------------------
+// Measurement type variations (station counts match schema)
+// ---------------------------------------------------------------------
+
+TEST_CASE("scalar two-station measurement carries First and Second only") {
+    // Type L (height difference): First+Second, no Third.
+    constexpr const char* two_stn =
+        "{\"DnaMeasurement\":{\"Type\":\"L\",\"First\":\"A\","
+        "\"Second\":\"B\",\"Value\":10.0,\"Adjusted\":10.0,"
+        "\"StdDev\":0.01,\"Correction\":0.0,\"AdjustedPrecision\":0.01,"
+        "\"ResidualPrecision\":0.01,\"NStat\":0.0,\"TStat\":0.0,"
+        "\"PelzerRel\":0.0}}";
+    const json r = json::parse(two_stn);
+    const auto& m = r["DnaMeasurement"];
+    REQUIRE(m.contains("First"));
+    REQUIRE(m.contains("Second"));
+    REQUIRE(!m.contains("Third"));
+}
+
+TEST_CASE("angle measurement carries First, Second, and Third") {
+    // Type A (horizontal angle): three stations.
+    constexpr const char* three_stn =
+        "{\"DnaMeasurement\":{\"Type\":\"A\",\"First\":\"A\","
+        "\"Second\":\"B\",\"Third\":\"C\",\"Value\":45.0,\"StdDev\":0.01,"
+        "\"Adjusted\":45.0,\"Correction\":0.0,"
+        "\"AdjustedPrecision\":0.01,\"ResidualPrecision\":0.01,"
+        "\"NStat\":0.0,\"TStat\":0.0,\"PelzerRel\":0.0}}";
+    const json r = json::parse(three_stn);
+    const auto& m = r["DnaMeasurement"];
+    REQUIRE(m["Type"] == "A");
+    REQUIRE(m.contains("First"));
+    REQUIRE(m.contains("Second"));
+    REQUIRE(m.contains("Third"));
+}
+
+TEST_CASE("direction set measurement carries grouped Directions array") {
+    const json record = json::parse(kDirectionSetLine);
+    const auto& m = record["DnaMeasurement"];
+    REQUIRE(m["Type"] == "D");
+    REQUIRE(m["First"] == "STN1");
+    REQUIRE(m["Second"] == "STN2");
+    REQUIRE(m["Total"] == 2);
+    REQUIRE(m["EpochOfObservation"] == "16.07.2021");
+    REQUIRE(m.contains("Directions"));
+    REQUIRE(m["Directions"].is_array());
+    REQUIRE(m["Directions"].size() == 2);
+    REQUIRE(m["Directions"][0]["Target"] == "STN3");
+    REQUIRE(m["Directions"][0]["Value"].is_number());
+    REQUIRE(m["Directions"][0]["StdDev"].is_number());
+    REQUIRE(!m["Directions"][0].contains("Second"));
+    REQUIRE(m["Directions"][1]["Ignore"].get<bool>() == true);
+}
+
+TEST_CASE("cluster measurement carries parser-compatible GPSBaseline values") {
+    const json record = json::parse(kClusterMeasurementLine);
+    const auto& m = record["DnaMeasurement"];
+    REQUIRE(m["Type"] == "X");
+    REQUIRE(m["Total"] == 2);
+    REQUIRE(m["EpochOfObservation"] == "17.07.2021");
+    REQUIRE(m.contains("GPSBaseline"));
+    REQUIRE(m["GPSBaseline"].is_array());
+    REQUIRE(m["GPSBaseline"].size() == 2);
+    const auto& b = m["GPSBaseline"][0];
+    for (const char* field : {"First", "Second", "X", "Y", "Z",
+                               "SigmaXX", "SigmaXY", "SigmaXZ",
+                               "SigmaYY", "SigmaYZ", "SigmaZZ"}) {
+        REQUIRE(b.contains(field));
+    }
+    REQUIRE(b["X"].is_number());
+    REQUIRE(b["Y"].is_number());
+    REQUIRE(b["Z"].is_number());
+    REQUIRE(b["SigmaXX"].is_number());
+    REQUIRE(b.contains("GPSCovariance"));
+    REQUIRE(b["GPSCovariance"].is_array());
+    REQUIRE(b["GPSCovariance"].size() == 1);
+    REQUIRE(b["GPSCovariance"][0]["m11"].is_number());
+    REQUIRE(!m["GPSBaseline"][1].contains("GPSCovariance"));
+    REQUIRE(!m.contains("Value"));
+
+    for (const char* field : {"Adjusted", "Correction", "AdjustedPrecision",
+                               "NStat", "TStat", "PelzerRel"}) {
+        REQUIRE(m.contains(field));
+        REQUIRE(m[field].is_array());
+        REQUIRE(m[field].size() == 2);
+        REQUIRE(m[field][0].contains("X"));
+        REQUIRE(m[field][0].contains("Y"));
+        REQUIRE(m[field][0].contains("Z"));
+        REQUIRE(m[field][0]["X"].is_number());
+        REQUIRE(m[field][0]["Y"].is_number());
+        REQUIRE(m[field][0]["Z"].is_number());
+    }
+}
+
+TEST_CASE("single-station measurement carries First only") {
+    // Type H (orthometric height): one station.
+    constexpr const char* one_stn =
+        "{\"DnaMeasurement\":{\"Type\":\"H\",\"First\":\"A\","
+        "\"Value\":100.0,\"StdDev\":0.01,\"Adjusted\":100.0,"
+        "\"Correction\":0.0,"
+        "\"AdjustedPrecision\":0.01,\"ResidualPrecision\":0.01,"
+        "\"NStat\":0.0,\"TStat\":0.0,\"PelzerRel\":0.0}}";
+    const json r = json::parse(one_stn);
+    const auto& m = r["DnaMeasurement"];
+    REQUIRE(m["Type"] == "H");
+    REQUIRE(m.contains("First"));
+    REQUIRE(!m.contains("Second"));
+    REQUIRE(!m.contains("Third"));
+}
+
+// ---------------------------------------------------------------------
+// MsrCounts structure
+// ---------------------------------------------------------------------
+
+TEST_CASE("MsrCounts carries every canonical measurement type key") {
+    const json record = json::parse(kM2SLine);
+    const auto& counts = record["DnaStation"]["MsrCounts"];
+    // The 20 canonical measurement types DynAdjust supports.
+    for (const char* key : {"A","B","C","D","E","G","H","I","J","K",
+                             "L","M","P","Q","R","S","V","X","Y","Z"}) {
+        REQUIRE(counts.contains(key));
+        REQUIRE(counts[key].is_number_integer());
+    }
+}
+
+TEST_CASE("MsrCounts sum consistent with TotalMeasurements") {
+    const json record = json::parse(kM2SLine);
+    const auto& s = record["DnaStation"];
+    int sum = 0;
+    for (const char* key : {"A","B","C","D","E","G","H","I","J","K",
+                             "L","M","P","Q","R","S","V","X","Y","Z"}) {
+        sum += s["MsrCounts"][key].get<int>();
+    }
+    REQUIRE(sum == s["TotalMeasurements"].get<int>());
+}
+
+// ---------------------------------------------------------------------
+// Cross-record / end-to-end stream structure
+// ---------------------------------------------------------------------
+
+TEST_CASE("multi-record JSONL stream parses record-by-record") {
+    // Simulate a minimal `.adj.jsonl`: header, stats, one measurement,
+    // one station.  Parser must read each line independently.
+    std::string stream;
+    stream += kAdjHeader; stream += "\n";
+    stream += kStatisticsLine; stream += "\n";
+    stream += kMeasurementLine; stream += "\n";
+    stream += kAdjustedStationLine; stream += "\n";
+
+    std::vector<json> records;
+    std::size_t start = 0;
+    while (start < stream.size()) {
+        auto end = stream.find('\n', start);
+        if (end == std::string::npos) break;
+        records.push_back(json::parse(stream.substr(start, end - start)));
+        start = end + 1;
+    }
+    REQUIRE(records.size() == 4);
+    REQUIRE(records[0].contains("DnaAdjustmentReport"));
+    REQUIRE(records[1].contains("DnaStatistics"));
+    REQUIRE(records[2].contains("DnaMeasurement"));
+    REQUIRE(records[3].contains("DnaStation"));
+}
+
+TEST_CASE("exactly one top-level wrapper per record") {
+    // Every emitted line must have exactly one of DnaAdjustmentReport /
+    // DnaStation / DnaMeasurement / DnaStatistics so the dispatch
+    // in dnaparser_jsonl.cpp:621-625 remains unambiguous.  (The parser
+    // also accepts DnaXmlFormat from the input grammar as a header
+    // wrapper, for backwards compatibility.)
+    for (const char* line : {kAdjHeader, kStatisticsLine,
+                             kAdjustedStationLine, kUncertaintyLine,
+                             kCorrectionsLine, kM2SLine, kMeasurementLine,
+                             kDirectionSetLine, kClusterMeasurementLine}) {
+        const json r = json::parse(line);
+        REQUIRE(r.is_object());
+        REQUIRE(r.size() == 1);
+        const std::string key = r.begin().key();
+        REQUIRE((key == "DnaAdjustmentReport" || key == "DnaStation" ||
+                 key == "DnaMeasurement" || key == "DnaStatistics"));
+    }
+}
+
+// ---------------------------------------------------------------------
+// Value ranges
+// ---------------------------------------------------------------------
+
+TEST_CASE("Lat/Lon values are DMS-packed decimals in geographic range") {
+    // RadtoDms/RadtoDmsL encode -36°54'43.21" as the decimal -36.544321:
+    // integer part is signed degrees, decimal part packs MM.SSssss.  So
+    // max |Lat| ≈ 90.595999 and max |Lon| ≈ 180.595999.
+    const json record = json::parse(kAdjustedStationLine);
+    const auto& a = record["DnaStation"]["Adjusted"];
+    const double lat = a["Lat"].get<double>();
+    const double lon = a["Lon"].get<double>();
+    REQUIRE(lat >= -91.0);
+    REQUIRE(lat <= 91.0);
+    REQUIRE(lon >= -181.0);
+    REQUIRE(lon <= 181.0);
+}
+
+TEST_CASE("Statistics Chi-square test reports one of the known verdicts") {
+    const json record = json::parse(kStatisticsLine);
+    const std::string verdict =
+        record["DnaStatistics"]["chisq_test"].get<std::string>();
+    REQUIRE((verdict == "passed" || verdict == "warning" ||
+             verdict == "failed" || verdict == "no_redundancy"));
+}
+
+// ---------------------------------------------------------------------
+// Hook context threading contract — compile-time guard against silent
+// signature changes.  A test-only subclass exposes the three protected
+// context structs via public type aliases (the structs are declared in
+// the protected section of DynAdjustPrinter).  Each test constructs a
+// context using aggregate initialisation and asserts every field
+// round-trips the value passed in.  Matrix parameters are passed by
+// reference and the tests verify address identity to confirm the struct
+// stores references, not copies.
+// ---------------------------------------------------------------------
+
+using dynadjust::networkadjust::DynAdjustPrinter;
+
+TEST_CASE("AdjustedStationContext carries threaded precomputed fields") {
+  matrix_2d vc(3, 3), vl(3, 3);
+  DynAdjustPrinter::AdjustedStationContext ctx{
+      -0.635, 2.557, 227.18, vc, vl};
+  REQUIRE(ctx.lat == -0.635);
+  REQUIRE(ctx.lon == 2.557);
+  REQUIRE(ctx.height == 227.18);
+  REQUIRE(&ctx.var_cart == &vc);
+  REQUIRE(&ctx.var_local == &vl);
+}
+
+TEST_CASE("PositionalUncertaintyContext carries ellipse + PU") {
+  matrix_2d vc(3, 3), vl(3, 3);
+  DynAdjustPrinter::PositionalUncertaintyContext ctx{
+      -0.635, 2.557, 227.18, vc, vl,
+      0.002, 0.002, 1.88, 0.005, 0.010};
+  REQUIRE(ctx.lat == -0.635);
+  REQUIRE(ctx.lon == 2.557);
+  REQUIRE(ctx.height == 227.18);
+  REQUIRE(ctx.semimajor == 0.002);
+  REQUIRE(ctx.semiminor == 0.002);
+  REQUIRE(ctx.azimuth == 1.88);
+  REQUIRE(ctx.hz_pos_u == 0.005);
+  REQUIRE(ctx.vt_pos_u == 0.010);
+  REQUIRE(&ctx.var_cart == &vc);
+  REQUIRE(&ctx.var_local == &vl);
+}
+
+TEST_CASE("StationCorrectionContext carries dE/dN/dUp") {
+  DynAdjustPrinter::StationCorrectionContext ctx{0.003, 0.002, 9.1};
+  REQUIRE(ctx.cor_e == 0.003);
+  REQUIRE(ctx.cor_n == 0.002);
+  REQUIRE(ctx.cor_up == 9.1);
+}
diff --git a/tests/test_dnaparser_jsonl.cpp b/tests/test_dnaparser_jsonl.cpp
new file mode 100644
index 000000000..9e18e1ec8
--- /dev/null
+++ b/tests/test_dnaparser_jsonl.cpp
@@ -0,0 +1,370 @@
+//============================================================================
+// Name         : test_dnaparser_jsonl.cpp
+// Author       : Dale Roberts <dale.o.roberts@gmail.com>
+// Copyright    : Copyright 2026 Geoscience Australia
+//
+//                Licensed under the Apache License, Version 2.0 (the "License");
+//                you may not use this file except in compliance with the License.
+//                You may obtain a copy of the License at
+//
+//                http://www.apache.org/licenses/LICENSE-2.0
+//
+// Description  : JSONL parser regression tests.
+//============================================================================
+
+#define TESTING_MAIN
+#ifndef __BINARY_NAME__
+#define __BINARY_NAME__ "test_dnaparser_jsonl"
+#endif
+#ifndef __BINARY_DESC__
+#define __BINARY_DESC__ "Regression tests for JSONL parser"
+#endif
+
+#include "testing.hpp"
+
+#include <filesystem>
+#include <fstream>
+#include <string>
+#include <system_error>
+
+#include <dynadjust/dnaimport/dnaparser_jsonl.hpp>
+#include <include/measurement_types/dnadirection.hpp>
+#include <include/measurement_types/dnagpsbaseline.hpp>
+#include <include/measurement_types/dnagpspoint.hpp>
+#include <include/measurement_types/dnameasurement.hpp>
+#include <include/measurement_types/dnastntally.hpp>
+
+using dynadjust::import::JsonlParseContext;
+using dynadjust::import::ParseJsonlFile;
+using dynadjust::measurements::MsrTally;
+using dynadjust::measurements::StnTally;
+using dynadjust::measurements::vdnaMsrPtr;
+using dynadjust::measurements::vdnaStnPtr;
+
+MsrTally g_parsemsr_tally;
+StnTally g_parsestn_tally;
+UINT32 g_fileOrder = 0;
+
+namespace {
+
+struct TempJsonlFile {
+  explicit TempJsonlFile(const char* name)
+      : path(std::filesystem::temp_directory_path() / name) {}
+
+  ~TempJsonlFile() {
+    std::error_code ec;
+    std::filesystem::remove(path, ec);
+  }
+
+  std::filesystem::path path;
+};
+
+JsonlParseContext DefaultContext() {
+  JsonlParseContext ctx{};
+  ctx.default_frame = "GDA2020";
+  ctx.default_epoch = "01.01.2020";
+  ctx.first_file = true;
+  ctx.user_supplied_frame = false;
+  ctx.user_supplied_epoch = false;
+  ctx.override_input_frame = false;
+  ctx.prefer_single_x_as_g = false;
+  ctx.cluster_id = 0;
+  return ctx;
+}
+
+}  // namespace
+
+TEST_CASE("JSONL parser ignores DnaStatistics adjustment metadata records") {
+  TempJsonlFile tmp("dynadjust-jsonl-statistics-regression.jsonl");
+  {
+    std::ofstream out(tmp.path);
+    out << "{\"DnaAdjustmentReport\":{\"type\":\"Adjustment\","
+           "\"report\":\"adj\",\"software\":\"DynAdjust 1.4.0\","
+           "\"referenceframe\":\"GDA2020\",\"epoch\":\"01.01.2020\"}}\n";
+    out << "{\"DnaStatistics\":{\"iteration\":1,\"dof\":288,"
+           "\"sigma_zero\":1.16,\"chisq_test\":\"passed\"}}\n";
+    out << "{\"DnaStation\":{\"Name\":\"STN1\",\"Constraints\":\"FFF\","
+           "\"Type\":\"LLH\",\"StationCoord\":{\"Name\":\"STN1\","
+           "\"XAxis\":-36.3348253511,\"YAxis\":145.5741006918,"
+           "\"Height\":172.1735},\"Description\":\"Parser regression\"}}\n";
+  }
+
+  vdnaStnPtr stations;
+  vdnaMsrPtr measurements;
+  JsonlParseContext ctx = DefaultContext();
+
+  ParseJsonlFile(tmp.path.string(), &stations, &measurements, ctx);
+
+  REQUIRE(ctx.stn_count == 1);
+  REQUIRE(ctx.msr_count == 0);
+  REQUIRE(stations.size() == 1);
+  REQUIRE(measurements.empty());
+}
+
+TEST_CASE("JSONL parser rejects invalid header reference frame") {
+  TempJsonlFile tmp("dynadjust-jsonl-invalid-header-frame.jsonl");
+  {
+    std::ofstream out(tmp.path);
+    out << "{\"DnaXmlFormat\":{\"type\":\"Measurement File\","
+           "\"referenceframe\":\"GDA202O\",\"epoch\":\"01.01.2020\"}}\n";
+  }
+
+  vdnaStnPtr stations;
+  vdnaMsrPtr measurements;
+  JsonlParseContext ctx = DefaultContext();
+
+  bool threw = false;
+  std::string message;
+  try {
+    ParseJsonlFile(tmp.path.string(), &stations, &measurements, ctx);
+  } catch (const std::exception& e) {
+    threw = true;
+    message = e.what();
+  }
+
+  REQUIRE(threw);
+  REQUIRE(message.find("JSONL line 1") != std::string::npos);
+}
+
+TEST_CASE("JSONL parser re-ingests adjustment measurement records") {
+  TempJsonlFile tmp("dynadjust-jsonl-measurement-regression.jsonl");
+  {
+    std::ofstream out(tmp.path);
+    out << "{\"DnaAdjustmentReport\":{\"type\":\"Adjustment\","
+           "\"report\":\"adj\",\"software\":\"DynAdjust 1.4.0\","
+           "\"referenceframe\":\"GDA2020\",\"epoch\":\"01.01.2020\"}}\n";
+    out << "{\"DnaMeasurement\":{\"Type\":\"L\",\"First\":\"STN1\","
+           "\"Second\":\"STN2\",\"Value\":1234.565,\"StdDev\":0.004,"
+           "\"Adjusted\":1234.567,\"Correction\":0.002,"
+           "\"AdjustedPrecision\":0.001,\"ResidualPrecision\":0.001,"
+           "\"NStat\":0.8,\"TStat\":1.1,\"PelzerRel\":0.92}}\n";
+    out << "{\"DnaMeasurement\":{\"Type\":\"D\",\"First\":\"STN1\","
+           "\"Second\":\"STN2\",\"Value\":45.0,\"StdDev\":0.01,"
+           "\"Total\":1,\"Directions\":[{\"Target\":\"STN2\","
+           "\"Value\":45.0,\"StdDev\":0.01}],\"Adjusted\":45.1,"
+           "\"Correction\":0.1}}\n";
+    out << "{\"DnaMeasurement\":{\"Type\":\"G\",\"First\":\"STN1\","
+           "\"Second\":\"STN2\",\"Total\":1,\"GPSBaseline\":[{"
+           "\"First\":\"STN1\",\"Second\":\"STN2\",\"X\":1.099,"
+           "\"Y\":2.198,\"Z\":3.297,\"SigmaXX\":0.0001,"
+           "\"SigmaXY\":0.00001,\"SigmaXZ\":0.00002,"
+           "\"SigmaYY\":0.0002,\"SigmaYZ\":0.00003,"
+           "\"SigmaZZ\":0.0003}],\"Adjusted\":{\"X\":1.1,"
+           "\"Y\":2.2,\"Z\":3.3}}}\n";
+    out << "{\"DnaMeasurement\":{\"Type\":\"Y\",\"First\":\"STN1\","
+           "\"Total\":1,\"Coords\":\"XYZ\",\"Clusterpoint\":[{"
+           "\"First\":\"STN1\",\"X\":4.099,\"Y\":5.198,\"Z\":6.297,"
+           "\"SigmaXX\":0.0004,\"SigmaXY\":0.00004,"
+           "\"SigmaXZ\":0.00005,\"SigmaYY\":0.0005,"
+           "\"SigmaYZ\":0.00006,\"SigmaZZ\":0.0006}],"
+           "\"Adjusted\":{\"X\":4.1,\"Y\":5.2,\"Z\":6.3}}}\n";
+  }
+
+  vdnaStnPtr stations;
+  vdnaMsrPtr measurements;
+  JsonlParseContext ctx = DefaultContext();
+
+  ParseJsonlFile(tmp.path.string(), &stations, &measurements, ctx);
+
+  REQUIRE(ctx.stn_count == 0);
+  REQUIRE(ctx.msr_count == 8);
+  REQUIRE(stations.empty());
+  REQUIRE(measurements.size() == 4);
+}
+
+TEST_CASE("JSONL parser preserves multi-item GNSS cluster covariances") {
+  TempJsonlFile tmp("dynadjust-jsonl-gnss-cluster-covariance.jsonl");
+  {
+    std::ofstream out(tmp.path);
+    out << "{\"DnaAdjustmentReport\":{\"type\":\"Adjustment\","
+           "\"report\":\"adj\",\"software\":\"DynAdjust 1.4.0\","
+           "\"referenceframe\":\"GDA2020\",\"epoch\":\"01.01.2020\"}}\n";
+    out << "{\"DnaMeasurement\":{\"Type\":\"X\",\"First\":\"STN1\","
+           "\"Second\":\"STN2\",\"Total\":2,\"GPSBaseline\":[{"
+           "\"First\":\"STN1\",\"Second\":\"STN2\",\"X\":1.0,"
+           "\"Y\":2.0,\"Z\":3.0,\"SigmaXX\":0.0001,"
+           "\"SigmaXY\":0.00001,\"SigmaXZ\":0.00002,"
+           "\"SigmaYY\":0.0002,\"SigmaYZ\":0.00003,"
+           "\"SigmaZZ\":0.0003,\"GPSCovariance\":[{"
+           "\"m11\":0.000001,\"m12\":0.000002,\"m13\":0.000003,"
+           "\"m21\":0.000004,\"m22\":0.000005,\"m23\":0.000006,"
+           "\"m31\":0.000007,\"m32\":0.000008,\"m33\":0.000009}]},"
+           "{\"First\":\"STN1\",\"Second\":\"STN3\",\"X\":4.0,"
+           "\"Y\":5.0,\"Z\":6.0,\"SigmaXX\":0.0004,"
+           "\"SigmaXY\":0.00004,\"SigmaXZ\":0.00005,"
+           "\"SigmaYY\":0.0005,\"SigmaYZ\":0.00006,"
+           "\"SigmaZZ\":0.0006}]}}\n";
+    out << "{\"DnaMeasurement\":{\"Type\":\"Y\",\"First\":\"STN1\","
+           "\"Total\":2,\"Coords\":\"XYZ\",\"Clusterpoint\":[{"
+           "\"First\":\"STN1\",\"X\":7.0,\"Y\":8.0,\"Z\":9.0,"
+           "\"SigmaXX\":0.0007,\"SigmaXY\":0.00007,"
+           "\"SigmaXZ\":0.00008,\"SigmaYY\":0.0008,"
+           "\"SigmaYZ\":0.00009,\"SigmaZZ\":0.0009,"
+           "\"PointCovariance\":[{\"m11\":0.000011,"
+           "\"m12\":0.000012,\"m13\":0.000013,"
+           "\"m21\":0.000014,\"m22\":0.000015,"
+           "\"m23\":0.000016,\"m31\":0.000017,"
+           "\"m32\":0.000018,\"m33\":0.000019}]},"
+           "{\"First\":\"STN2\",\"X\":10.0,\"Y\":11.0,\"Z\":12.0,"
+           "\"SigmaXX\":0.0010,\"SigmaXY\":0.00010,"
+           "\"SigmaXZ\":0.00011,\"SigmaYY\":0.0011,"
+           "\"SigmaYZ\":0.00012,\"SigmaZZ\":0.0012}]}}\n";
+  }
+
+  vdnaStnPtr stations;
+  vdnaMsrPtr measurements;
+  JsonlParseContext ctx = DefaultContext();
+
+  ParseJsonlFile(tmp.path.string(), &stations, &measurements, ctx);
+
+  REQUIRE(ctx.stn_count == 0);
+  REQUIRE(ctx.msr_count == 12);
+  REQUIRE(stations.empty());
+  REQUIRE(measurements.size() == 2);
+
+  auto* baselines = measurements[0]->GetBaselines_ptr();
+  REQUIRE(baselines != nullptr);
+  REQUIRE(baselines->size() == 2);
+  REQUIRE(baselines->at(0).GetCovariances_ptr()->size() == 1);
+  REQUIRE(baselines->at(1).GetCovariances_ptr()->empty());
+  REQUIRE(baselines->at(0).GetCovariances_ptr()->at(0).GetM11() == 0.000001);
+
+  auto* points = measurements[1]->GetPoints_ptr();
+  REQUIRE(points != nullptr);
+  REQUIRE(points->size() == 2);
+  REQUIRE(points->at(0).GetCovariances_ptr()->size() == 1);
+  REQUIRE(points->at(1).GetCovariances_ptr()->empty());
+  REQUIRE(points->at(0).GetCovariances_ptr()->at(0).GetM11() == 0.000011);
+}
+
+TEST_CASE("JSONL parser preserves measurement observation epochs") {
+  TempJsonlFile tmp("dynadjust-jsonl-observation-epoch.jsonl");
+  {
+    std::ofstream out(tmp.path);
+    out << "{\"DnaAdjustmentReport\":{\"type\":\"Adjustment\","
+           "\"report\":\"adj\",\"software\":\"DynAdjust 1.4.0\","
+           "\"referenceframe\":\"GDA2020\",\"epoch\":\"01.01.2020\"}}\n";
+    out << "{\"DnaMeasurement\":{\"Type\":\"L\",\"First\":\"STN1\","
+           "\"Second\":\"STN2\",\"Epoch\":\"01.01.2020\","
+           "\"EpochOfObservation\":\"15.07.2021\","
+           "\"Value\":10.0,\"StdDev\":0.01}}\n";
+    out << "{\"DnaMeasurement\":{\"Type\":\"D\",\"First\":\"STN1\","
+           "\"Second\":\"STN2\",\"EpochOfObservation\":\"16.07.2021\","
+           "\"Value\":44.0,\"StdDev\":0.01,\"Total\":1,"
+           "\"Directions\":[{\"Target\":\"STN3\",\"Value\":45.0,"
+           "\"StdDev\":0.01}]}}\n";
+    out << "{\"DnaMeasurement\":{\"Type\":\"X\",\"First\":\"STN1\","
+           "\"Second\":\"STN2\",\"Epoch\":\"01.01.2020\","
+           "\"EpochOfObservation\":\"17.07.2021\",\"Total\":1,"
+           "\"GPSBaseline\":[{\"First\":\"STN1\",\"Second\":\"STN2\","
+           "\"X\":1.0,\"Y\":2.0,\"Z\":3.0,\"SigmaXX\":0.0001,"
+           "\"SigmaXY\":0.00001,\"SigmaXZ\":0.00002,"
+           "\"SigmaYY\":0.0002,\"SigmaYZ\":0.00003,"
+           "\"SigmaZZ\":0.0003}]}}\n";
+    out << "{\"DnaMeasurement\":{\"Type\":\"Y\",\"First\":\"STN1\","
+           "\"Epoch\":\"01.01.2020\","
+           "\"EpochOfObservation\":\"18.07.2021\",\"Total\":1,"
+           "\"Coords\":\"XYZ\",\"Clusterpoint\":[{\"First\":\"STN1\","
+           "\"X\":4.0,\"Y\":5.0,\"Z\":6.0,\"SigmaXX\":0.0004,"
+           "\"SigmaXY\":0.00004,\"SigmaXZ\":0.00005,"
+           "\"SigmaYY\":0.0005,\"SigmaYZ\":0.00006,"
+           "\"SigmaZZ\":0.0006}]}}\n";
+  }
+
+  vdnaStnPtr stations;
+  vdnaMsrPtr measurements;
+  JsonlParseContext ctx = DefaultContext();
+
+  ParseJsonlFile(tmp.path.string(), &stations, &measurements, ctx);
+
+  REQUIRE(measurements.size() == 4);
+  REQUIRE(measurements[0]->GetObservationEpoch() == "15.07.2021");
+  REQUIRE(measurements[1]->GetObservationEpoch() == "16.07.2021");
+  REQUIRE(measurements[2]->GetObservationEpoch() == "17.07.2021");
+  REQUIRE(measurements[3]->GetObservationEpoch() == "18.07.2021");
+
+  auto* directions = measurements[1]->GetDirections_ptr();
+  REQUIRE(directions != nullptr);
+  REQUIRE(directions->at(0).GetObservationEpoch() == "16.07.2021");
+
+  auto* baselines = measurements[2]->GetBaselines_ptr();
+  REQUIRE(baselines != nullptr);
+  REQUIRE(baselines->at(0).GetObservationEpoch() == "17.07.2021");
+
+  auto* points = measurements[3]->GetPoints_ptr();
+  REQUIRE(points != nullptr);
+  REQUIRE(points->at(0).GetObservationEpoch() == "18.07.2021");
+}
+
+TEST_CASE("JSONL parser preserves grouped adjustment direction sets") {
+  TempJsonlFile tmp("dynadjust-jsonl-direction-set-regression.jsonl");
+  {
+    std::ofstream out(tmp.path);
+    out << "{\"DnaAdjustmentReport\":{\"type\":\"Adjustment\","
+           "\"report\":\"adj\",\"software\":\"DynAdjust 1.4.0\","
+           "\"referenceframe\":\"GDA2020\",\"epoch\":\"01.01.2020\"}}\n";
+    out << "{\"DnaMeasurement\":{\"Type\":\"D\",\"First\":\"STN1\","
+           "\"Second\":\"STN2\",\"Value\":44.0,\"StdDev\":0.01,"
+           "\"Total\":2,\"Directions\":[{\"Target\":\"STN3\","
+           "\"Value\":45.0,\"StdDev\":0.01,\"Adjusted\":45.1,"
+           "\"Correction\":0.1},{\"Target\":\"STN4\","
+           "\"Value\":46.0,\"StdDev\":0.01,\"Ignore\":true,"
+           "\"Adjusted\":46.2,\"Correction\":0.2}]}}\n";
+  }
+
+  vdnaStnPtr stations;
+  vdnaMsrPtr measurements;
+  JsonlParseContext ctx = DefaultContext();
+
+  ParseJsonlFile(tmp.path.string(), &stations, &measurements, ctx);
+
+  REQUIRE(ctx.stn_count == 0);
+  REQUIRE(ctx.msr_count == 2);
+  REQUIRE(stations.empty());
+  REQUIRE(measurements.size() == 1);
+
+  auto* directions = measurements[0]->GetDirections_ptr();
+  REQUIRE(directions != nullptr);
+  REQUIRE(directions->size() == 2);
+  REQUIRE(directions->at(0).GetTarget() == "STN3");
+  REQUIRE(directions->at(1).GetTarget() == "STN4");
+  REQUIRE(directions->at(1).GetIgnore() == true);
+}
+
+TEST_CASE("JSONL parser treats boolean Ignore false as active") {
+  TempJsonlFile tmp("dynadjust-jsonl-ignore-false-regression.jsonl");
+  {
+    std::ofstream out(tmp.path);
+    out << "{\"DnaAdjustmentReport\":{\"type\":\"Adjustment\","
+           "\"report\":\"adj\",\"software\":\"DynAdjust 1.4.0\","
+           "\"referenceframe\":\"GDA2020\",\"epoch\":\"01.01.2020\"}}\n";
+    out << "{\"DnaMeasurement\":{\"Type\":\"L\",\"First\":\"STN1\","
+           "\"Second\":\"STN2\",\"Value\":10.0,\"StdDev\":0.01,"
+           "\"Ignore\":false}}\n";
+    out << "{\"DnaMeasurement\":{\"Type\":\"D\",\"First\":\"STN1\","
+           "\"Second\":\"STN2\",\"Value\":44.0,\"StdDev\":0.01,"
+           "\"Ignore\":false,\"Total\":2,\"Directions\":[{"
+           "\"Target\":\"STN3\",\"Value\":45.0,\"StdDev\":0.01,"
+           "\"Ignore\":false},{\"Target\":\"STN4\",\"Value\":46.0,"
+           "\"StdDev\":0.01,\"Ignore\":true}]}}\n";
+  }
+
+  vdnaStnPtr stations;
+  vdnaMsrPtr measurements;
+  JsonlParseContext ctx = DefaultContext();
+
+  ParseJsonlFile(tmp.path.string(), &stations, &measurements, ctx);
+
+  REQUIRE(ctx.stn_count == 0);
+  REQUIRE(ctx.msr_count == 3);
+  REQUIRE(stations.empty());
+  REQUIRE(measurements.size() == 2);
+  REQUIRE(measurements[0]->GetIgnore() == false);
+  REQUIRE(measurements[1]->GetIgnore() == false);
+
+  auto* directions = measurements[1]->GetDirections_ptr();
+  REQUIRE(directions != nullptr);
+  REQUIRE(directions->size() == 2);
+  REQUIRE(directions->at(0).GetIgnore() == false);
+  REQUIRE(directions->at(1).GetIgnore() == true);
+}
diff --git a/tests/test_dynadjust_file.cpp b/tests/test_dynadjust_file.cpp
new file mode 100644
index 000000000..cf3ca885f
--- /dev/null
+++ b/tests/test_dynadjust_file.cpp
@@ -0,0 +1,217 @@
+//============================================================================
+// Name         : test_dynadjust_file.cpp
+// Author       : Dale Roberts <dale.o.roberts@gmail.com>
+// Contributors :
+// Copyright    : Copyright 2017-2025 Geoscience Australia
+//
+//                Licensed under the Apache License, Version 2.0 (the "License");
+//                you may not use this file except in compliance with the License.
+//                You may obtain a copy of the License at
+//
+//                http ://www.apache.org/licenses/LICENSE-2.0
+//
+//                Unless required by applicable law or agreed to in writing, software
+//                distributed under the License is distributed on an "AS IS" BASIS,
+//                WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//                See the License for the specific language governing permissions and
+//                limitations under the License.
+//
+// Description  : Unit tests for DynadjustFile (issue #325 back-compat)
+//============================================================================
+
+#define TESTING_MAIN
+#ifndef __BINARY_NAME__
+#define __BINARY_NAME__ "test_dynadjust_file"
+#endif
+#ifndef __BINARY_DESC__
+#define __BINARY_DESC__ "Unit tests for DynadjustFile v1.1 back-compat"
+#endif
+
+#include "testing.hpp"
+
+#include "../dynadjust/include/io/dynadjust_file.hpp"
+#include <cstdint>
+#include <filesystem>
+#include <fstream>
+
+using namespace dynadjust::iostreams;
+
+namespace {
+const std::string TEMP_V11_FILE = "temp_test_v11.bin";
+const std::string TEMP_V12_FILE = "temp_test_v12.bin";
+
+void cleanup(const std::string& path) {
+    if (std::filesystem::exists(path))
+        std::filesystem::remove(path);
+}
+
+void write_identifier_field(std::ofstream& os, const std::string& value) {
+    char buf[identifier_field_width + 1];
+    snprintf(buf, sizeof(buf), "%*s", identifier_field_width,
+             value.substr(0, identifier_field_width).c_str());
+    os.write(buf, identifier_field_width);
+}
+
+// Writes the DynadjustFile file-info header block with the supplied version
+// string (no class setter forces the on-disk version independent of __FILE_VERSION__).
+void write_file_info(std::ofstream& os, const std::string& version_value) {
+    os.write(version_header, identifier_field_width);
+    write_identifier_field(os, version_value);
+    os.write(create_date_header, identifier_field_width);
+    write_identifier_field(os, "2024-01-15");
+    os.write(create_by_header, identifier_field_width);
+    write_identifier_field(os, "DNA1.4");
+}
+
+// Writes metadata in the pre-v1.2 layout: omits the observation_epoch fields
+// from both the top-level meta and each input_file_meta entry.
+void write_v11_metadata(std::ofstream& os,
+                        const std::string& epsg,
+                        const std::string& epoch,
+                        std::uint64_t input_file_count,
+                        const std::string& input_file_epoch) {
+    std::uint64_t bin_count = 0;
+    os.write(reinterpret_cast<const char*>(&bin_count), sizeof(bin_count));
+
+    bool reduced = false;
+    os.write(reinterpret_cast<const char*>(&reduced), sizeof(reduced));
+
+    char modified_by[MOD_NAME_WIDTH] = {0};
+    snprintf(modified_by, sizeof(modified_by), "test_v11");
+    os.write(modified_by, MOD_NAME_WIDTH);
+
+    char epsg_buf[STN_EPSG_WIDTH] = {0};
+    snprintf(epsg_buf, sizeof(epsg_buf), "%s", epsg.c_str());
+    os.write(epsg_buf, STN_EPSG_WIDTH);
+
+    char epoch_buf[STN_EPOCH_WIDTH] = {0};
+    snprintf(epoch_buf, sizeof(epoch_buf), "%s", epoch.c_str());
+    os.write(epoch_buf, STN_EPOCH_WIDTH);
+
+    // v1.1: no observation_epoch field at this position.
+
+    bool reftran = false;
+    os.write(reinterpret_cast<const char*>(&reftran), sizeof(reftran));
+
+    bool geoid = false;
+    os.write(reinterpret_cast<const char*>(&geoid), sizeof(geoid));
+
+    os.write(reinterpret_cast<const char*>(&input_file_count), sizeof(input_file_count));
+    for (std::uint64_t i = 0; i < input_file_count; ++i) {
+        char file_name[FILE_NAME_WIDTH] = {0};
+        snprintf(file_name, sizeof(file_name), "input_%llu.xml",
+                 static_cast<unsigned long long>(i));
+        os.write(file_name, FILE_NAME_WIDTH);
+
+        char input_epsg_buf[STN_EPSG_WIDTH] = {0};
+        snprintf(input_epsg_buf, sizeof(input_epsg_buf), "%s", epsg.c_str());
+        os.write(input_epsg_buf, STN_EPSG_WIDTH);
+
+        char input_epoch_buf[STN_EPOCH_WIDTH] = {0};
+        snprintf(input_epoch_buf, sizeof(input_epoch_buf), "%s", input_file_epoch.c_str());
+        os.write(input_epoch_buf, STN_EPOCH_WIDTH);
+
+        // v1.1: no observation_epoch per input file.
+
+        std::uint16_t filetype = 1;
+        os.write(reinterpret_cast<const char*>(&filetype), sizeof(filetype));
+
+        std::uint16_t datatype = 1;
+        os.write(reinterpret_cast<const char*>(&datatype), sizeof(datatype));
+    }
+
+    // sourceFileCount is v1.1+, so it is present (set to zero for simplicity).
+    std::uint64_t source_file_count = 0;
+    os.write(reinterpret_cast<const char*>(&source_file_count), sizeof(source_file_count));
+}
+} // namespace
+
+// Regression test for issue #325: v1.1 segment/project files (no
+// observation_epoch on disk) must load with observation_epoch defaulted to
+// epoch so legacy files remain readable with identical semantics.
+TEST_CASE("DynadjustFile v1.1 loads with observation_epoch defaulted to epoch",
+          "[DynadjustFile][backcompat]") {
+    cleanup(TEMP_V11_FILE);
+
+    const std::string epsg = "7843";
+    const std::string epoch = "01.01.2020";
+    const std::string input_epoch = "01.01.2020";
+
+    {
+        std::ofstream os(TEMP_V11_FILE, std::ios::out | std::ios::binary);
+        REQUIRE(os.is_open());
+        write_file_info(os, "1.1");
+        write_v11_metadata(os, epsg, epoch, 2, input_epoch);
+        os.close();
+    }
+
+    DynadjustFile file;
+    std::ifstream is(TEMP_V11_FILE, std::ios::in | std::ios::binary);
+    REQUIRE(is.is_open());
+
+    file.ReadFileInfo(is);
+    REQUIRE(file.GetVersion() == "1.1");
+
+    binary_file_meta_t meta;
+    file.ReadFileMetadata(is, meta);
+    is.close();
+
+    REQUIRE(std::string(meta.epsgCode) == epsg);
+    REQUIRE(std::string(meta.epoch) == epoch);
+    // Back-compat invariant: observation_epoch falls back to epoch.
+    REQUIRE(std::string(meta.observation_epoch) == std::string(meta.epoch));
+
+    REQUIRE(meta.inputFileCount == 2);
+    for (std::uint64_t i = 0; i < meta.inputFileCount; ++i) {
+        REQUIRE(std::string(meta.inputFileMeta[i].epoch) == input_epoch);
+        REQUIRE(std::string(meta.inputFileMeta[i].observation_epoch)
+                == std::string(meta.inputFileMeta[i].epoch));
+    }
+
+    cleanup(TEMP_V11_FILE);
+}
+
+// v1.2 round-trip: writing via DynadjustFile and reading back must preserve a
+// distinct observation_epoch independent of reference-frame epoch.
+TEST_CASE("DynadjustFile v1.2 round-trip preserves distinct observation_epoch",
+          "[DynadjustFile][roundtrip]") {
+    cleanup(TEMP_V12_FILE);
+
+    binary_file_meta_t write_meta;
+    write_meta.binCount = 0;
+    write_meta.reduced = false;
+    write_meta.reftran = false;
+    write_meta.geoid = false;
+    snprintf(write_meta.modifiedBy, sizeof(write_meta.modifiedBy), "test_v12");
+    snprintf(write_meta.epsgCode, sizeof(write_meta.epsgCode), "7843");
+    snprintf(write_meta.epoch, sizeof(write_meta.epoch), "01.01.2020");
+    snprintf(write_meta.observation_epoch, sizeof(write_meta.observation_epoch),
+             "15.06.2015");
+    write_meta.inputFileCount = 0;
+    write_meta.sourceFileCount = 0;
+
+    {
+        DynadjustFile file;
+        std::ofstream os(TEMP_V12_FILE, std::ios::out | std::ios::binary);
+        REQUIRE(os.is_open());
+        file.WriteFileInfo(os);
+        file.WriteFileMetadata(os, write_meta);
+        os.close();
+    }
+
+    DynadjustFile file;
+    std::ifstream is(TEMP_V12_FILE, std::ios::in | std::ios::binary);
+    REQUIRE(is.is_open());
+
+    file.ReadFileInfo(is);
+    REQUIRE(file.GetVersion() == "1.2");
+
+    binary_file_meta_t read_meta;
+    file.ReadFileMetadata(is, read_meta);
+    is.close();
+
+    REQUIRE(std::string(read_meta.epoch) == "01.01.2020");
+    REQUIRE(std::string(read_meta.observation_epoch) == "15.06.2015");
+
+    cleanup(TEMP_V12_FILE);
+}
diff --git a/tests/test_format_elapsed_time.cpp b/tests/test_format_elapsed_time.cpp
new file mode 100644
index 000000000..45f99e88a
--- /dev/null
+++ b/tests/test_format_elapsed_time.cpp
@@ -0,0 +1,36 @@
+#define TESTING_MAIN
+#ifndef __BINARY_NAME__
+#define __BINARY_NAME__ "test_format_elapsed_time"
+#endif
+#ifndef __BINARY_DESC__
+#define __BINARY_DESC__ "Unit tests for FormatElapsedTime helper (issue #351)"
+#endif
+
+#include "testing.hpp"
+
+#include "../dynadjust/include/functions/dnatimer.hpp"
+
+using dynadjust::FormatElapsedTime;
+
+TEST_CASE("Sub-second durations report milliseconds", "[time][issue351]") {
+    REQUIRE(FormatElapsedTime(0.000078) == "0.078ms");
+    REQUIRE(FormatElapsedTime(0.0) == "0.000ms");
+    REQUIRE(FormatElapsedTime(0.5) == "500.000ms");
+    REQUIRE(FormatElapsedTime(0.999) == "999.000ms");
+}
+
+TEST_CASE("Durations between 1 and 60 seconds report seconds", "[time][issue351]") {
+    REQUIRE(FormatElapsedTime(1.0) == "1.000s");
+    REQUIRE(FormatElapsedTime(12.580) == "12.580s");
+    REQUIRE(FormatElapsedTime(59.999) == "59.999s");
+}
+
+TEST_CASE("Durations of 60 seconds or more report hh:mm:ss", "[time][issue351]") {
+    REQUIRE(FormatElapsedTime(60.0) == "00:01:00");
+    REQUIRE(FormatElapsedTime(68.0) == "00:01:08");
+    REQUIRE(FormatElapsedTime(139.419) == "00:02:19");
+    REQUIRE(FormatElapsedTime(3600.0) == "01:00:00");
+    REQUIRE(FormatElapsedTime(5841.0) == "01:37:21");
+    REQUIRE(FormatElapsedTime(26697.777) == "07:24:57");
+    REQUIRE(FormatElapsedTime(36000.0) == "10:00:00");
+}
diff --git a/tests/test_matrix.cpp b/tests/test_matrix.cpp
index c96d32dfa..ae7169cfd 100644
--- a/tests/test_matrix.cpp
+++ b/tests/test_matrix.cpp
@@ -22,6 +22,7 @@
 #define TESTING_MAIN
 
 #include <cmath>
+#include <sstream>
 #include <stdexcept>
 
 #include "math/dnamatrix_contiguous.hpp"
@@ -587,3 +588,947 @@ TEST_CASE("Cholesky inverse with LOWER_IS_CLEARED", "[matrix_2d]") {
     REQUIRE(abs(inverse.get(0, 2) - inverse.get(2, 0)) < 1e-10);
     REQUIRE(abs(inverse.get(1, 2) - inverse.get(2, 1)) < 1e-10);
 }
+
+// ============================================================================
+// Symmetric matrix support
+// ============================================================================
+
+TEST_CASE("Symmetric flag default is false", "[matrix_2d][symmetric]") {
+    matrix_2d mat(3, 3);
+    REQUIRE(mat.is_symmetric() == false);
+}
+
+TEST_CASE("Symmetric flag set and get", "[matrix_2d][symmetric]") {
+    matrix_2d mat(3, 3);
+    mat.set_symmetric(true);
+    REQUIRE(mat.is_symmetric() == true);
+    mat.set_symmetric(false);
+    REQUIRE(mat.is_symmetric() == false);
+}
+
+TEST_CASE("Symmetric flag propagates through copy constructor", "[matrix_2d][symmetric]") {
+    matrix_2d mat(3, 3);
+    mat.put(0, 0, 1.0); mat.put(1, 0, 2.0); mat.put(1, 1, 3.0);
+    mat.put(2, 0, 4.0); mat.put(2, 1, 5.0); mat.put(2, 2, 6.0);
+    mat.set_symmetric(true);
+
+    matrix_2d copy(mat);
+    REQUIRE(copy.is_symmetric() == true);
+    REQUIRE(copy.get(0, 1) == 2.0);  // reflects from lower
+}
+
+TEST_CASE("Symmetric flag propagates through operator=", "[matrix_2d][symmetric]") {
+    matrix_2d mat(3, 3);
+    mat.put(0, 0, 1.0); mat.put(1, 0, 2.0); mat.put(1, 1, 3.0);
+    mat.set_symmetric(true);
+
+    matrix_2d other(3, 3);
+    other = mat;
+    REQUIRE(other.is_symmetric() == true);
+    REQUIRE(other.get(0, 1) == 2.0);
+}
+
+TEST_CASE("Symmetric get reflects upper to lower", "[matrix_2d][symmetric]") {
+    // Populate only the lower triangle + diagonal
+    matrix_2d mat(4, 4);
+    mat.put(0, 0, 1.0);
+    mat.put(1, 0, 2.0); mat.put(1, 1, 3.0);
+    mat.put(2, 0, 4.0); mat.put(2, 1, 5.0); mat.put(2, 2, 6.0);
+    mat.put(3, 0, 7.0); mat.put(3, 1, 8.0); mat.put(3, 2, 9.0); mat.put(3, 3, 10.0);
+    mat.set_symmetric(true);
+
+    // Diagonal
+    REQUIRE(mat.get(0, 0) == 1.0);
+    REQUIRE(mat.get(1, 1) == 3.0);
+    REQUIRE(mat.get(2, 2) == 6.0);
+    REQUIRE(mat.get(3, 3) == 10.0);
+
+    // Lower triangle (direct)
+    REQUIRE(mat.get(1, 0) == 2.0);
+    REQUIRE(mat.get(2, 0) == 4.0);
+    REQUIRE(mat.get(3, 2) == 9.0);
+
+    // Upper triangle (reflected from lower)
+    REQUIRE(mat.get(0, 1) == 2.0);
+    REQUIRE(mat.get(0, 2) == 4.0);
+    REQUIRE(mat.get(0, 3) == 7.0);
+    REQUIRE(mat.get(1, 2) == 5.0);
+    REQUIRE(mat.get(1, 3) == 8.0);
+    REQUIRE(mat.get(2, 3) == 9.0);
+}
+
+TEST_CASE("Symmetric getelementref reflects upper to lower", "[matrix_2d][symmetric]") {
+    matrix_2d mat(3, 3);
+    mat.put(0, 0, 10.0);
+    mat.put(1, 0, 20.0); mat.put(1, 1, 30.0);
+    mat.put(2, 0, 40.0); mat.put(2, 1, 50.0); mat.put(2, 2, 60.0);
+    mat.set_symmetric(true);
+
+    // const version
+    const matrix_2d& cmat = mat;
+    REQUIRE(*cmat.getelementref(0, 2) == 40.0);  // reflects (0,2) -> (2,0)
+    REQUIRE(*cmat.getelementref(2, 0) == 40.0);  // direct
+
+    // non-const version
+    REQUIRE(*mat.getelementref(1, 2) == 50.0);   // reflects (1,2) -> (2,1)
+}
+
+TEST_CASE("Symmetric redim clears flag", "[matrix_2d][symmetric]") {
+    matrix_2d mat(3, 3);
+    mat.set_symmetric(true);
+    mat.redim(4, 4);
+    REQUIRE(mat.is_symmetric() == false);
+}
+
+TEST_CASE("Cholesky inverse with mark_symmetric", "[matrix_2d][symmetric]") {
+    matrix_2d mat(3, 3);
+    mat.put(0, 0, 4.0);
+    mat.put(0, 1, -1.0);
+    mat.put(0, 2, -1.0);
+    mat.put(1, 0, -1.0);
+    mat.put(1, 1, 3.0);
+    mat.put(1, 2, -1.0);
+    mat.put(2, 0, -1.0);
+    mat.put(2, 1, -1.0);
+    mat.put(2, 2, 2.0);
+
+    matrix_2d inverse = mat.cholesky_inverse(false, true);
+
+    REQUIRE(inverse.is_symmetric() == true);
+    // Values should match the non-symmetric cholesky inverse
+    REQUIRE(abs(inverse.get(0, 0) - 0.384615) < 0.0001);
+    REQUIRE(abs(inverse.get(1, 1) - 0.538462) < 0.0001);
+    REQUIRE(abs(inverse.get(2, 2) - 0.846154) < 0.0001);
+    // Upper triangle via symmetric reflection
+    REQUIRE(abs(inverse.get(0, 1) - 0.230769) < 0.0001);
+    REQUIRE(abs(inverse.get(0, 2) - 0.307692) < 0.0001);
+    REQUIRE(abs(inverse.get(1, 2) - 0.384615) < 0.0001);
+    // Symmetry
+    REQUIRE(abs(inverse.get(0, 1) - inverse.get(1, 0)) < 1e-10);
+    REQUIRE(abs(inverse.get(0, 2) - inverse.get(2, 0)) < 1e-10);
+    REQUIRE(abs(inverse.get(1, 2) - inverse.get(2, 1)) < 1e-10);
+}
+
+TEST_CASE("Cholesky mark_symmetric matches full inverse", "[matrix_2d][symmetric]") {
+    // Larger 5x5 SPD matrix
+    matrix_2d full(5, 5);
+    matrix_2d sym(5, 5);
+    double spd[] = {
+        10, 1, 2, 0, 1,
+         1, 8, 1, 2, 0,
+         2, 1, 7, 1, 1,
+         0, 2, 1, 6, 1,
+         1, 0, 1, 1, 5
+    };
+    for (UINT32 i = 0; i < 5; ++i)
+        for (UINT32 j = 0; j < 5; ++j) {
+            full.put(i, j, spd[i * 5 + j]);
+            sym.put(i, j, spd[i * 5 + j]);
+        }
+
+    full.cholesky_inverse(false, false);  // full inverse with fillupper
+    sym.cholesky_inverse(false, true);    // symmetric inverse
+
+    REQUIRE(sym.is_symmetric() == true);
+    REQUIRE(full.is_symmetric() == false);
+
+    // All elements should match
+    for (UINT32 i = 0; i < 5; ++i)
+        for (UINT32 j = 0; j < 5; ++j)
+            REQUIRE(abs(sym.get(i, j) - full.get(i, j)) < 1e-12);
+}
+
+TEST_CASE("multiply_sym matches dgemm multiply", "[matrix_2d][symmetric]") {
+    // Create a symmetric 4x4 matrix and a 4x2 rhs
+    matrix_2d A(4, 4);
+    double spd[] = {
+        5, 1, 2, 0,
+        1, 4, 1, 1,
+        2, 1, 6, 1,
+        0, 1, 1, 3
+    };
+    for (UINT32 i = 0; i < 4; ++i)
+        for (UINT32 j = 0; j < 4; ++j)
+            A.put(i, j, spd[i * 4 + j]);
+
+    matrix_2d B(4, 2);
+    B.put(0, 0, 1.0); B.put(0, 1, 5.0);
+    B.put(1, 0, 2.0); B.put(1, 1, 6.0);
+    B.put(2, 0, 3.0); B.put(2, 1, 7.0);
+    B.put(3, 0, 4.0); B.put(3, 1, 8.0);
+
+    // dgemm result
+    matrix_2d C_full(4, 2);
+    C_full.multiply(A, "N", B, "N");
+
+    // dsymm result — only lower triangle in A_sym
+    matrix_2d A_sym(4, 4);
+    for (UINT32 i = 0; i < 4; ++i)
+        for (UINT32 j = 0; j <= i; ++j)
+            A_sym.put(i, j, spd[i * 4 + j]);
+    A_sym.set_symmetric(true);
+
+    matrix_2d C_sym(4, 2);
+    C_sym.multiply_sym(A_sym, B);
+
+    for (UINT32 i = 0; i < 4; ++i)
+        for (UINT32 j = 0; j < 2; ++j)
+            REQUIRE(abs(C_sym.get(i, j) - C_full.get(i, j)) < 1e-12);
+}
+
+TEST_CASE("multiply_sym with column vector", "[matrix_2d][symmetric]") {
+    // This mirrors the Solve() hot path: N_inv * At_Vinv_m
+    matrix_2d N(3, 3);
+    N.put(0, 0, 4.0);
+    N.put(0, 1, -1.0);
+    N.put(0, 2, -1.0);
+    N.put(1, 0, -1.0);
+    N.put(1, 1, 3.0);
+    N.put(1, 2, -1.0);
+    N.put(2, 0, -1.0);
+    N.put(2, 1, -1.0);
+    N.put(2, 2, 2.0);
+
+    // Full inverse
+    matrix_2d N_full(N);
+    N_full.cholesky_inverse(false, false);
+
+    // Symmetric inverse
+    matrix_2d N_sym(N);
+    N_sym.cholesky_inverse(false, true);
+
+    matrix_2d rhs(3, 1);
+    rhs.put(0, 0, 1.0);
+    rhs.put(1, 0, 2.0);
+    rhs.put(2, 0, 3.0);
+
+    // dgemm
+    matrix_2d result_full(3, 1);
+    result_full.multiply(N_full, "N", rhs, "N");
+
+    // dsymm
+    matrix_2d result_sym(3, 1);
+    result_sym.multiply_sym(N_sym, rhs);
+
+    for (UINT32 i = 0; i < 3; ++i)
+        REQUIRE(abs(result_sym.get(i, 0) - result_full.get(i, 0)) < 1e-12);
+}
+
+TEST_CASE("Symmetric copyelements 3x3 from lower triangle", "[matrix_2d][symmetric]") {
+    matrix_2d src(6, 6);
+    // Fill lower triangle only
+    for (UINT32 i = 0; i < 6; ++i)
+        for (UINT32 j = 0; j <= i; ++j)
+            src.put(i, j, static_cast<double>(i * 10 + j));
+    src.set_symmetric(true);
+
+    matrix_2d dst(3, 3);
+
+    // Copy from lower triangle region (row >= col) — should work directly
+    dst.copyelements(0, 0, src, 3, 0, 3, 3);
+    REQUIRE(dst.get(0, 0) == 30.0);
+    REQUIRE(dst.get(1, 0) == 40.0);
+    REQUIRE(dst.get(2, 0) == 50.0);
+    REQUIRE(dst.get(0, 1) == 31.0);
+    REQUIRE(dst.get(1, 1) == 41.0);
+    REQUIRE(dst.get(2, 1) == 51.0);
+    REQUIRE(dst.get(0, 2) == 32.0);
+    REQUIRE(dst.get(1, 2) == 42.0);
+    REQUIRE(dst.get(2, 2) == 52.0);
+}
+
+TEST_CASE("Symmetric copyelements 3x3 from upper triangle", "[matrix_2d][symmetric]") {
+    matrix_2d src(6, 6);
+    // Fill lower triangle only: src(i,j) = i*10+j for j<=i
+    for (UINT32 i = 0; i < 6; ++i)
+        for (UINT32 j = 0; j <= i; ++j)
+            src.put(i, j, static_cast<double>(i * 10 + j));
+    src.set_symmetric(true);
+
+    matrix_2d dst(3, 3);
+
+    // Copy from upper triangle region (row_src=0, col_src=3)
+    // dst(r,c) = src.get(r, 3+c) which reflects to src(3+c, r) = (3+c)*10 + r
+    dst.copyelements(0, 0, src, 0, 3, 3, 3);
+    REQUIRE(dst.get(0, 0) == 30.0);  // src.get(0,3) = src(3,0) = 30
+    REQUIRE(dst.get(1, 0) == 31.0);  // src.get(1,3) = src(3,1) = 31
+    REQUIRE(dst.get(2, 0) == 32.0);  // src.get(2,3) = src(3,2) = 32
+    REQUIRE(dst.get(0, 1) == 40.0);  // src.get(0,4) = src(4,0) = 40
+    REQUIRE(dst.get(1, 1) == 41.0);  // src.get(1,4) = src(4,1) = 41
+    REQUIRE(dst.get(2, 1) == 42.0);  // src.get(2,4) = src(4,2) = 42
+    REQUIRE(dst.get(0, 2) == 50.0);  // src.get(0,5) = src(5,0) = 50
+    REQUIRE(dst.get(1, 2) == 51.0);  // src.get(1,5) = src(5,1) = 51
+    REQUIRE(dst.get(2, 2) == 52.0);  // src.get(2,5) = src(5,2) = 52
+}
+
+TEST_CASE("Symmetric blockadd 3x3 from upper triangle", "[matrix_2d][symmetric]") {
+    matrix_2d src(6, 6);
+    for (UINT32 i = 0; i < 6; ++i)
+        for (UINT32 j = 0; j <= i; ++j)
+            src.put(i, j, static_cast<double>(i * 10 + j));
+    src.set_symmetric(true);
+
+    matrix_2d dst(3, 3);
+    // Pre-fill with 1.0 to verify addition
+    for (UINT32 i = 0; i < 3; ++i)
+        for (UINT32 j = 0; j < 3; ++j)
+            dst.put(i, j, 1.0);
+
+    // blockadd from upper triangle (row_src=0, col_src=3)
+    dst.blockadd(0, 0, src, 0, 3, 3, 3);
+
+    // dst(r,c) = 1.0 + src.get(r, 3+c)
+    REQUIRE(dst.get(0, 0) == 31.0);  // 1 + 30
+    REQUIRE(dst.get(1, 0) == 32.0);  // 1 + 31
+    REQUIRE(dst.get(2, 0) == 33.0);  // 1 + 32
+    REQUIRE(dst.get(0, 1) == 41.0);  // 1 + 40
+    REQUIRE(dst.get(1, 1) == 42.0);  // 1 + 41
+    REQUIRE(dst.get(2, 1) == 43.0);  // 1 + 42
+    REQUIRE(dst.get(0, 2) == 51.0);  // 1 + 50
+    REQUIRE(dst.get(1, 2) == 52.0);  // 1 + 51
+    REQUIRE(dst.get(2, 2) == 53.0);  // 1 + 52
+}
+
+TEST_CASE("Symmetric copyelements generic from upper triangle", "[matrix_2d][symmetric]") {
+    matrix_2d src(8, 8);
+    for (UINT32 i = 0; i < 8; ++i)
+        for (UINT32 j = 0; j <= i; ++j)
+            src.put(i, j, static_cast<double>(i * 10 + j));
+    src.set_symmetric(true);
+
+    // Copy a 4x4 block from upper triangle (row=0, col=4)
+    matrix_2d dst(4, 4);
+    dst.copyelements(0, 0, src, 0, 4, 4, 4);
+
+    // Verify via get() which handles reflection
+    for (UINT32 i = 0; i < 4; ++i)
+        for (UINT32 j = 0; j < 4; ++j)
+            REQUIRE(abs(dst.get(i, j) - src.get(i, 4 + j)) < 1e-15);
+}
+
+TEST_CASE("End-to-end: cholesky mark_symmetric then multiply_sym", "[matrix_2d][symmetric]") {
+    // Simulate the full Solve() path
+    matrix_2d N(3, 3);
+    N.put(0, 0, 4.0);  N.put(0, 1, -1.0); N.put(0, 2, -1.0);
+    N.put(1, 0, -1.0); N.put(1, 1, 3.0);  N.put(1, 2, -1.0);
+    N.put(2, 0, -1.0); N.put(2, 1, -1.0); N.put(2, 2, 2.0);
+
+    matrix_2d N_ref(N);
+
+    // Reference: full inverse + dgemm
+    N_ref.cholesky_inverse(false, false);
+
+    matrix_2d rhs(3, 1);
+    rhs.put(0, 0, 10.0);
+    rhs.put(1, 0, 20.0);
+    rhs.put(2, 0, 30.0);
+
+    matrix_2d ref_result(3, 1);
+    ref_result.multiply(N_ref, "N", rhs, "N");
+
+    // Test: symmetric inverse + dsymm
+    N.cholesky_inverse(false, true);
+    REQUIRE(N.is_symmetric() == true);
+
+    matrix_2d sym_result(3, 1);
+    sym_result.multiply_sym(N, rhs);
+
+    for (UINT32 i = 0; i < 3; ++i)
+        REQUIRE(abs(sym_result.get(i, 0) - ref_result.get(i, 0)) < 1e-12);
+}
+
+// ============================================================================
+// Packed symmetric matrix storage
+// ============================================================================
+
+TEST_CASE("Packed allocation has correct buffer size", "[matrix_2d][packed]") {
+    matrix_2d mat;
+    mat.redim_packed(4);
+    REQUIRE(mat.rows() == 4);
+    REQUIRE(mat.columns() == 4);
+    REQUIRE(mat.is_packed() == true);
+    REQUIRE(mat.is_symmetric() == true);
+    // n*(n+1)/2 = 10 elements
+    REQUIRE(mat.memRows() == 4);
+}
+
+TEST_CASE("Packed element access: put and get reflect symmetry", "[matrix_2d][packed]") {
+    matrix_2d mat;
+    mat.redim_packed(4);
+
+    mat.put(0, 0, 1.0);
+    mat.put(1, 0, 2.0); mat.put(1, 1, 3.0);
+    mat.put(2, 0, 4.0); mat.put(2, 1, 5.0); mat.put(2, 2, 6.0);
+    mat.put(3, 0, 7.0); mat.put(3, 1, 8.0); mat.put(3, 2, 9.0); mat.put(3, 3, 10.0);
+
+    // Diagonal
+    REQUIRE(mat.get(0, 0) == 1.0);
+    REQUIRE(mat.get(1, 1) == 3.0);
+    REQUIRE(mat.get(2, 2) == 6.0);
+    REQUIRE(mat.get(3, 3) == 10.0);
+
+    // Lower triangle (direct)
+    REQUIRE(mat.get(1, 0) == 2.0);
+    REQUIRE(mat.get(2, 0) == 4.0);
+    REQUIRE(mat.get(3, 2) == 9.0);
+
+    // Upper triangle (reflected from lower)
+    REQUIRE(mat.get(0, 1) == 2.0);
+    REQUIRE(mat.get(0, 2) == 4.0);
+    REQUIRE(mat.get(0, 3) == 7.0);
+    REQUIRE(mat.get(1, 2) == 5.0);
+    REQUIRE(mat.get(1, 3) == 8.0);
+    REQUIRE(mat.get(2, 3) == 9.0);
+}
+
+TEST_CASE("Packed put via upper triangle maps to lower", "[matrix_2d][packed]") {
+    matrix_2d mat;
+    mat.redim_packed(3);
+
+    mat.put(0, 1, 42.0);
+    REQUIRE(mat.get(1, 0) == 42.0);
+    REQUIRE(mat.get(0, 1) == 42.0);
+}
+
+TEST_CASE("Packed elementadd skips upper triangle", "[matrix_2d][packed]") {
+    matrix_2d mat;
+    mat.redim_packed(3);
+
+    mat.elementadd(1, 0, 10.0);
+    mat.elementadd(0, 1, 5.0);  // skipped — upper triangle
+    REQUIRE(mat.get(1, 0) == 10.0);
+    REQUIRE(mat.get(0, 1) == 10.0);
+
+    mat.elementadd(1, 0, 3.0);  // lower triangle — accumulates
+    REQUIRE(mat.get(1, 0) == 13.0);
+}
+
+TEST_CASE("Packed cholesky_inverse matches full inverse", "[matrix_2d][packed]") {
+    matrix_2d full(3, 3);
+    full.put(0, 0, 4.0);  full.put(0, 1, -1.0); full.put(0, 2, -1.0);
+    full.put(1, 0, -1.0); full.put(1, 1, 3.0);  full.put(1, 2, -1.0);
+    full.put(2, 0, -1.0); full.put(2, 1, -1.0); full.put(2, 2, 2.0);
+
+    matrix_2d packed;
+    packed.redim_packed(3);
+    packed.put(0, 0, 4.0);
+    packed.put(1, 0, -1.0); packed.put(1, 1, 3.0);
+    packed.put(2, 0, -1.0); packed.put(2, 1, -1.0); packed.put(2, 2, 2.0);
+
+    full.cholesky_inverse();
+    packed.cholesky_inverse();
+
+    REQUIRE(packed.is_packed() == true);
+    for (UINT32 i = 0; i < 3; ++i)
+        for (UINT32 j = 0; j < 3; ++j)
+            REQUIRE(abs(packed.get(i, j) - full.get(i, j)) < 1e-10);
+}
+
+TEST_CASE("Packed cholesky_inverse throws on indefinite matrix", "[matrix_2d][packed]") {
+    matrix_2d mat;
+    mat.redim_packed(2);
+    mat.put(0, 0, 2.0);
+    mat.put(1, 0, 1.0);
+    mat.put(1, 1, -1.0);
+
+    bool caught = false;
+    try { mat.cholesky_inverse(); }
+    catch (const MatrixInversionFailure&) { caught = true; }
+    REQUIRE(caught);
+}
+
+TEST_CASE("Packed multiply_sym with vector matches full result", "[matrix_2d][packed]") {
+    matrix_2d full(3, 3);
+    full.put(0, 0, 4.0);  full.put(0, 1, -1.0); full.put(0, 2, -1.0);
+    full.put(1, 0, -1.0); full.put(1, 1, 3.0);  full.put(1, 2, -1.0);
+    full.put(2, 0, -1.0); full.put(2, 1, -1.0); full.put(2, 2, 2.0);
+
+    matrix_2d packed;
+    packed.redim_packed(3);
+    packed.put(0, 0, 4.0);
+    packed.put(1, 0, -1.0); packed.put(1, 1, 3.0);
+    packed.put(2, 0, -1.0); packed.put(2, 1, -1.0); packed.put(2, 2, 2.0);
+
+    matrix_2d rhs(3, 1);
+    rhs.put(0, 0, 1.0); rhs.put(1, 0, 2.0); rhs.put(2, 0, 3.0);
+
+    matrix_2d result_full(3, 1);
+    result_full.multiply(full, "N", rhs, "N");
+
+    matrix_2d result_packed(3, 1);
+    result_packed.multiply_sym(packed, rhs);
+
+    for (UINT32 i = 0; i < 3; ++i)
+        REQUIRE(abs(result_packed.get(i, 0) - result_full.get(i, 0)) < 1e-12);
+}
+
+TEST_CASE("Packed multiply_sym with multi-column rhs", "[matrix_2d][packed]") {
+    matrix_2d packed;
+    packed.redim_packed(4);
+    double spd[] = {5, 1, 2, 0, 1, 4, 1, 1, 2, 1, 6, 1, 0, 1, 1, 3};
+    for (UINT32 i = 0; i < 4; ++i)
+        for (UINT32 j = 0; j <= i; ++j)
+            packed.put(i, j, spd[i * 4 + j]);
+
+    matrix_2d full(4, 4);
+    for (UINT32 i = 0; i < 4; ++i)
+        for (UINT32 j = 0; j < 4; ++j)
+            full.put(i, j, spd[i * 4 + j]);
+
+    matrix_2d B(4, 2);
+    B.put(0, 0, 1.0); B.put(0, 1, 5.0);
+    B.put(1, 0, 2.0); B.put(1, 1, 6.0);
+    B.put(2, 0, 3.0); B.put(2, 1, 7.0);
+    B.put(3, 0, 4.0); B.put(3, 1, 8.0);
+
+    matrix_2d C_full(4, 2);
+    C_full.multiply(full, "N", B, "N");
+
+    matrix_2d C_packed(4, 2);
+    C_packed.multiply_sym(packed, B);
+
+    for (UINT32 i = 0; i < 4; ++i)
+        for (UINT32 j = 0; j < 2; ++j)
+            REQUIRE(abs(C_packed.get(i, j) - C_full.get(i, j)) < 1e-12);
+}
+
+TEST_CASE("Packed scale_symmetric_diagonal", "[matrix_2d][packed]") {
+    matrix_2d packed;
+    packed.redim_packed(3);
+    packed.put(0, 0, 4.0);
+    packed.put(1, 0, -1.0); packed.put(1, 1, 3.0);
+    packed.put(2, 0, -1.0); packed.put(2, 1, -1.0); packed.put(2, 2, 2.0);
+
+    matrix_2d full(3, 3);
+    full.put(0, 0, 4.0);  full.put(0, 1, -1.0); full.put(0, 2, -1.0);
+    full.put(1, 0, -1.0); full.put(1, 1, 3.0);  full.put(1, 2, -1.0);
+    full.put(2, 0, -1.0); full.put(2, 1, -1.0); full.put(2, 2, 2.0);
+    full.set_symmetric(true);
+
+    double diag[] = {2.0, 3.0, 0.5};
+    packed.scale_symmetric_diagonal(diag);
+    full.scale_symmetric_diagonal(diag);
+
+    for (UINT32 i = 0; i < 3; ++i)
+        for (UINT32 j = 0; j < 3; ++j)
+            REQUIRE(abs(packed.get(i, j) - full.get(i, j)) < 1e-12);
+}
+
+TEST_CASE("Packed blockadd diagonal block", "[matrix_2d][packed]") {
+    matrix_2d packed;
+    packed.redim_packed(4);
+
+    // Diagonal blocks only write lower triangle via elementadd
+    // (mirrors how AddMsrtoNormalsVar works)
+    packed.elementadd(1, 1, 10.0);
+    packed.elementadd(2, 1, 20.0);
+    packed.elementadd(2, 2, 40.0);
+
+    REQUIRE(packed.get(1, 1) == 10.0);
+    REQUIRE(packed.get(2, 1) == 20.0);
+    REQUIRE(packed.get(1, 2) == 20.0);
+    REQUIRE(packed.get(2, 2) == 40.0);
+    REQUIRE(packed.get(0, 0) == 0.0);
+}
+
+TEST_CASE("Packed submatrix extraction", "[matrix_2d][packed]") {
+    matrix_2d packed;
+    packed.redim_packed(4);
+    packed.put(0, 0, 1.0);
+    packed.put(1, 0, 2.0); packed.put(1, 1, 3.0);
+    packed.put(2, 0, 4.0); packed.put(2, 1, 5.0); packed.put(2, 2, 6.0);
+    packed.put(3, 0, 7.0); packed.put(3, 1, 8.0); packed.put(3, 2, 9.0); packed.put(3, 3, 10.0);
+
+    matrix_2d sub = packed.submatrix(1, 1, 2, 2);
+    REQUIRE(sub.rows() == 2);
+    REQUIRE(sub.columns() == 2);
+    REQUIRE(sub.get(0, 0) == 3.0);
+    REQUIRE(sub.get(0, 1) == 5.0);
+    REQUIRE(sub.get(1, 0) == 5.0);
+    REQUIRE(sub.get(1, 1) == 6.0);
+}
+
+TEST_CASE("Packed copy constructor", "[matrix_2d][packed]") {
+    matrix_2d orig;
+    orig.redim_packed(3);
+    orig.put(0, 0, 1.0);
+    orig.put(1, 0, 2.0); orig.put(1, 1, 3.0);
+    orig.put(2, 0, 4.0); orig.put(2, 1, 5.0); orig.put(2, 2, 6.0);
+
+    matrix_2d copy(orig);
+    REQUIRE(copy.is_packed() == true);
+    REQUIRE(copy.is_symmetric() == true);
+    for (UINT32 i = 0; i < 3; ++i)
+        for (UINT32 j = 0; j < 3; ++j)
+            REQUIRE(copy.get(i, j) == orig.get(i, j));
+}
+
+TEST_CASE("Packed operator= packed-to-packed", "[matrix_2d][packed]") {
+    matrix_2d a;
+    a.redim_packed(3);
+    a.put(0, 0, 10.0); a.put(1, 0, 20.0); a.put(1, 1, 30.0);
+    a.put(2, 0, 40.0); a.put(2, 1, 50.0); a.put(2, 2, 60.0);
+
+    matrix_2d b;
+    b.redim_packed(2);
+    b = a;
+    REQUIRE(b.is_packed() == true);
+    REQUIRE(b.rows() == 3);
+    for (UINT32 i = 0; i < 3; ++i)
+        for (UINT32 j = 0; j < 3; ++j)
+            REQUIRE(b.get(i, j) == a.get(i, j));
+}
+
+TEST_CASE("Packed operator= full-to-packed preserves full", "[matrix_2d][packed]") {
+    matrix_2d full(3, 3);
+    full.put(0, 0, 1.0); full.put(0, 1, 2.0); full.put(0, 2, 3.0);
+    full.put(1, 0, 4.0); full.put(1, 1, 5.0); full.put(1, 2, 6.0);
+    full.put(2, 0, 7.0); full.put(2, 1, 8.0); full.put(2, 2, 9.0);
+
+    matrix_2d packed;
+    packed.redim_packed(3);
+    packed = full;
+    // Assigning a non-packed to a packed should convert to non-packed
+    REQUIRE(packed.is_packed() == false);
+    for (UINT32 i = 0; i < 3; ++i)
+        for (UINT32 j = 0; j < 3; ++j)
+            REQUIRE(packed.get(i, j) == full.get(i, j));
+}
+
+TEST_CASE("Packed redim_packed reuses buffer when shrinking", "[matrix_2d][packed]") {
+    matrix_2d mat;
+    mat.redim_packed(5);
+    mat.put(0, 0, 99.0);
+
+    mat.redim_packed(3);
+    REQUIRE(mat.rows() == 3);
+    REQUIRE(mat.is_packed() == true);
+    REQUIRE(mat.get(0, 0) == 0.0);
+}
+
+TEST_CASE("Packed zero", "[matrix_2d][packed]") {
+    matrix_2d mat;
+    mat.redim_packed(3);
+    mat.put(0, 0, 1.0); mat.put(1, 0, 2.0); mat.put(2, 2, 3.0);
+    mat.zero();
+    for (UINT32 i = 0; i < 3; ++i)
+        for (UINT32 j = 0; j < 3; ++j)
+            REQUIRE(mat.get(i, j) == 0.0);
+}
+
+TEST_CASE("Packed scale", "[matrix_2d][packed]") {
+    matrix_2d mat;
+    mat.redim_packed(3);
+    mat.put(0, 0, 2.0);
+    mat.put(1, 0, 3.0); mat.put(1, 1, 4.0);
+    mat.put(2, 0, 5.0); mat.put(2, 1, 6.0); mat.put(2, 2, 7.0);
+    mat.scale(2.0);
+
+    REQUIRE(mat.get(0, 0) == 4.0);
+    REQUIRE(mat.get(1, 0) == 6.0);
+    REQUIRE(mat.get(2, 2) == 14.0);
+    REQUIRE(mat.get(0, 1) == 6.0); // reflected
+}
+
+TEST_CASE("Packed end-to-end: cholesky then multiply_sym", "[matrix_2d][packed]") {
+    matrix_2d full(3, 3);
+    full.put(0, 0, 4.0);  full.put(0, 1, -1.0); full.put(0, 2, -1.0);
+    full.put(1, 0, -1.0); full.put(1, 1, 3.0);  full.put(1, 2, -1.0);
+    full.put(2, 0, -1.0); full.put(2, 1, -1.0); full.put(2, 2, 2.0);
+
+    matrix_2d packed;
+    packed.redim_packed(3);
+    packed.put(0, 0, 4.0);
+    packed.put(1, 0, -1.0); packed.put(1, 1, 3.0);
+    packed.put(2, 0, -1.0); packed.put(2, 1, -1.0); packed.put(2, 2, 2.0);
+
+    // Reference
+    full.cholesky_inverse(false, false);
+    matrix_2d rhs(3, 1);
+    rhs.put(0, 0, 10.0); rhs.put(1, 0, 20.0); rhs.put(2, 0, 30.0);
+    matrix_2d ref_result(3, 1);
+    ref_result.multiply(full, "N", rhs, "N");
+
+    // Packed path
+    packed.cholesky_inverse();
+    matrix_2d packed_result(3, 1);
+    packed_result.multiply_sym(packed, rhs);
+
+    for (UINT32 i = 0; i < 3; ++i)
+        REQUIRE(abs(packed_result.get(i, 0) - ref_result.get(i, 0)) < 1e-12);
+}
+
+TEST_CASE("Packed copyelements from packed source", "[matrix_2d][packed]") {
+    matrix_2d packed;
+    packed.redim_packed(6);
+    for (UINT32 i = 0; i < 6; ++i)
+        for (UINT32 j = 0; j <= i; ++j)
+            packed.put(i, j, static_cast<double>(i * 10 + j));
+
+    matrix_2d dst(3, 3);
+    dst.copyelements(0, 0, packed, 3, 0, 3, 3);
+
+    REQUIRE(dst.get(0, 0) == 30.0);
+    REQUIRE(dst.get(1, 0) == 40.0);
+    REQUIRE(dst.get(2, 0) == 50.0);
+    REQUIRE(dst.get(0, 1) == 31.0);
+    REQUIRE(dst.get(1, 1) == 41.0);
+    REQUIRE(dst.get(2, 1) == 51.0);
+}
+
+TEST_CASE("Packed 5x5 cholesky_inverse matches full", "[matrix_2d][packed]") {
+    double spd[] = {
+        10, 1, 2, 0, 1,
+         1, 8, 1, 2, 0,
+         2, 1, 7, 1, 1,
+         0, 2, 1, 6, 1,
+         1, 0, 1, 1, 5
+    };
+
+    matrix_2d full(5, 5);
+    matrix_2d packed;
+    packed.redim_packed(5);
+
+    for (UINT32 i = 0; i < 5; ++i)
+        for (UINT32 j = 0; j < 5; ++j) {
+            full.put(i, j, spd[i * 5 + j]);
+            if (j <= i)
+                packed.put(i, j, spd[i * 5 + j]);
+        }
+
+    full.cholesky_inverse(false, false);
+    packed.cholesky_inverse();
+
+    for (UINT32 i = 0; i < 5; ++i)
+        for (UINT32 j = 0; j < 5; ++j)
+            REQUIRE(abs(packed.get(i, j) - full.get(i, j)) < 1e-12);
+}
+
+// ================================================================
+// In-place mmap buffer tests (AttachMappedFileRegion / DetachMappedFileRegion)
+// ================================================================
+
+TEST_CASE("In-place mmap round-trip: full matrix", "[matrix_2d][mmap]") {
+    // Create a 4x3 full matrix
+    matrix_2d orig(4, 3);
+    for (UINT32 r = 0; r < 4; ++r)
+        for (UINT32 c = 0; c < 3; ++c)
+            orig.put(r, c, (r + 1) * 10.0 + c);
+    orig.compute_maximum_value();
+
+    // Allocate a buffer to simulate an mmap region
+    std::size_t region_size = orig.get_size();
+    std::vector<char> region(region_size, 0);
+    void* addr = region.data();
+
+    // Write the matrix to the "mmap" region
+    orig.WriteMappedFileRegion(addr);
+
+    // Attach in-place — should point _buffer at the data in the region
+    matrix_2d attached;
+    attached.AttachMappedFileRegion(addr);
+
+    REQUIRE(!attached.owns_buffer());
+    REQUIRE(attached.rows() == 4);
+    REQUIRE(attached.columns() == 3);
+    REQUIRE(attached.matrixType() == mtx_full);
+
+    // Verify all elements match
+    for (UINT32 r = 0; r < 4; ++r)
+        for (UINT32 c = 0; c < 3; ++c)
+            REQUIRE(attached.get(r, c) == orig.get(r, c));
+
+    // Modify in-place (writes directly to region)
+    attached.put(2, 1, 999.0);
+    REQUIRE(attached.get(2, 1) == 999.0);
+
+    // Detach
+    attached.DetachMappedFileRegion(addr);
+    REQUIRE(attached.empty());
+    REQUIRE(attached.owns_buffer());
+
+    // Read back with copy-based Read to verify data persisted
+    matrix_2d readback;
+    readback.ReadMappedFileRegion(addr);
+    REQUIRE(readback.get(2, 1) == 999.0);
+    REQUIRE(readback.get(0, 0) == 10.0);
+}
+
+TEST_CASE("In-place mmap round-trip: packed lower-triangular", "[matrix_2d][mmap][packed]") {
+    // Create a 4x4 packed lower-triangular matrix
+    matrix_2d orig;
+    orig.redim_packed(4);
+    for (UINT32 i = 0; i < 4; ++i)
+        for (UINT32 j = 0; j <= i; ++j)
+            orig.put(i, j, (i + 1) * 10.0 + j);
+    orig.compute_maximum_value();
+
+    std::size_t region_size = orig.get_size();
+    std::vector<char> region(region_size, 0);
+    void* addr = region.data();
+
+    orig.WriteMappedFileRegion(addr);
+
+    matrix_2d attached;
+    attached.AttachMappedFileRegion(addr);
+
+    REQUIRE(!attached.owns_buffer());
+    REQUIRE(attached.is_packed());
+    REQUIRE(attached.is_symmetric());
+    REQUIRE(attached.rows() == 4);
+
+    // Verify all elements
+    for (UINT32 i = 0; i < 4; ++i)
+        for (UINT32 j = 0; j <= i; ++j)
+            REQUIRE(attached.get(i, j) == orig.get(i, j));
+
+    // Symmetry: upper = lower
+    REQUIRE(attached.get(0, 1) == attached.get(1, 0));
+
+    // Modify in-place
+    attached.put(3, 0, -7.5);
+
+    // WriteMappedFileRegion on in-place buffer should only write footer
+    attached.WriteMappedFileRegion(addr);
+
+    // deallocate detaches without freeing
+    attached.deallocate();
+    REQUIRE(attached.empty());
+    REQUIRE(attached.owns_buffer());
+
+    // Read back to verify
+    matrix_2d readback;
+    readback.ReadMappedFileRegion(addr);
+    REQUIRE(readback.get(3, 0) == -7.5);
+    REQUIRE(readback.get(1, 0) == 20.0);
+}
+
+TEST_CASE("In-place mmap: deallocate does not crash", "[matrix_2d][mmap]") {
+    matrix_2d orig(3, 3);
+    for (UINT32 i = 0; i < 9; ++i)
+        orig.put(i / 3, i % 3, i + 1.0);
+
+    std::size_t region_size = orig.get_size();
+    std::vector<char> region(region_size, 0);
+    void* addr = region.data();
+    orig.WriteMappedFileRegion(addr);
+
+    matrix_2d attached;
+    attached.AttachMappedFileRegion(addr);
+    REQUIRE(!attached.owns_buffer());
+
+    // deallocate should not crash (no delete[] on mmap pointer)
+    attached.deallocate();
+    REQUIRE(attached.empty());
+    REQUIRE(attached.owns_buffer());
+
+    // Re-attach and verify data still intact
+    attached.AttachMappedFileRegion(addr);
+    REQUIRE(attached.get(1, 1) == 5.0);
+    attached.deallocate();
+}
+
+TEST_CASE("In-place mmap: copy constructor makes owned copy", "[matrix_2d][mmap]") {
+    matrix_2d orig(2, 2);
+    orig.put(0, 0, 1.0); orig.put(0, 1, 2.0);
+    orig.put(1, 0, 3.0); orig.put(1, 1, 4.0);
+
+    std::size_t region_size = orig.get_size();
+    std::vector<char> region(region_size, 0);
+    void* addr = region.data();
+    orig.WriteMappedFileRegion(addr);
+
+    matrix_2d attached;
+    attached.AttachMappedFileRegion(addr);
+
+    // Copy constructor should create an owned copy
+    matrix_2d copy(attached);
+    REQUIRE(copy.owns_buffer());
+    REQUIRE(copy.get(1, 1) == 4.0);
+
+    // Modifying copy should not affect mmap
+    copy.put(1, 1, 99.0);
+    REQUIRE(attached.get(1, 1) == 4.0);
+
+    attached.deallocate();
+}
+
+TEST_CASE("In-place mmap: operator= into owned buffer", "[matrix_2d][mmap]") {
+    matrix_2d orig(3, 2);
+    for (UINT32 r = 0; r < 3; ++r)
+        for (UINT32 c = 0; c < 2; ++c)
+            orig.put(r, c, r * 2.0 + c);
+
+    std::size_t region_size = orig.get_size();
+    std::vector<char> region(region_size, 0);
+    void* addr = region.data();
+    orig.WriteMappedFileRegion(addr);
+
+    matrix_2d attached;
+    attached.AttachMappedFileRegion(addr);
+
+    // Assign to a pre-allocated owned matrix of same size
+    matrix_2d dest(3, 2);
+    dest = attached;
+    REQUIRE(dest.owns_buffer());
+    REQUIRE(dest.get(2, 1) == 5.0);
+
+    attached.deallocate();
+}
+
+TEST_CASE("In-place mmap: region size alignment", "[matrix_2d][mmap]") {
+    // Verify that get_size() returns 8-byte aligned sizes for proper mmap alignment
+    matrix_2d full(7, 5);
+    REQUIRE(full.get_size() % 8 == 0);
+
+    matrix_2d packed;
+    packed.redim_packed(11);
+    REQUIRE(packed.get_size() % 8 == 0);
+
+    matrix_2d col_vec(100, 1);
+    REQUIRE(col_vec.get_size() % 8 == 0);
+}
+
+TEST_CASE("operator<< binary size matches get_size for mmap regions", "[matrix_2d][mmap]") {
+    // Verify that operator<< writes exactly get_size() bytes in binary mode.
+    // A mismatch here causes mmap region offsets to be wrong for all blocks
+    // after the first, leading to corrupted header reads.
+
+    auto check_stream_size = [](matrix_2d& m, const std::string& label) {
+        std::ostringstream oss;
+        oss.iword(0) = binary;
+        oss << m;
+        std::size_t stream_bytes = oss.str().size();
+        std::size_t region_bytes = m.get_size();
+        REQUIRE(stream_bytes == region_bytes);
+    };
+
+    // Full matrix (column vector — the case that crashed)
+    matrix_2d col_vec(50, 1);
+    for (UINT32 r = 0; r < 50; ++r)
+        col_vec.put(r, 0, static_cast<double>(r));
+    check_stream_size(col_vec, "column vector");
+
+    // Full matrix
+    matrix_2d full(7, 5);
+    for (UINT32 r = 0; r < 7; ++r)
+        for (UINT32 c = 0; c < 5; ++c)
+            full.put(r, c, static_cast<double>(r * 10 + c));
+    check_stream_size(full, "full 7x5");
+
+    // Packed lower-triangular
+    matrix_2d packed;
+    packed.redim_packed(6);
+    for (UINT32 r = 0; r < 6; ++r)
+        for (UINT32 c = 0; c <= r; ++c)
+            packed.put(r, c, static_cast<double>(r * 10 + c));
+    check_stream_size(packed, "packed 6x6");
+
+    // Full matrix with slack (redim + shrink, simulating staged adjustment)
+    matrix_2d with_slack;
+    with_slack.redim(100, 1);
+    with_slack.shrink(30, 0);  // _rows=70, _mem_rows=100
+    for (UINT32 r = 0; r < 70; ++r)
+        with_slack.put(r, 0, static_cast<double>(r));
+    check_stream_size(with_slack, "column vector with slack");
+}